feat: 完成扫描建网大框架修改

df_datalink_ge/src/main.c

@@ -46,7 +46,7 @@
 /************************** Function Prototypes ******************************/
 int32_t SetupInterruptSystem(struct irq_ctrl_desc *descPtr);
 void Phy_IntrHandler(void *context);
-void PeriodicPull_Handler(void *callBackRef);
+void PeriodicPoll_Handler(void *callBackRef);
 void ScuTimer_IntrHandler(void *context);
 void Mpc_RxIntrHandler(void *context);
 void Mpc_TxIntrHandler(void *context);
@@ -57,9 +57,9 @@ struct callback_desc phy_callback_desc =
 	.ctx = NULL
 };
 
-struct callback_desc periodicpull_callback_desc =
+struct callback_desc periodicpoll_callback_desc =
 {
-	.callback = PeriodicPull_Handler,
+	.callback = PeriodicPoll_Handler,
 	.ctx = NULL
 };
 
@@ -246,7 +246,7 @@ int32_t SetupInterruptSystem(struct irq_ctrl_desc *descPtr)
 		return Status;
 	}
 	// Connect the interrupt service routine isr1 to the interrupt controller
-	Status = irq_register_callback(descPtr, PERIODIC_5MS_INTR_ID, &periodicpull_callback_desc);
+	Status = irq_register_callback(descPtr, PERIODIC_5MS_INTR_ID, &periodicpoll_callback_desc);
 	if (Status != SUCCESS)
 	{
 		DBG_ERROR("PHY_INTR register callback FAILED, ErrorCode: %" PRId32 ".\n", Status);
@@ -341,14 +341,14 @@ void Phy_IntrHandler(void *context)
 
 /****************************************************************************/
 /**
- * Handler of periodic 5ms interrupt
+ * Handler of periodic 2 ms interrupt
  *
  * @param    callBackRef is the linklayer instance pointer.
  *
  * @return   None.
  *
  *****************************************************************************/
-void PeriodicPull_Handler(void *callBackRef)
+void PeriodicPoll_Handler(void *callBackRef)
 {
 	int32_t Status;
 	Status = Linklayer_Proc(linkInstPtr);
@@ -357,7 +357,7 @@ void PeriodicPull_Handler(void *callBackRef)
 		DBG_ERROR("Link layer runs failed, with error code: %" PRId32 "\n", Status);
 		_nop_();
 	}
-} // PeriodicPull_Handler
+} // PeriodicPoll_Handler
 
 /*****************************************************************************/
 /**

df_datalink_sp/src/main.c

@@ -38,7 +38,7 @@
 /************************** Function Prototypes ******************************/
 int32_t SetupInterruptSystem(struct irq_ctrl_desc *descPtr);
 void Phy_IntrHandler(void *context);
-void PeriodicPull_Handler(void *callBackRef);
+void PeriodicPoll_Handler(void *callBackRef);
 void ScuTimer_IntrHandler(void *context);
 void Systembus_RxIntrHandler(void *context);
 void Systembus_TxIntrHandler(void *context);
@@ -49,8 +49,8 @@ struct callback_desc phy_callback_desc = {
 	.ctx = NULL
 };
 
-struct callback_desc periodicpull_callback_desc = {
+struct callback_desc periodicpoll_callback_desc = {
-	.callback = PeriodicPull_Handler,
+	.callback = PeriodicPoll_Handler,
 	.ctx = NULL
 };
 
@@ -190,7 +190,7 @@ int32_t SetupInterruptSystem(struct irq_ctrl_desc *descPtr)
 		return Status;
 	}
 	// Connect the interrupt service routine isr1 to the interrupt controller
-	Status = irq_register_callback(descPtr, PERIODIC_5MS_INTR_ID, &periodicpull_callback_desc);
+	Status = irq_register_callback(descPtr, PERIODIC_5MS_INTR_ID, &periodicpoll_callback_desc);
 	if (Status != SUCCESS)
 	{
 		DBG_ERROR("PHY_INTR register callback FAILED, ErrorCode: %" PRId32 ".\n", Status);
@@ -282,17 +282,16 @@ void Phy_IntrHandler(void *context)
 	Phy_UpdateState(phyInstPtr);
 } // PhyIntr_Handler
 
-
 /****************************************************************************/
 /**
- * Handler of periodic 5ms interrupt
+ * Handler of periodic 2ms interrupt
  *
  * @param    callBackRef is the linklayer instance pointer.
  *
  * @return   None.
  *
  *****************************************************************************/
-void PeriodicPull_Handler(void *callBackRef)
+void PeriodicPoll_Handler(void *callBackRef)
 {
 	int32_t Status;
 	Status = Linklayer_Proc(linkInstPtr);
@@ -301,7 +300,7 @@ void PeriodicPull_Handler(void *callBackRef)
 		DBG_ERROR("Link layer runs failed, with error code: %" PRId32 "\n", Status);
 		_nop_();
 	}
-} // PeriodicPull_Handler
+} // PeriodicPoll_Handler
 
 /*****************************************************************************/
 /**

df_datalink_sp/src/networking/link_layer/link_layer.c

@@ -33,7 +33,7 @@
 #endif
 /************************** Constant Definitions *****************************/
 #define NET_START_TIME_INFTY UINT32_MAX
-#define LINK_BROCK_THRESHOLD L2_SLOTS_PER_FRAME // 0.5 secods
+#define LINK_BROCK_THRESHOLD L2_SLOTS_PER_FRAME // 1 seconds
 
 /************************** Variable Definitions *****************************/
 /***************** Macros (Inline Functions) Definitions *********************/
@@ -59,7 +59,7 @@ inline void L2_RcdShift(L2_RCD *rcd, uint32_t netxVal)
 }
 
 /**
- * @brief	helper function to update linkelayer state
+ * @brief	helper function to update linklayer state
  */
 static inline void UpdateMainSate(L2_INST *instPtr, L2_NODE_STATE newSate)
 {
@@ -131,7 +131,7 @@ static void L2_FrameStateUpdate(L2_INST *instPtr)
 	ASSERT(instPtr != NULL);
 	PHY_INST *phyRef = instPtr->config.phyInstPtr;
 	bool isValid;
-	L2_FRAME_TYPE recvType = L2_GetLastOptFrameType(instPtr);
+	L2_FRAME_TYPE recvType = L2_GetLastFrameType(instPtr);
 	isValid = false;
 	// Update frame state.
 	if (Phy_IsFrameValid(phyRef) == false)
@@ -148,20 +148,34 @@ static void L2_FrameStateUpdate(L2_INST *instPtr)
 		// Update frame state.
 		switch (recvType)
 		{
-		case L2_SCAN_FRAME:
+		case L2_FRAME_ADV:
-		case L2_ADV_FRAME:
+			isValid = L2_CrcCheck(instPtr->recvPktData, L2_GetFrameLen(L2_FRAME_ADV, L2_SVC_NONE), L2_CRC16_1021);
-			isValid = L2_CrcCheck(instPtr->recvPktData, L2_ADV_PACK_LEN, L2_CRC16_1021);
 			instPtr->log.advRecvCnt++;
 			instPtr->log.advCorrectCnt = isValid ? instPtr->log.advCorrectCnt + 1 : instPtr->log.advCorrectCnt;
 			break;
-		case L2_CFM_FRAME:
+		case L2_FRAME_ACK:
-			isValid = L2_CrcCheck(instPtr->recvPktData, L2_CMF_PACK_LEN, L2_CRC16_1021);
+			isValid = L2_CrcCheck(instPtr->recvPktData, L2_GetFrameLen(L2_FRAME_ACK, L2_SVC_NONE), L2_CRC16_1021);
-			instPtr->log.cfmRecvCnt++;
+			instPtr->log.ackRecvCnt++;
-			instPtr->log.cfmCorrectCnt = isValid ? instPtr->log.cfmCorrectCnt + 1 : instPtr->log.cfmCorrectCnt;
+			instPtr->log.ackCorrectCnt = isValid ? instPtr->log.ackCorrectCnt + 1 : instPtr->log.ackCorrectCnt;
 			break;
-		case L2_SVC_FRAME:
+		case L2_FRAME_DIS:
+			isValid = L2_CrcCheck(instPtr->recvPktData, L2_GetFrameLen(L2_FRAME_DIS, L2_SVC_NONE), L2_CRC16_1021);
+			instPtr->log.disRecvCnt++;
+			instPtr->log.disCorrectCnt = isValid ? instPtr->log.disCorrectCnt + 1 : instPtr->log.disCorrectCnt;
+			break;
+		case L2_FRAME_MNG:
+			isValid = L2_CrcCheck(instPtr->recvPktData, L2_GetFrameLen(L2_FRAME_MNG, L2_SVC_NONE), L2_CRC16_1021);
+			instPtr->log.mngRecvCnt++;
+			instPtr->log.mngCorrectCnt = isValid ? instPtr->log.mngCorrectCnt + 1 : instPtr->log.mngCorrectCnt;
+			break;
+		case L2_FRAME_RTT:
+			isValid = L2_CrcCheck(instPtr->recvPktData, L2_GetFrameLen(L2_FRAME_RTT, L2_SVC_NONE), L2_CRC16_1021);
+			instPtr->log.rttRecvCnt++;
+			instPtr->log.rttCorrectCnt = isValid ? instPtr->log.rttCorrectCnt + 1 : instPtr->log.rttCorrectCnt;
+			break;
+		case L2_FRAME_SVC:
 #ifndef DATALINK_ENABLE_BERTEST
-			isValid = L2_CrcCheck(instPtr->recvPktData, L2_SVC_PACK_LEN, L2_CRC16_1021);
+			isValid = L2_CrcCheck(instPtr->recvPktData, L2_GetFrameLen(L2_FRAME_SVC, instPtr->config.serviceRate), L2_CRC16_1021);
 #else
 			isValid = true;
 #endif
@@ -265,9 +279,9 @@ inline bool L2_isCxn2Net(L2_INST *instPtr)
 /**
  * @brief   Get corresponding frame length in byte of L2 frame.
  */
-inline uint32_t L2_GetFrameLen(L2_FRAME_TYPE l2FrameType)
+inline uint32_t L2_GetFrameLen(L2_FRAME_TYPE l2FrameType, L2_SVC_RATE l2SvcRate)
 {
-	return Phy_GetFrameLen(L2_L2frame2L1frame(l2FrameType));
+	return Phy_GetFrameLen(L2_L2frame2L1frame(l2FrameType, l2SvcRate));
 }
 
 /**
@@ -377,57 +391,78 @@ inline L2_TOR_TYPE L2_GetNextTor(L2_INST *instPtr)
 	return instPtr->tor.next;
 }
 
-/*****************************************************************************/
 /**
- * @brief   Infer last received frame type.
+ * @brief    Get service rate of the node.
- *
+ */
- * @param   instPtr  A pointer to physical layer control instance.
+inline L2_SVC_RATE L2_GetServiceRate(L2_INST *instPtr)
- *
- * @return  L2_FRAME_TYPE.
- *
- ******************************************************************************/
-L2_FRAME_TYPE L2_GetLastOptFrameType(L2_INST *instPtr)
 {
-	if (instPtr->myInfo.nodeType == L2_NODE_HEAD || L2_isCxn2Net(instPtr))
+	ASSERT(instPtr != NULL);
-	{
+	return instPtr->config.serviceRate;
-		return instPtr->frame.curr;
-	}
-	switch (instPtr->scanFSM->scanStage)
-	{
-	case L2_SCAN_INIT_STAGE:
-		return L2_SCAN_FRAME;
-	case L2_SCAN_ADV_STAGE:
-		return L2_ADV_FRAME;
-	case L2_SCAN_CFM_STAGE:
-		return L2_CFM_FRAME;
-	default:
-		return L2_NONE_FRAME;
-	}
 }
+
 /*****************************************************************************/
 /**
  * @brief   Convert L2 frame type to L1 frame type
  *
  * @param   l2Frame
+ * @param	l2SvcRate
  *
  * @return  L1 frame type.
  *
  ******************************************************************************/
-L1_FRAME_TYPE L2_L2frame2L1frame(L2_FRAME_TYPE l2Frame)
+L1_FRAME_TYPE L2_L2frame2L1frame(L2_FRAME_TYPE l2Frame, L2_SVC_RATE l2SvcRate)
 {
 	switch (l2Frame)
 	{
-	case L2_SCAN_FRAME:
+	case L2_FRAME_ADV:
-		return L1_10KBPS_10MS_FRAME;
+		return L1_FRAME_ADV_24MS;
-	case L2_ADV_FRAME:
+	case L2_FRAME_ACK:
-		return L1_10KBPS_20MS_FRAME;
+		return L1_FRAME_ACK_8MS;
-	case L2_CFM_FRAME:
+	case L2_FRAME_DIS:
-	case L2_SVC_FRAME:
+	case L2_FRAME_MNG:
-		return L1_40KBPS_20MS_FRAME;
+	case L2_FRAME_RTT:
+		return L1_FRAME_128KBPS_4MS;
+	case L2_FRAME_SVC:
+		switch (l2SvcRate)
+		{
+		case L2_SVC_128K:
+			return L1_FRAME_128KBPS_4MS;
+		case L2_SVC_512K:
+			return L1_FRAME_512KBPS_4MS;
+		case L2_SVC_2M:
+			return L1_FRAME_2MBPS_4MS;
+		default:
+			return L1_FRAME_NONE;
+		}
 	default:
 		return L1_FRAME_NONE;
 	}
 }
+
+/*****************************************************************************/
+/**
+ * @brief   Convert antenna broadcast id to antenna index
+ *
+ * @param   antId
+ *
+ * @return  Physical antenna index.
+ *
+ ******************************************************************************/
+PHY_ANT_INDEX L2_AntId2AntIndex(uint8_t antId)
+{
+	switch (antId)
+	{
+	case L2_BROADCAST_ID1:
+		return PHY_ANT_INDEX_1;
+	case L2_BROADCAST_ID2:
+		return PHY_ANT_INDEX_2;
+	case L2_BROADCAST_ID3:
+		return PHY_ANT_INDEX_3;
+	default:
+		return PHY_ANT_INDEX_NONE;
+	}
+}
+
 /** @} LinkLayer_Utility*/
 
 /**
@@ -508,9 +543,9 @@ int32_t Linklayer_Init(L2_INST **instPtr, const L2_CONFIG *config)
 	(*instPtr)->slotNum.last = 0;
 	(*instPtr)->slotNum.curr = 0;
 	(*instPtr)->slotNum.next = 0;
-	(*instPtr)->frame.last = L2_NONE_FRAME;
+	(*instPtr)->frame.last = L2_FRAME_NONE;
-	(*instPtr)->frame.curr = L2_NONE_FRAME;
+	(*instPtr)->frame.curr = L2_FRAME_NONE;
-	(*instPtr)->frame.next = L2_NONE_FRAME;
+	(*instPtr)->frame.next = L2_FRAME_NONE;
 	(*instPtr)->tor.last = L2_TOR_SUSPEND;
 	(*instPtr)->tor.curr = L2_TOR_SUSPEND;
 	(*instPtr)->tor.next = L2_TOR_SUSPEND;
@@ -605,9 +640,9 @@ int32_t Linklayer_Reconfig(L2_INST *instPtr, const L2_CONFIG *config)
 	instPtr->slotNum.last = 0;
 	instPtr->slotNum.curr = 0;
 	instPtr->slotNum.next = 0;
-	instPtr->frame.last = L2_NONE_FRAME;
+	instPtr->frame.last = L2_FRAME_NONE;
-	instPtr->frame.curr = L2_NONE_FRAME;
+	instPtr->frame.curr = L2_FRAME_NONE;
-	instPtr->frame.next = L2_NONE_FRAME;
+	instPtr->frame.next = L2_FRAME_NONE;
 	instPtr->tor.last = L2_TOR_SUSPEND;
 	instPtr->tor.curr = L2_TOR_SUSPEND;
 	instPtr->tor.next = L2_TOR_SUSPEND;
@@ -671,7 +706,7 @@ void Linklayer_Destroy(L2_INST *instPtr)
 int32_t Linklayer_Start(L2_INST *instPtr)
 {
 	ASSERT(instPtr != NULL);
-	// Set netStartTime at first call.
+	// Set netStartTime at first call, i.e. at the beginning of next time unit.
 	if (instPtr->netStartTime == NET_START_TIME_INFTY)
 	{
 		instPtr->netStartTime = TimeCtrl_GetIntCnt(instPtr->config.tmcInstPtr) / L2_SLOTS_PER_FRAME + 1;
@@ -851,12 +886,14 @@ int32_t Linklayer_PktHandler(L2_INST *instPtr, L2_FRAME_TYPE frameType)
 
 	switch (frameType)
 	{
-	case L2_SCAN_FRAME:
+	case L2_FRAME_ADV:
-	case L2_ADV_FRAME:
+	case L2_FRAME_ACK:
-	case L2_CFM_FRAME:
 		Status = L2_Scan_PktHandler(instPtr, instPtr->recvPktData);
 		break;
-	case L2_SVC_FRAME:
+	case L2_FRAME_DIS:
+	case L2_FRAME_MNG:
+	case L2_FRAME_RTT:
+	case L2_FRAME_SVC:
 		Status = L2_Service_PktHandler(instPtr, instPtr->recvPktData);
 		break;
 	default:
@@ -923,22 +960,26 @@ static int32_t Linklayer_Routine(L2_INST *instPtr)
 	instPtr->rtneConfig.curr = instPtr->rtneConfig.next;
 	instPtr->rtneConfig.next = &(instPtr->rtneConfig.rtneTable[tableIndx][entryIndx]);
 	rtneEntry = instPtr->rtneConfig.rtneTable[tableIndx][entryIndx];
-	DBG_INFO("## Routine: %" PRIu32 "-%" PRIu32 ", Routine period: %" PRIu32 ".\n", tableIndx, entryIndx, instPtr->rtneConfig.rtnePrd);
+	DBG_INFO("## Routine: %" PRIu32 "-%" PRIu32 ", Routine period: %" PRIu32 ".\n", tableIndx, entryIndx,
+		instPtr->rtneConfig.rtnePrd);
 
 	switch (rtneEntry.slotType)
 	{
 	case L2_SLOT_IDLE:
-		// Skip a 5ms slot.
+		// Skip a 2 ms slot.
-		DBG_INFO("Skipping idle slot (5ms)...\n");
+		DBG_INFO("Skipping idle slot (2 ms)...\n");
 		Status = SUCCESS;
 		break;
-	case L2_SLOT_SCAN:
 	case L2_SLOT_ADVERTISE:
-	case L2_SLOT_CONFIRM:
+	case L2_SLOT_ACKNOWLEDGE:
 		Status = L2_Scan_Routine(instPtr, &rtneEntry);
 		break;
+	case L2_SLOT_DISTRIBUTE:
+	case L2_SLOT_MANAGE:
+	case L2_SLOT_RTT:
+		Status = L2_Service_Routine(instPtr, &rtneEntry, L2_SVC_128K);
 	case L2_SLOT_SERVICE:
-		Status = L2_Service_Routine(instPtr, &rtneEntry);
+		Status = L2_Service_Routine(instPtr, &rtneEntry, L2_GetServiceRate(instPtr));
 		break;
 	default:
 		DBG_ERROR("UNKNOWN slot type [%" PRId8 "].\n", rtneEntry.slotType);
@@ -1021,9 +1062,9 @@ int32_t Linklayer_Proc(L2_INST *instPtr)
 	// Handle frame received in last slot.
 	if (L2_isDataAvail(instPtr) == true)
 	{
-		if (Linklayer_PktHandler(instPtr, L2_GetLastOptFrameType(instPtr)) != SUCCESS)
+		if (Linklayer_PktHandler(instPtr, L2_GetLastFrameType(instPtr)) != SUCCESS)
 		{
-			DBG_ERROR("Failed to handle last received frame: %" PRId8 ".\n", L2_GetLastOptFrameType(instPtr));
+			DBG_ERROR("Failed to handle last received frame: %" PRId8 ".\n", L2_GetLastFrameType(instPtr));
 		}
 	}
 
@@ -1064,16 +1105,22 @@ int32_t Linklayer_Proc(L2_INST *instPtr)
 	instPtr->linkLog.cxnStatus = (L2_isCxn2Net(instPtr)) ? 0x11 : 0x00;
 	instPtr->linkLog.linkStage = (instPtr->mainState == L2_INIT_STATE) ? 0x11 : 0x22;
 	instPtr->linkLog.recxnCnt = instPtr->log.reconnectCnt;
-	instPtr->linkLog.beamNo = instPtr->scanFSM->beamNo;
+	instPtr->linkLog.antIndex = instPtr->scanFSM->antIndex;
-	instPtr->linkLog.beamWidth = instPtr->log.lastBeamWidth;
-	instPtr->linkLog.beamAz = phyRef->antNrrwPattern[instPtr->scanFSM->beamNo].oaxis;
-	instPtr->linkLog.beamEl = phyRef->antNrrwPattern[instPtr->scanFSM->beamNo].raxis;
 	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.ackTxCnt = instPtr->log.ackTxCnt;
-	instPtr->linkLog.cfmRecvCnt = instPtr->log.cfmRecvCnt;
+	instPtr->linkLog.ackRecvCnt = instPtr->log.ackRecvCnt;
-	instPtr->linkLog.cfmCorrectCnt = instPtr->log.cfmCorrectCnt;
+	instPtr->linkLog.ackCorrectCnt = instPtr->log.ackCorrectCnt;
+	instPtr->linkLog.disTxCnt = instPtr->log.disTxCnt;
+	instPtr->linkLog.disRecvCnt = instPtr->log.disRecvCnt;
+	instPtr->linkLog.disCorrectCnt = instPtr->log.disCorrectCnt;
+	instPtr->linkLog.mngTxCnt = instPtr->log.mngTxCnt;
+	instPtr->linkLog.mngRecvCnt = instPtr->log.mngRecvCnt;
+	instPtr->linkLog.mngCorrectCnt = instPtr->log.mngCorrectCnt;
+	instPtr->linkLog.rttTxCnt = instPtr->log.rttTxCnt;
+	instPtr->linkLog.rttRecvCnt = instPtr->log.rttRecvCnt;
+	instPtr->linkLog.rttCorrectCnt = instPtr->log.rttCorrectCnt;
 	instPtr->linkLog.svcTxCnt = instPtr->log.svcTxCnt;
 	instPtr->linkLog.svcRecvCnt = instPtr->log.svcRecvCnt;
 	instPtr->linkLog.svcCorrectCnt = instPtr->log.svcCorrectCnt;
@@ -1086,69 +1133,6 @@ int32_t Linklayer_Proc(L2_INST *instPtr)
 	return SUCCESS;
 }
 
-/*****************************************************************************/
-/**
- * @brief   Steer antenna beam to specified node.
- *
- * @param   instPtr	a pointer to link layer descriptor instance
- * @param   nodeId		destination node
- *
- * @return Corresponding frame length
- *         L2_FRAME_NONE_LEN if the frame type code cannot be recognized.
- *
- ******************************************************************************/
-int32_t L2_SteerBeam2Node(L2_INST *instPtr, uint8_t nodeId)
-{
-	ASSERT(instPtr != NULL);
-	int32_t Status;
-
-	COORD myPos, dstPos, beamDir;
-	Status = L2_GetNodePos(instPtr->nodeList, nodeId, &dstPos);
-	if (Status != SUCCESS)
-	{
-		DBG_ERROR("Failed to retrieve position info of node %" PRIu8 ", remain last configuration.\n", nodeId);
-		return EPARAM;
-	}
-	myPos.x = instPtr->sysInfo.posX;
-	myPos.y = instPtr->sysInfo.posY;
-	myPos.z = instPtr->sysInfo.posZ;
-
-	// TODO Check data format
-	EULERANGLES attitudeEuler, antAttitudeEuler;
-	attitudeEuler.alpha = DEG2RAD(instPtr->sysInfo.pitch);
-	attitudeEuler.beta = DEG2RAD(instPtr->sysInfo.yaw);
-	attitudeEuler.gamma = DEG2RAD(instPtr->sysInfo.roll);
-
-	// FIXME: confirm date source.
-	antAttitudeEuler.alpha = DEG2RAD(0);
-	antAttitudeEuler.beta = DEG2RAD(0);
-	antAttitudeEuler.gamma = DEG2RAD(0);
-
-	// TODO Check data format
-	QUATERNION attitude, antAttitude;
-	attitude = Quaternion_FromeEulerAngles(attitudeEuler, EULERANGLES_XYZ);
-	antAttitude = Quaternion_FromeEulerAngles(antAttitudeEuler, EULERANGLES_XYZ);
-
-	// --- --- Algorithm --- ---
-	// TODO Check result validation
-	// Compute beam direction vector
-	beamDir = Coord_Sub(dstPos, myPos);
-
-	// Compute antenna attitude respect to ECEF
-	antAttitude = Quaternion_Mult(attitude, antAttitude);
-
-	// Convert beam direction vector to antenna coordinate
-	beamDir = Quaternion_Rotate(Quaternion_GeInverse(antAttitude), beamDir);
-	// Normalize
-	Coord_Normalize(&beamDir);
-
-	double oAxis, rAxis;
-	oAxis = RAD2DEG(atan2(beamDir.z, beamDir.y));
-	rAxis = RAD2DEG(acos(Coord_Dot(beamDir, COORD_X_AXIS)));
-	Status = Phy_SetBeamAngle(instPtr->config.phyInstPtr, oAxis, rAxis);
-	return Status;
-}
-
 /*****************************************************************************/
 /**
  * @brief   Layer 2 setup next slot operation, update current operating frame.
@@ -1165,8 +1149,9 @@ int32_t L2_SetupNextSlot(L2_INST *instPtr, L2_TOR_TYPE txrxMode, L2_FRAME_TYPE f
 	ASSERT(instPtr != NULL);
 	PHY_INST *phyRef = instPtr->config.phyInstPtr;
 	int32_t Status;
-	if (frameType < L2_SCAN_FRAME || frameType > L2_SVC_FRAME)
+	if (frameType < L2_FRAME_ADV || frameType > L2_FRAME_SVC)
 	{
+		DBG_WARNING("L2_SetupNextSlot(): UNKNOWN L2-FrameType %" PRId8 "\n", frameType);
 		return FAILURE;
 	}
 
@@ -1176,13 +1161,22 @@ int32_t L2_SetupNextSlot(L2_INST *instPtr, L2_TOR_TYPE txrxMode, L2_FRAME_TYPE f
 		instPtr->log.frameTx++;
 		switch (frameType)
 		{
-		case L2_ADV_FRAME:
+		case L2_FRAME_ADV:
 			instPtr->log.advTxCnt++;
 			break;
-		case L2_CFM_FRAME:
+		case L2_FRAME_ACK:
-			instPtr->log.cfmTxCnt++;
+			instPtr->log.ackTxCnt++;
 			break;
-		case L2_SVC_FRAME:
+		case L2_FRAME_DIS:
+			instPtr->log.disTxCnt++;
+			break;
+		case L2_FRAME_MNG:
+			instPtr->log.mngTxCnt++;
+			break;
+		case L2_FRAME_RTT:
+			instPtr->log.rttTxCnt++;
+			break;
+		case L2_FRAME_SVC:
 			instPtr->log.svcTxCnt++;
 			break;
 		default:
@@ -1194,13 +1188,22 @@ int32_t L2_SetupNextSlot(L2_INST *instPtr, L2_TOR_TYPE txrxMode, L2_FRAME_TYPE f
 		instPtr->log.frameRx++;
 		switch (frameType)
 		{
-		case L2_ADV_FRAME:
+		case L2_FRAME_ADV:
 			instPtr->log.advRxCnt++;
 			break;
-		case L2_CFM_FRAME:
+		case L2_FRAME_ACK:
-			instPtr->log.cfmRxCnt++;
+			instPtr->log.ackRxCnt++;
 			break;
-		case L2_SVC_FRAME:
+		case L2_FRAME_DIS:
+			instPtr->log.disRxCnt++;
+			break;
+		case L2_FRAME_MNG:
+			instPtr->log.mngRxCnt++;
+			break;
+		case L2_FRAME_RTT:
+			instPtr->log.rttRxCnt++;
+			break;
+		case L2_FRAME_SVC:
 			instPtr->log.svcRxCnt++;
 			break;
 		default:
@@ -1225,16 +1228,22 @@ int32_t L2_SetupNextSlot(L2_INST *instPtr, L2_TOR_TYPE txrxMode, L2_FRAME_TYPE f
 	}
 	switch (frameType)
 	{
-	case L2_SCAN_FRAME:
+	case L2_FRAME_ADV:
-		frameStr = "Scan";
-		break;
-	case L2_ADV_FRAME:
 		frameStr = "Advertisement";
 		break;
-	case L2_CFM_FRAME:
+	case L2_FRAME_ACK:
-		frameStr = "Confirm";
+		frameStr = "Acknowledgement";
 		break;
-	case L2_SVC_FRAME:
+	case L2_FRAME_DIS:
+		frameStr = "Distribution";
+		break;
+	case L2_FRAME_MNG:
+		frameStr = "Management";
+		break;
+	case L2_FRAME_RTT:
+		frameStr = "Round Trip Time";
+		break;
+	case L2_FRAME_SVC:
 		frameStr = "Service";
 		break;
 	default:
@@ -1277,7 +1286,8 @@ int32_t L2_SetupNextSlot(L2_INST *instPtr, L2_TOR_TYPE txrxMode, L2_FRAME_TYPE f
 		return EPARAM;
 	}
 
-	Status = Phy_SetupNextSlot(phyRef, tor, L2_L2frame2L1frame(frameType), instPtr->sendPktData);
+	Status = Phy_SetupNextSlot(phyRef, tor, L2_L2frame2L1frame(frameType,
+		instPtr->config.serviceRate), instPtr->sendPktData);
 	if (Status != SUCCESS)
 	{
 		DBG_ERROR("Physical setup failed, with error code: %" PRId32 "\n", Status);

df_datalink_sp/src/networking/link_layer/link_layer.h

@@ -38,13 +38,14 @@
  */
 typedef struct
 {
-	L2_NODE_TYPE myType;  ///< node type
+	L2_NODE_TYPE myType;	 ///< node type
-	uint8_t clustId;	  ///< node cluster id
+	uint8_t clustId;		 ///< node cluster id
-	uint8_t myId;		  ///< node id
+	uint8_t myId;			 ///< node id
-	uint8_t headId;		  ///< head node id
+	uint8_t headId;			 ///< head node id
-	uint8_t netScale;	  ///< net scale
+	uint8_t netScale;		 ///< net scale
-	PHY_INST *phyInstPtr; ///< pointer to system physical layer instance
+	L2_SVC_RATE serviceRate; ///< service data rate
-	TMC_INST *tmcInstPtr; ///< pointer to system timer controller layer instance
+	PHY_INST *phyInstPtr;	 ///< pointer to system physical layer instance
+	TMC_INST *tmcInstPtr;	 ///< pointer to system timer controller layer instance
 } L2_CONFIG;
 
 /**
@@ -63,10 +64,25 @@ typedef struct
 	uint32_t advRecvCnt;	///< advertise received frame count
 	uint32_t advCorrectCnt; ///< advertise correctly received frame count
 
-	uint32_t cfmRxCnt;		///< confirm rx frame count
+	uint32_t ackRxCnt;		///< acknowledgement rx frame count
-	uint32_t cfmTxCnt;		///< confirm tx frame count
+	uint32_t ackTxCnt;		///< acknowledgement tx frame count
-	uint32_t cfmRecvCnt;	///< confirm received frame count
+	uint32_t ackRecvCnt;	///< acknowledgement received frame count
-	uint32_t cfmCorrectCnt; ///< confirm correctly received frame count
+	uint32_t ackCorrectCnt; ///< acknowledgement correctly received frame count
+
+	uint32_t distRxCnt;		///< distribution rx frame count
+	uint32_t distTxCnt;		///< distribution tx frame count
+	uint32_t distRecvCnt;	///< distribution received frame count
+	uint32_t distCorrectCnt;///< distribution correctly received frame count
+
+	uint32_t mngRxCnt;		///< management rx frame count
+	uint32_t mngTxCnt;		///< management tx frame count
+	uint32_t mngRecvCnt;	///< management received frame count
+	uint32_t mngCorrectCnt; ///< management correctly received frame count
+
+	uint32_t rttRxCnt;		///< rtt rx frame count
+	uint32_t rttTxCnt;		///< rtt tx frame count
+	uint32_t rttRecvCnt;	///< rtt received frame count
+	uint32_t rttCorrectCnt; ///< rtt correctly received frame count
 
 	uint32_t svcRxCnt;		///< service rx frame count
 	uint32_t svcTxCnt;		///< service tx frame count
@@ -74,7 +90,6 @@ typedef struct
 	uint32_t svcCorrectCnt; ///< service correctly received frame count
 
 	int64_t timeDev;	   ///< last time deviation estimation result
-	uint8_t lastBeamWidth; ///< last beam width
 	uint32_t reconnectCnt; ///< reconnect trial count
 
 	PAYLOAD rxLog;
@@ -128,7 +143,6 @@ int32_t Linklayer_Halt(L2_INST *instPtr);
 int32_t Linklayer_Proc(L2_INST *instPtr);
 int32_t Linklayer_EventHandler(L2_INST *instPtr, const L2_EVENT *l2Event);
 int32_t Linklayer_PktHandler(L2_INST *instPtr, L2_FRAME_TYPE frameType);
-int32_t L2_SteerBeam2Node(L2_INST *instPtr, uint8_t nodeId);
 int32_t L2_SetupNextSlot(L2_INST *instPtr, L2_TOR_TYPE txrxMode, L2_FRAME_TYPE frameType);
 /** @} LinkLayer_Main*/
 
@@ -198,7 +212,7 @@ L2_NODE_STATE L2_GetMainState(L2_INST *instPtr);
 bool L2_isStarted(L2_INST *instPtr);
 bool L2_isDataAvail(L2_INST *instPtr);
 bool L2_isCxn2Net(L2_INST *instPtr);
-uint32_t L2_GetFrameLen(L2_FRAME_TYPE l2FrameType);
+uint32_t L2_GetFrameLen(L2_FRAME_TYPE l2FrameType, L2_SVC_RATE l2SvcRate);
 uint32_t L2_GetLastFrameNum(L2_INST *instPtr);
 uint32_t L2_GetLastSlotNum(L2_INST *instPtr);
 L2_FRAME_TYPE L2_GetLastFrameType(L2_INST *instPtr);
@@ -211,8 +225,8 @@ uint32_t L2_GetNextFrameNum(L2_INST *instPtr);
 uint32_t L2_GetNextSlotNum(L2_INST *instPtr);
 L2_FRAME_TYPE L2_GetNextFrameType(L2_INST *instPtr);
 L2_TOR_TYPE L2_GetNextTor(L2_INST *instPtr);
-L2_FRAME_TYPE L2_GetLastOptFrameType(L2_INST *instPtr);
+L1_FRAME_TYPE L2_L2frame2L1frame(L2_FRAME_TYPE l2Frame, L2_SVC_RATE l2SvcRate);
-L1_FRAME_TYPE L2_L2frame2L1frame(L2_FRAME_TYPE l2Frame);
+PHY_ANT_INDEX L2_AntId2AntIndex(uint8_t antId);
 /** @} LinkLayer_Utility*/
 
 #endif /* __LINK_LAYER_H_ */

df_datalink_sp/src/networking/link_layer/link_layer_types.h

@@ -33,7 +33,9 @@
  * @{
  */
 // Common node ID definition
-#define L2_BROADCAST_ID 0xFF
+#define L2_BROADCAST_ID1 0xF1 // broadcast
+#define L2_BROADCAST_ID2 0xF2
+#define L2_BROADCAST_ID3 0xF4
 #define L2_NONE_ID 0
 
 // Routine configure
@@ -45,15 +47,8 @@
 #define L2_FRAMENO_NONE 0
 
 // Common number of slots definition
-#define L2_SLOTS_PER_FRAME 100
+#define L2_SLOTS_PER_FRAME 250 // 2 ms per slot, 250 slots per time unit
-#define L2_SLOTS_PER_SUBFRAME 20
 
-#define L2_NUM_SLOTS_NONE UINT32_MAX
-#define L2_NUM_SLOTS_100MS 20
-#define L2_NUM_SLOTS_20MS 4
-#define L2_NUM_SLOTS_10MS 2
-#define L2_NUM_SLOTS_5MS 1
-#define L2_NUM_SLOTS_SKIP 0
 /** @} Linklayer_Common_Constants*/
 
 /**************************** Type Definitions *******************************/
@@ -113,7 +108,7 @@ typedef struct
 	uint8_t clustId;	   ///< node cluster ID
 	uint8_t headId;		   ///< cluster head ID
 	L2_NODE_TYPE nodeType; ///< node type
-	uint8_t beamNo;		   ///< beam number to this node
+	uint8_t antIndex;	   ///< antenna number to this node
 	COORD pos;			   ///< node position
 	COORD speed;		   ///< node speed
 	QUATERNION attitude;   ///< node attitude
@@ -153,12 +148,14 @@ typedef struct
  */
 typedef enum
 {
-	L2_SLOT_NONE = 0,
+	L2_SLOT_NONE 		= 0,
-	L2_SLOT_IDLE = 1,
+	L2_SLOT_IDLE 		= 1,
-	L2_SLOT_SCAN = 2,
+	L2_SLOT_ADVERTISE 	= 2,
-	L2_SLOT_ADVERTISE = 3,
+	L2_SLOT_ACKNOWLEDGE = 3,
-	L2_SLOT_CONFIRM = 4,
+	L2_SLOT_DISTRIBUTE 	= 4,
-	L2_SLOT_SERVICE = 5,
+	L2_SLOT_MANAGE 		= 5,
+	L2_SLOT_RTT 		= 6,
+	L2_SLOT_SERVICE		= 7
 } L2_SLOT_TYPE;
 
 /**
@@ -166,13 +163,26 @@ typedef enum
  */
 typedef enum
 {
-	L2_NONE_FRAME = 0,
+	L2_FRAME_NONE = 0,
-	L2_SCAN_FRAME = 1,
+	L2_FRAME_ADV = 1,
-	L2_ADV_FRAME = 2,
+	L2_FRAME_ACK = 2,
-	L2_CFM_FRAME = 3,
+	L2_FRAME_DIS = 3,
-	L2_SVC_FRAME = 4
+	L2_FRAME_MNG = 4,
+	L2_FRAME_RTT = 5,
+	L2_FRAME_SVC = 6
 } L2_FRAME_TYPE;
 
+/**
+ * @enum L2_SVC_RATE
+ */
+typedef enum
+{
+	L2_SVC_NONE = 0,
+	L2_SVC_128K = 1, // 128 kbps
+	L2_SVC_512K = 2, // 512 kbps
+	L2_SVC_2M 	= 3  // 2 Mbps
+} L2_SVC_RATE;
+
 /**
  * @enum L2_CRC_TYPE
  */
@@ -201,10 +211,8 @@ typedef struct
  */
 typedef enum
 {
-	L2_SCAN_NONE_STAGE = 0,
+	L2_SCAN_STAGE_NONE = 0,
-	L2_SCAN_INIT_STAGE = 1,
+	L2_SCAN_STAGE_ADV = 1
-	L2_SCAN_ADV_STAGE = 2,
-	L2_SCAN_CFM_STAGE = 3
 } SCAN_STAGE;
 
 /**
@@ -213,16 +221,9 @@ typedef enum
  */
 typedef struct
 {
-	bool isLocked;		  ///< indicates if init acq done(beam locked).
+	bool isAdvRecvd;	  ///< indicates if advertisement frame done(antenna locked).
-	bool isAdvRecvd;	  ///< indicates if advertisement frame done(beam locked).
+	uint8_t advCnt;		  ///< adv receive try count
-	bool isAckPending;	  ///< indicates if confirm message acked
+	uint8_t antIndex;	  ///< target antenna index
-	uint8_t scanCnt;	  ///< scan count
-	uint8_t advTimeout;	  ///< adv receive try count
-	uint8_t cfmTimeout;	  ///< cmf receive try count
-	SCAN_STAGE scanStage; ///< scan stage \n
-						  /// only for member node
-	uint8_t beamNo;		  ///< locked beam number
-	uint8_t tableNo;	  ///< scan table index
 } L2_SCAN_FSM;
 
 /**

df_datalink_sp/src/networking/link_layer/node_list.c

@@ -198,7 +198,7 @@ NODE_ENTRY *L2_AppendNode(NODE_LIST *list, uint8_t nodeId, L2_NODE_TYPE nodeType
 	nodeEntry->nodeInfo.speed.x = 0;
 	nodeEntry->nodeInfo.speed.y = 0;
 	nodeEntry->nodeInfo.speed.z = 0;
-	nodeEntry->nodeInfo.beamNo = 0;
+	nodeEntry->nodeInfo.antIndex = 0;
 	nodeEntry->ttlCnt = 0;
 	clist_rpush(list, node);
 	return nodeEntry;

df_datalink_sp/src/networking/link_layer/scan.c

@@ -31,122 +31,20 @@
 #include "../phy_layer/phy_layer.h"
 
 /************************** Constant Definitions *****************************/
-#define ADV_LISTEN_TIMEOUT 40
+#define ACK_FRAME_SLOTS 4
-#define CFM_LISTEN_TIMEOUT 5
-#define ADV_FRAME_SLOTS 4
-#define CFM_FRAME_SLOTS 5
 /***************** Macros (In-line Functions) Definitions *********************/
 
 /**************************** Type Definitions *******************************/
 
 /************************** Variable Definitions *****************************/
-// Pair by regex
-// Regex: ((\{\.oaxis = [0-9]+[ ,]+\.raxis = [0-9]+[ ]*\}, ){2})
-PHY_ANT_ANGLE antNrrwPattern_0[L1_ANT_PATTERN_NUM] =
-{
-	{.oaxis = 0  , .raxis = 0   },
-	{.oaxis = 139, .raxis = 2225},
-	{.oaxis = 152, .raxis = 850 },
-	{.oaxis = 138, .raxis = 3155},
-	{.oaxis = 159, .raxis = 1680},
-	{.oaxis = 168, .raxis = 285 },
-	{.oaxis = 195, .raxis = 2630},
-	{.oaxis = 211, .raxis = 1204},
-	{.oaxis = 225, .raxis = 3429},
-	{.oaxis = 249, .raxis = 2022},
-	{.oaxis = 272, .raxis = 629 },
-	{.oaxis = 265, .raxis = 2934},
-	{.oaxis = 277, .raxis = 1499},
-	{.oaxis = 289, .raxis = 124 },
-	{.oaxis = 300, .raxis = 2349},
-	{.oaxis = 311, .raxis = 959 },
-	{.oaxis = 321, .raxis = 3199},
-	{.oaxis = 331, .raxis = 1824},
-	{.oaxis = 341, .raxis = 389 },
-	{.oaxis = 351, .raxis = 2674},
-	{.oaxis = 360, .raxis = 1268},
-	{.oaxis = 364, .raxis = 3483},
-	{.oaxis = 378, .raxis = 2118},
-	{.oaxis = 387, .raxis = 733 },
-	{.oaxis = 416, .raxis = 3028},
-	{.oaxis = 404, .raxis = 1623},
-	{.oaxis = 433, .raxis = 248 },
-	{.oaxis = 421, .raxis = 2473},
-	{.oaxis = 429, .raxis = 1098},
-	{.oaxis = 437, .raxis = 3303},
-	{.oaxis = 445, .raxis = 1948},
-	{.oaxis = 443, .raxis = 543 },
-	{.oaxis = 450, .raxis = 2828},
-	{.oaxis = 448, .raxis = 1422},
-	{.oaxis = 455, .raxis = 47  },
-	{.oaxis = 453, .raxis = 2272},
-	{.oaxis = 450, .raxis = 897 }
-};
 
-PHY_ANT_ANGLE antNrrwPattern_1[L1_ANT_PATTERN_NUM] =
-{
-	{.oaxis = 0  , .raxis = 0   },
-	{.oaxis = 139, .raxis = 1155},
-	{.oaxis = 152, .raxis = 3380},
-	{.oaxis = 138, .raxis = 2085},
-	{.oaxis = 159, .raxis = 610 },
-	{.oaxis = 168, .raxis = 2815},
-	{.oaxis = 195, .raxis = 1560},
-	{.oaxis = 211, .raxis = 134 },
-	{.oaxis = 225, .raxis = 2359},
-	{.oaxis = 249, .raxis = 952 },
-	{.oaxis = 272, .raxis = 3159},
-	{.oaxis = 265, .raxis = 1864},
-	{.oaxis = 277, .raxis = 429 },
-	{.oaxis = 289, .raxis = 2654},
-	{.oaxis = 300, .raxis = 1279},
-	{.oaxis = 311, .raxis = 3489},
-	{.oaxis = 321, .raxis = 2129},
-	{.oaxis = 331, .raxis = 754 },
-	{.oaxis = 341, .raxis = 2919},
-	{.oaxis = 351, .raxis = 1604},
-	{.oaxis = 360, .raxis = 198 },
-	{.oaxis = 364, .raxis = 2413},
-	{.oaxis = 378, .raxis = 1048},
-	{.oaxis = 387, .raxis = 3263},
-	{.oaxis = 416, .raxis = 1958},
-	{.oaxis = 404, .raxis = 553 },
-	{.oaxis = 433, .raxis = 2778},
-	{.oaxis = 421, .raxis = 1403},
-	{.oaxis = 429, .raxis = 28  },
-	{.oaxis = 437, .raxis = 2233},
-	{.oaxis = 445, .raxis = 878 },
-	{.oaxis = 443, .raxis = 3073},
-	{.oaxis = 450, .raxis = 1758},
-	{.oaxis = 448, .raxis = 352 },
-	{.oaxis = 455, .raxis = 2577},
-	{.oaxis = 453, .raxis = 1202},
-	{.oaxis = 450, .raxis = 3427},
-};
 /************************** Function Prototypes ******************************/
-static void LockStateUpdate(L2_SCAN_FSM *scanFsmPtr, bool state);
 static void AdvRecvStateUpdate(L2_SCAN_FSM *scanFsmPtr, bool state);
-static void StageUpdate(L2_SCAN_FSM *scanFsmPtr, SCAN_STAGE newStage);
-static void PendCfmAck(L2_SCAN_FSM *scanFsmPtr);
 
-static int32_t Scan_InitScanHandler(L2_INST *instPtr);
 static int32_t Scan_AdvHandler(L2_INST *instPtr);
-static int32_t Scan_CfmHandler(L2_INST *instPtr);
 
 static int32_t ScanMsg_Packing(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t dstId);
 
-/**
- * @brief   Update Init-Scan lock state.
- */
-static inline void LockStateUpdate(L2_SCAN_FSM *scanFsmPtr, bool state)
-{
-	ASSERT(scanFsmPtr != NULL);
-	DBG_INFO("Update BeamLockState from [%" PRId8 "] to [%" PRId8 "].\n",
-			 scanFsmPtr->isLocked, state);
-	scanFsmPtr->isLocked = state;
-	return;
-}
-
 /**
  * @brief   Update Base-info Advertisement state.
  */
@@ -159,91 +57,13 @@ static void AdvRecvStateUpdate(L2_SCAN_FSM *scanFsmPtr, bool state)
 	return;
 }
 
-/**
- * @brief   Update 2-Way Acquisition ack state.
- */
-static void PendCfmAck(L2_SCAN_FSM *scanFsmPtr)
-{
-	ASSERT(scanFsmPtr != NULL);
-	DBG_INFO("Pending Cfm-Ack...\n");
-	scanFsmPtr->isAckPending = true;
-	return;
-}
-
 /*****************************************************************************/
 /**
- * @brief   Update current Scan-Net stage
+ * @brief	Member node scan net BmAdvt stage handler.
  *
- * @param   scanFsmPtr  A pointer to scan net fsm.
+ * @param	scanFsmPtr  A pointer to scan net fsm.
- *          newStage    New state.
  *
- * @return  NONE.
+ * @return	used slot (2 ms slot).
- *
- ******************************************************************************/
-static void StageUpdate(L2_SCAN_FSM *scanFsmPtr, SCAN_STAGE newStage)
-{
-	ASSERT((newStage >= L2_SCAN_NONE_STAGE) && (newStage <= L2_SCAN_CFM_STAGE));
-	DBG_INFO("ScanNet current stage: %" PRIu8 " -> ScanNet new stage: %" PRIu8 " \n",
-			 scanFsmPtr->scanStage, newStage);
-	scanFsmPtr->scanStage = newStage;
-}
-
-/*****************************************************************************/
-/**
- * @brief   Member node scan net InitScan stage handler.
- *
- * @param   instPtr  A pointer to l2 instance
- *
- * @return used slot (5ms slot).
- *
- ******************************************************************************/
-static int32_t Scan_InitScanHandler(L2_INST *instPtr)
-{
-	ASSERT(instPtr != NULL);
-	PHY_INST *phyRef = instPtr->config.phyInstPtr;
-	L2_SCAN_FSM *scanFsmPtr = instPtr->scanFSM;
-	DBG_INFO("** Net-Setup - InitScan Procedure (Attempts: %" PRIu8 ")**\n", scanFsmPtr->scanCnt);
-
-	if (scanFsmPtr->scanCnt == 0)
-	{
-		// Update scan beam table
-		L2_Scan_RefreashScanTable(instPtr);
-	}
-	else if (Phy_IsFrameDetected(phyRef))
-	{
-		// last scan beam number
-		scanFsmPtr->beamNo = Phy_LastScanBeamNo(phyRef);
-		// Update scan beam table
-		L2_Scan_RefreashScanTable(instPtr);
-	}
-
-	if (scanFsmPtr->isLocked == true)
-	{
-		scanFsmPtr->beamNo = Phy_LastScanBeamNo(phyRef);
-		Phy_SetBeamNo(phyRef, scanFsmPtr->beamNo, PHY_ANT_BEAM_16);
-		L2_SetupNextSlot(instPtr, L2_TOR_RX, L2_ADV_FRAME);
-		StageUpdate(scanFsmPtr, L2_SCAN_ADV_STAGE);
-		instPtr->log.lastBeamWidth = PHY_ANT_BEAM_16;
-	} /* Otherwise remain L2_SCAN_INIT_STAGE */
-	else
-	{
-		/* Antenna steering (reserved, automatically accomplished by physical layer) */
-		Phy_SetBeamNo(phyRef, scanFsmPtr->beamNo, PHY_ANT_BEAM_16);
-		L2_SetupNextSlot(instPtr, L2_TOR_RX, L2_SCAN_FRAME);
-		scanFsmPtr->scanCnt++;
-		instPtr->log.lastBeamWidth = PHY_ANT_BEAM_16;
-	}
-	return SUCCESS;
-}
-
-/*****************************************************************************/
-/**
- * @brief   Member node scan net BmAdvt stage handler.
- *
- * @param   scanFsmPtr  A pointer to scan net fsm.
- *          mainState    A pointer to main node state.
- *
- * @return used slot (5ms slot).
  *
  ******************************************************************************/
 static int32_t Scan_AdvHandler(L2_INST *instPtr)
@@ -252,92 +72,29 @@ static int32_t Scan_AdvHandler(L2_INST *instPtr)
 	L2_SCAN_FSM *scanFsmPtr = instPtr->scanFSM;
 	PHY_INST *phyRef = instPtr->config.phyInstPtr;
 	TMC_INST *tmcRef = instPtr->config.tmcInstPtr;
-	DBG_INFO("** Net-Setup - Advertisement Procedure (Timeout: %" PRIu8 ") **\n", scanFsmPtr->advTimeout);
+	DBG_INFO("** Net-Setup - Advertisement Procedure (Attempts: %" PRIu8 ") **\n", scanFsmPtr->advCnt);
 
 	// if received a valid bm frame.
 	if (scanFsmPtr->isAdvRecvd == true)
 	{
-		// last scan beam number
+		// antenna index from listening state
-		scanFsmPtr->beamNo = Phy_LastScanBeamNo(phyRef);
+		scanFsmPtr->antIndex = Phy_ListenAntIndex(phyRef);
-		// reset listen counter.
-		scanFsmPtr->advTimeout = 0;
 
-		// Update scan stage
+		// start a acknowledge frame reception if in the target slot
-		StageUpdate(scanFsmPtr, L2_SCAN_CFM_STAGE);
+		if ((TimeCtrl_GetIntCnt(tmcRef) + 1) % ACK_FRAME_SLOTS == 0) // FIXME: correct?
-
-		// start a confirm frame reception if in the target slot
-		if ((TimeCtrl_GetIntCnt(tmcRef) + 1) % CFM_FRAME_SLOTS == 0)
 		{
-			// using pull mode to receive confirm frame
+			// using pull mode to transmit confirm frame
 			// since first time sync procedure is accomplished in ADV stage.
-			(void)Phy_SetBeamWidth(phyRef, PHY_ANT_BEAM_16);
+			(void)Phy_SetAntIndex(phyRef, scanFsmPtr->antIndex);
-			(void)Phy_SetBeamNo(phyRef, scanFsmPtr->beamNo, PHY_ANT_BEAM_16);
 			(void)Phy_SetMode(phyRef, PHY_MODE_POLL);
-			(void)L2_SetupNextSlot(instPtr, L2_TOR_RX, L2_CFM_FRAME);
+			(void)L2_SetupNextSlot(instPtr, L2_TOR_TX, L2_FRAME_ACK);
-			scanFsmPtr->cfmTimeout++; // increase counter.
-			instPtr->log.lastBeamWidth = PHY_ANT_BEAM_16;
 		}
-		// otherwise skip...
-		return SUCCESS;
 	}
 	// no valid bm frame was received.
 	else
 	{
-		/* if time out reached, go back to init scan stage. */
+		(void)L2_SetupNextSlot(instPtr, L2_TOR_RX, L2_FRAME_ADV);
-		if (scanFsmPtr->advTimeout > ADV_LISTEN_TIMEOUT)
+		scanFsmPtr->advCnt++;
-		{
-			/* Antenna steering (reserved, automatically accomplished by physical layer) */
-			(void)Phy_SetBeamNo(phyRef, scanFsmPtr->beamNo, PHY_ANT_BEAM_16);
-			(void)L2_SetupNextSlot(instPtr, L2_TOR_RX, L2_SCAN_FRAME);
-			DBG_WARNING("Adv timeout, restart net scan from L2_SCAN_INIT_STAGE.\n");
-			(void)L2_Scan_Reset(scanFsmPtr);
-			instPtr->log.lastBeamWidth = PHY_ANT_BEAM_16;
-		}
-		else
-		{
-			/* Antenna steering (reserved, automatically accomplished by physical layer) */
-			(void)Phy_SetBeamNo(phyRef, scanFsmPtr->beamNo, PHY_ANT_BEAM_16);
-			(void)L2_SetupNextSlot(instPtr, L2_TOR_RX, L2_ADV_FRAME);
-			scanFsmPtr->advTimeout++;
-			instPtr->log.lastBeamWidth = PHY_ANT_BEAM_16;
-		}
-		return SUCCESS;
-	}
-}
-
-/*****************************************************************************/
-/**
- * @brief   Scan net 2Way-Acq stage handler.
- *
- * @param   instPtr	a pointer to linklayer layer instance
- *
- * @return used slot (5ms slot).
- *
- ******************************************************************************/
-static int32_t Scan_CfmHandler(L2_INST *instPtr)
-{
-	ASSERT(instPtr != NULL);
-	L2_SCAN_FSM *scanFsmPtr = instPtr->scanFSM;
-	PHY_INST *phyRef = instPtr->config.phyInstPtr;
-	DBG_INFO("** Net-Setup - Confirm Procedure (Timeout: %" PRIu8 ") **\n", scanFsmPtr->cfmTimeout);
-
-	// 2 way acq failed, back to init stage.
-	if (scanFsmPtr->cfmTimeout >= CFM_LISTEN_TIMEOUT)
-	{
-		DBG_WARNING("Cmf timeout, restart net scan from L2_SCAN_INIT_STAGE.\n");
-		L2_Scan_Reset(scanFsmPtr);
-		return SUCCESS;
-	}
-	if (L2_GetNextSlotNum(instPtr) % CFM_FRAME_SLOTS == 0)
-	{
-		// using pull mode to receive confirm frame
-		// since first time sync procedure is accomplished in ADV stage.
-		(void)Phy_SetBeamWidth(phyRef, PHY_ANT_BEAM_16);
-		(void)Phy_SetBeamNo(phyRef, scanFsmPtr->beamNo, PHY_ANT_BEAM_16);
-		(void)Phy_SetMode(phyRef, PHY_MODE_POLL);
-		(void)L2_SetupNextSlot(instPtr, L2_TOR_RX, L2_CFM_FRAME);
-		scanFsmPtr->cfmTimeout++; // increase counter.
-		instPtr->log.lastBeamWidth = PHY_ANT_BEAM_16;
 	}
 	return SUCCESS;
 }
@@ -376,9 +133,9 @@ static int32_t ScanMsg_Packing(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t dst
 	L2_FrameInsertChunk(buff, L2_MSG_DST_ID, L2_MSG_DST_ID_LEN, &dataChunk);
 	switch (type)
 	{
-	case L2_ADV_FRAME:
+	case L2_FRAME_ADV:
 	{
-		dataChunk = L2_ADV_FRAME;
+		dataChunk = L2_FRAME_ADV;
 		L2_FrameInsertChunk(buff, L2_MSG_TYPE, L2_MSG_TYPE_LEN, &dataChunk);
 
 		SysMonitor_GetSysinfo(&(instPtr->sysInfo));
@@ -399,9 +156,9 @@ static int32_t ScanMsg_Packing(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t dst
 		}
 		break;
 	}
-	case L2_CFM_FRAME:
+	case L2_FRAME_ACK:
 	{
-		dataChunk = L2_CFM_FRAME;
+		dataChunk = L2_FRAME_ACK;
 		L2_FrameInsertChunk(buff, L2_MSG_TYPE, L2_MSG_TYPE_LEN, &dataChunk);
 
 		SysMonitor_GetSysinfo(&(instPtr->sysInfo));
@@ -468,31 +225,29 @@ int32_t L2_Scan_PktHandler(L2_INST *instPtr, uint8_t *msg)
 	ASSERT(msg != NULL);
 	int32_t Status;
 	L2_SCAN_FSM *scanFsmPtr = instPtr->scanFSM;
-	L2_FRAME_TYPE frameType = L2_NONE_FRAME;
+	L2_FRAME_TYPE frameType = L2_FRAME_NONE;
 	L2_FrameGetChunk(msg, L2_MSG_TYPE, L2_MSG_TYPE_LEN, &frameType);
+
 	switch (frameType)
 	{
-	case L2_SCAN_FRAME:
+	case L2_FRAME_ADV:
-	case L2_ADV_FRAME:
 	{
-		if (L2_GetLastOptFrameType(instPtr) == L2_SCAN_FRAME)
-		{
-			LockStateUpdate(scanFsmPtr, true);
-			StageUpdate(scanFsmPtr, L2_SCAN_ADV_STAGE);
-		}
 		if (L2_GetNodeType(instPtr) == L2_NODE_HEAD)
 		{
-			DBG_ERROR("Unexpected call from head node, only member Node can handle L2_SCAN_FRAME and L2_ADV_FRAME.\n");
+			DBG_ERROR("Unexpected call from head node, only member Node can handle L2_FRAME_ADV.\n");
 			Status = EUNEXP;
 			break;
 		}
-		uint8_t nodeId;
+
-		L2_FrameGetChunk(msg, L2_MSG_SRC_ID, L2_MSG_SRC_ID_LEN, &nodeId);
+		L2_MSG_ADV *message = msg;
+
+		// Update node status.
+		uint8_t nodeId = message->common.src;
 		NODE_ENTRY *node;
 		node = L2_GetNodeById(instPtr->nodeList, nodeId);
 		if (node == NULL)
 		{
-			node = L2_AppendNode(instPtr->nodeList, nodeId, L2_NODE_MEMBER);
+			node = L2_AppendNode(instPtr->nodeList, nodeId, L2_NODE_HEAD);
 			if (node == NULL)
 			{
 				DBG_ERROR("Failed to append new node [id: %" PRId8 "]", nodeId);
@@ -501,30 +256,26 @@ int32_t L2_Scan_PktHandler(L2_INST *instPtr, uint8_t *msg)
 			}
 		}
 		// Update node info.
-		float nodePos;
+		node->nodeInfo.pos.x = message->srcPosX;
-		L2_FrameGetChunk(msg, L2_MSG_ADV_SRC_POSX, L2_MSG_ADV_SRC_POSX_LEN, &nodePos);
+		node->nodeInfo.pos.y = message->srcPosY;
-		node->nodeInfo.pos.x = (double)nodePos;
+		node->nodeInfo.pos.z = message->srcPosZ;
-		L2_FrameGetChunk(msg, L2_MSG_ADV_SRC_POSY, L2_MSG_ADV_SRC_POSY_LEN, &nodePos);
+		node->nodeInfo.antIndex = Phy_ListenAntIndex(instPtr->config.phyInstPtr);
-		node->nodeInfo.pos.y = (double)nodePos;
-		L2_FrameGetChunk(msg, L2_MSG_ADV_SRC_POSZ, L2_MSG_ADV_SRC_POSZ_LEN, &nodePos);
-		node->nodeInfo.pos.z = (double)nodePos;
-		node->nodeInfo.beamNo = Phy_LastScanBeamNo(instPtr->config.phyInstPtr);
 
 		// Reset node ttl
 		node->ttlCnt = 0;
 
-		uint32_t netstartTime;
 		// Update net start time.
-		L2_FrameGetChunk(msg, L2_MSG_ADV_SRC_NETSTART_TIME, L2_MSG_ADV_SRC_NETSTART_TIME_LEN, &netstartTime);
+		uint32_t netstartTime = message->srcNetStatTime;
-		L2_EVENT netSetupDoneEvent = {
+		L2_EVENT netSetupDoneEvent =
+		{
 			.event = L2_EV_NET_ADV_UPDATE,
-			.msg = &netstartTime};
+			.msg = &netstartTime
+		};
 		AssertL2Event(instPtr, &netSetupDoneEvent);
 
 		// Calculate time deviation
-		uint32_t frameNum, slotNum = 0;
+		uint32_t frameNum = message->common.frameNum;
-		L2_FrameGetChunk(msg, L2_MSG_FRAME_NUM, L2_MSG_FRAME_NUM_LEN, &frameNum);
+		uint32_t slotNum = (uint32_t)message->common.slotNum;
-		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)
 		{
@@ -532,18 +283,56 @@ int32_t L2_Scan_PktHandler(L2_INST *instPtr, uint8_t *msg)
 			break;
 		}
 
+		// check if net setup finished.
+		if (L2_isCxn2Net(instPtr) == false)
+		{
+			// Assert Net-Setup Done.
+			L2_EVENT l2Event = {
+				.event = L2_EV_NET_SETUP_DONE,
+				.msg = NULL
+			};
+			(void)AssertL2Event(instPtr, &l2Event);
+
+			// Assert update routine event...
+			L2_RTNE_CONFIG newRtneConfig = {0};
+			L2_EVENT rtneUpEvent =
+			{
+				.event = L2_ROUTINE_UPDATE,
+				.msg = &newRtneConfig
+			};
+			newRtneConfig.rtneTable = initTable;
+			newRtneConfig.rtnePrd = ARRAY_SIZE(initTable);
+			(void)AssertL2Event(instPtr, &rtneUpEvent);
+		}
 		// Time sync.
 		L2_TimeAdjust(instPtr, &(instPtr->log.timeDev));
 
+		// Get data payload
+		uint32_t dataId = message->advDataId;
+		SysMonitor_UpdateRecvPayload(message->advData, dataId, L2_PAYLOAD_LEN_ADV);
+
+		// Logging...
+		memcpy(instPtr->log.rxLog.data, msg, Phy_GetFrameLen(L2_L2frame2L1frame(L2_FRAME_ADV, L2_SVC_NONE)));
+		instPtr->log.rxLog.dataId = dataId;
+
 		// trigger flag
 		AdvRecvStateUpdate(scanFsmPtr, true);
 		Status = SUCCESS;
 		break;
 	}
-	case L2_CFM_FRAME:
+	case L2_FRAME_ACK:
 	{
-		uint8_t nodeId;
+		if (L2_GetNodeType(instPtr) == L2_NODE_MEMBER)
-		L2_FrameGetChunk(msg, L2_MSG_SRC_ID, L2_MSG_SRC_ID_LEN, &nodeId);
+		{
+			DBG_ERROR("Unexpected call from member node, only head Node can handle L2_FRAME_ACK.\n");
+			Status = EUNEXP;
+			break;
+		}
+
+		L2_MSG_ACK *message = msg;
+
+		// Update node status.
+		uint8_t nodeId = message->common.src;
 		NODE_ENTRY *node;
 		node = L2_GetNodeById(instPtr->nodeList, nodeId);
 		if (node == NULL)
@@ -557,28 +346,19 @@ int32_t L2_Scan_PktHandler(L2_INST *instPtr, uint8_t *msg)
 			}
 		}
 		// Update node info.
-		float nodePos;
+		node->nodeInfo.pos.x = message->srcPosX;
-		L2_FrameGetChunk(msg, L2_MSG_CFM_SRC_POSX, L2_MSG_CFM_SRC_POSX_LEN, &nodePos);
+		node->nodeInfo.pos.y = message->srcPosY;
-		node->nodeInfo.pos.x = (double)nodePos;
+		node->nodeInfo.pos.z = message->srcPosZ;
-		L2_FrameGetChunk(msg, L2_MSG_CFM_SRC_POSY, L2_MSG_CFM_SRC_POSY_LEN, &nodePos);
+		node->nodeInfo.speed.x = message->srcSpeedX;
-		node->nodeInfo.pos.y = (double)nodePos;
+		node->nodeInfo.speed.y = message->srcSpeedY;
-		L2_FrameGetChunk(msg, L2_MSG_CFM_SRC_POSZ, L2_MSG_CFM_SRC_POSZ_LEN, &nodePos);
+		node->nodeInfo.speed.z = message->srcSpeedZ;
-		node->nodeInfo.pos.z = (double)nodePos;
-		float nodeSpeed;
-		L2_FrameGetChunk(msg, L2_MSG_CFM_SRC_SPEEDX, L2_MSG_CFM_SRC_SPEEDX_LEN, &nodeSpeed);
-		node->nodeInfo.speed.x = (double)nodePos;
-		L2_FrameGetChunk(msg, L2_MSG_CFM_SRC_SPEEDY, L2_MSG_CFM_SRC_SPEEDY_LEN, &nodeSpeed);
-		node->nodeInfo.speed.y = (double)nodePos;
-		L2_FrameGetChunk(msg, L2_MSG_CFM_SRC_SPEEDZ, L2_MSG_CFM_SRC_SPEEDZ_LEN, &nodeSpeed);
-		node->nodeInfo.speed.z = (double)nodePos;
 
 		// Reset node ttl
 		node->ttlCnt = 0;
 
 		// Calculate time deviation
-		uint32_t frameNum, slotNum = 0;
+		uint32_t frameNum = message->common.frameNum;
-		L2_FrameGetChunk(msg, L2_MSG_FRAME_NUM, L2_MSG_FRAME_NUM_LEN, &frameNum);
+		uint32_t slotNum = (uint32_t)message->common.slotNum;
-		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)
 		{
@@ -586,61 +366,22 @@ int32_t L2_Scan_PktHandler(L2_INST *instPtr, uint8_t *msg)
 			break;
 		}
 
-		if (L2_GetNodeType(instPtr) != L2_NODE_HEAD)
+		if (L2_GetMainState(instPtr) == L2_INIT_STATE) // FIXME: state switch should follow routing table
 		{
-			// check if net setup finished.
+			// Assert Net-Setup Done.
-			if (L2_isCxn2Net(instPtr) == false)
+			L2_EVENT l2Event;
-			{
+			L2_NODE_STATE newState = L2_NORMAL_STATE;
-				// Assert Net-Setup Done.
+			l2Event.event = L2_EV_MAIN_STATE_UPDATE;
-				L2_EVENT l2Event;
+			l2Event.msg = &newState;
-				l2Event.event = L2_EV_NET_SETUP_DONE;
+			(void)AssertL2Event(instPtr, &l2Event);
-				l2Event.msg = NULL;
-				AssertL2Event(instPtr, &l2Event);
-
-				// Assert update routine event...
-				L2_RTNE_CONFIG newRtneConfig = {0};
-				L2_EVENT rtneUpEvent =
-					{
-						.event = L2_ROUTINE_UPDATE,
-						.msg = &newRtneConfig
-					};
-				newRtneConfig.rtneTable = initTable;
-				newRtneConfig.rtnePrd = ARRAY_SIZE(initTable);
-				(void)AssertL2Event(instPtr, &rtneUpEvent);
-			}
-			PendCfmAck(instPtr->scanFSM);
-			// Time sync.
-			L2_TimeAdjust(instPtr, &(instPtr->log.timeDev));
-		}
-		else
-		{
-			if (L2_GetMainState(instPtr) == L2_INIT_STATE
-				&& L2_GetNodeListLen(instPtr->nodeList) >= instPtr->config.netScale - 1)
-			{
-				// Assert Net-Setup Done.
-				L2_EVENT l2Event;
-				L2_NODE_STATE newState = L2_NORMAL_STATE;
-				l2Event.event = L2_EV_MAIN_STATE_UPDATE;
-				l2Event.msg = &newState;
-				(void)AssertL2Event(instPtr, &l2Event);
-			}
 		}
 
 		// Get data payload
-		uint32_t dataId;
+		uint32_t dataId = message->advDataId;
-		L2_FrameGetChunk(msg, L2_MSG_CFM_PAYLOAD_ID, L2_MSG_CFM_PAYLOAD_ID_LEN, &dataId);
+		SysMonitor_UpdateRecvPayload(message->advData, dataId, L2_PAYLOAD_LEN_ADV);
-
-		if (L2_GetNodeType(instPtr) == L2_NODE_HEAD)
-		{
-			SysMonitor_UpdateRecvPayload(msg + L2_MSG_CFM_PAYLOAD, dataId, PAYLOAD_LEN_FLJ_RX);
-		}
-		else
-		{
-			SysMonitor_UpdateRecvPayload(msg + L2_MSG_CFM_PAYLOAD, dataId, PAYLOAD_LEN_LJ_RX);
-		}
 
 		// Logging...
-		memcpy(instPtr->log.rxLog.data, msg, L2_CMF_PACK_LEN);
+		memcpy(instPtr->log.rxLog.data, msg, Phy_GetFrameLen(L2_L2frame2L1frame(L2_FRAME_ACK, L2_SVC_NONE)));
 		instPtr->log.rxLog.dataId = dataId;
 
 		Status = SUCCESS;
@@ -673,8 +414,7 @@ int32_t L2_Scan_Init(L2_SCAN_FSM **scanFSMPtr)
 		return ENOMEM;
 	}
 	L2_Scan_Reset(*scanFSMPtr);
-	(*scanFSMPtr)->beamNo = 0;
+	(*scanFSMPtr)->antIndex = 0;
-	(*scanFSMPtr)->tableNo = 0;
 	return SUCCESS;
 }
 
@@ -693,10 +433,8 @@ void L2_Scan_Reset(L2_SCAN_FSM *scanFSMPtr)
 	scanFSMPtr->isLocked = false;
 	scanFSMPtr->isAdvRecvd = false;
 	scanFSMPtr->isAckPending = false;
-	scanFSMPtr->scanCnt = 0;
+	scanFSMPtr->advCnt = 0;
-	scanFSMPtr->advTimeout = 0;
 	scanFSMPtr->cfmTimeout = 0;
-	scanFSMPtr->scanStage = L2_SCAN_NONE_STAGE;
 }
 
 /*****************************************************************************/
@@ -713,39 +451,13 @@ void L2_Scan_Destroy(L2_SCAN_FSM *scanFSMPtr)
 	free(scanFSMPtr);
 }
 
-/*****************************************************************************/
-/**
- * @brief  Refresh scan beam table.
- *
- * @param   instPtr	a pointer to linklayer layer instance
- *
- * @return  NONE
- *
- ******************************************************************************/
-void L2_Scan_RefreashScanTable(L2_INST *instPtr)
-{
-	ASSERT(instPtr != NULL);
-	L2_SCAN_FSM *scanFsmPtr = instPtr->scanFSM;
-	PHY_INST *phyRef = instPtr->config.phyInstPtr;
-	if (scanFsmPtr->tableNo == 0)
-	{
-		Phy_SetBeamTable(phyRef, antNrrwPattern_0, scanFsmPtr->beamNo);
-		scanFsmPtr->tableNo = 1;
-	}
-	else
-	{
-		Phy_SetBeamTable(phyRef, antNrrwPattern_1, scanFsmPtr->beamNo);
-		scanFsmPtr->tableNo = 0;
-	}
-}
-
 /*****************************************************************************/
 /**
  * @brief   Execute a member node scan net procedure.
  *
  * @param   instPtr	a pointer to linklayer layer instance
  *
- * @return  used slot (5ms slot).
+ * @return  used slot (2 ms slot).
  *
  ******************************************************************************/
 int32_t L2_Scan_Proc(L2_INST *instPtr)
@@ -758,27 +470,9 @@ int32_t L2_Scan_Proc(L2_INST *instPtr)
 	}
 	int32_t Status;
 	DBG_INFO("-------- ScanNet Process --------\n");
-	switch (scanFSM->scanStage)
+
-	{
+	Status = Scan_AdvHandler(instPtr);
-	case L2_SCAN_NONE_STAGE:
+
-		/* Start Scan. */
-		StageUpdate(scanFSM, L2_SCAN_INIT_STAGE);
-		Status = Scan_InitScanHandler(instPtr);
-		break;
-	case L2_SCAN_INIT_STAGE:
-		Status = Scan_InitScanHandler(instPtr);
-		break;
-	case L2_SCAN_ADV_STAGE:
-		Status = Scan_AdvHandler(instPtr);
-		break;
-	case L2_SCAN_CFM_STAGE:
-		Status = Scan_CfmHandler(instPtr);
-		break;
-	default:
-		DBG_ERROR("Unexpected scan net stage: %" PRId8 ".\n", scanFSM->scanStage);
-		Status = FAILURE;
-		break;
-	}
 	return Status;
 }
 
@@ -789,7 +483,7 @@ int32_t L2_Scan_Proc(L2_INST *instPtr)
  *
  * @param   rtneEntry  Routine configuration
  *
- * @return  used slot (5ms slot).
+ * @return  used slot (2 ms slot).
  *
  ******************************************************************************/
 int32_t L2_Scan_Routine(L2_INST *instPtr, const L2_RTNE_TABLE_ENTRY *rtneEntry)
@@ -797,106 +491,68 @@ int32_t L2_Scan_Routine(L2_INST *instPtr, const L2_RTNE_TABLE_ENTRY *rtneEntry)
 	ASSERT(instPtr != NULL);
 	L2_TOR_TYPE torState;
 	const NODE_ENTRY *commNode;
+	PHY_ANT_INDEX antIndex;
 	PHY_INST *phyRef = instPtr->config.phyInstPtr;
 	DBG_INFO("-------- Scan Routine --------\n");
 
 	if (rtneEntry->slotSeq != 0)
 	{
-		return SUCCESS; // skip
+		return SUCCESS; // skip other slots, only process in the 1st slot
-	}
-
-	if (L2_GetNodeType(instPtr) != L2_NODE_HEAD)
-	{
-		if (rtneEntry->dst == L2_GetNodeId(instPtr) || rtneEntry->dst == L2_BROADCAST_ID)
-		{
-			torState = L2_TOR_RX;
-			commNode = L2_GetNodeById(instPtr->nodeList, rtneEntry->src);
-		}
-		else if (rtneEntry->src == L2_GetNodeId(instPtr) || rtneEntry->src == L2_BROADCAST_ID)
-		{
-			torState = L2_TOR_TX;
-			commNode = L2_GetNodeById(instPtr->nodeList, rtneEntry->dst);
-		}
-		else
-		{
-			torState = L2_TOR_SUSPEND;
-		}
-
-		// Setup antenna beam
-		Phy_SetBeamWidth(phyRef, PHY_ANT_BEAM_16);
-		instPtr->log.lastBeamWidth = PHY_ANT_BEAM_16;
-		if (commNode != NULL)
-		{
-			(void)Phy_SetBeamNo(phyRef, commNode->nodeInfo.beamNo, PHY_ANT_BEAM_16);
-		}
-	}
-	else
-	{
-		if (rtneEntry->dst == L2_GetNodeId(instPtr))
-		{
-			torState = L2_TOR_RX;
-		}
-		else if (rtneEntry->src == L2_GetNodeId(instPtr))
-		{
-			torState = L2_TOR_TX;
-		}
-		else
-		{
-			torState = L2_TOR_SUSPEND;
-		}
-		// Setup antenna beam
-		(void)Phy_SetBeamWidth(phyRef, PHY_ANT_BEAM_120);
-		instPtr->log.lastBeamWidth = PHY_ANT_BEAM_120;
 	}
 
 	switch (rtneEntry->slotType)
 	{
-	case L2_SLOT_SCAN:
+	case L2_SLOT_ADVERTISE:
-		if (L2_GetNodeType(instPtr) != L2_NODE_HEAD && torState == L2_TOR_TX)
+		if (L2_GetNodeType(instPtr) == L2_NODE_HEAD && rtneEntry->src == L2_GetNodeId(instPtr))
 		{
-			DBG_ERROR("Only head node can send init-scan Frame.\n");
+			antIndex = L2_AntId2AntIndex(rtneEntry->dst); // antenna selection based on broadcast id in routing table
+			torState = L2_TOR_TX; // head node transmits messages in advertise slot
+
+			memset(instPtr->sendPktData, 0xAA, L2_PACK_LEN_MAX);
+			if (ScanMsg_Packing(instPtr, L2_FRAME_ADV, rtneEntry->dst) != SUCCESS)
+			{
+				return FAILURE;
+			}
+		}
+		else if (L2_GetNodeType(instPtr) == L2_NODE_MEMBER)
+		{
+			commNode = L2_GetNodeById(instPtr->nodeList, rtneEntry->src);
+			antIndex = commNode->nodeInfo.antIndex; // antenna selection based on node list
+			torState = L2_TOR_RX; // member node receives message in advertise slot
+		}
+		else
+		{
+			DBG_ERROR("Unsupported node type" PRId8 "or wrong routine table in L2_SLOT_ADVERTISE.\n", L2_GetNodeType(instPtr));
 			return FAILURE;
 		}
-		(void)L2_SetupNextSlot(instPtr, torState, L2_SCAN_FRAME);
+		(void)Phy_SetAntIndex(instPtr->config.phyInstPtr, antIndex);
+		(void)L2_SetupNextSlot(instPtr, torState, L2_FRAME_ADV);
 		break;
-
+	case L2_SLOT_ACKNOWLEDGE:
-	case L2_SLOT_ADVERTISE:
+		if (L2_GetNodeType(instPtr) == L2_NODE_HEAD && rtneEntry->dst == L2_GetNodeId(instPtr))
-		if (torState == L2_TOR_TX)
 		{
-			if (L2_GetNodeType(instPtr) != L2_NODE_HEAD)
+			antIndex = PHY_ANT_INDEX_NONE; // FIXME: is antenna index necessary here?
-			{
+			torState = L2_TOR_RX; // head node receives messages in acknowledge slot
-				DBG_ERROR("Only head node can send ADV Frame.\n");
+		}
-				return FAILURE;
+		else if (L2_GetNodeType(instPtr) == L2_NODE_MEMBER)
-			}
+		{
+			commNode = L2_GetNodeById(instPtr->nodeList, rtneEntry->src);
+			antIndex = commNode->nodeInfo.antIndex; // antenna selection based on node list
+			torState = L2_TOR_TX; // member node transmits message in acknowledge slot
+
 			memset(instPtr->sendPktData, 0xAA, L2_PACK_LEN_MAX);
-			if (ScanMsg_Packing(instPtr, L2_ADV_FRAME, rtneEntry->dst) != SUCCESS)
+			if (ScanMsg_Packing(instPtr, L2_FRAME_ACK, rtneEntry->dst) != SUCCESS)
 			{
 				return FAILURE;
 			}
 		}
-		/* Antenna setting (reserved.) */
+		else
-		(void)L2_SetupNextSlot(instPtr, torState, L2_ADV_FRAME);
-		break;
-
-	case L2_SLOT_CONFIRM:
-		if (torState == L2_TOR_TX)
 		{
-			if (L2_GetNodeType(instPtr) != L2_NODE_HEAD)
+			DBG_ERROR("Unsupported node type" PRId8 "or wrong routine table in L2_SLOT_ACKNOWLEDGE.\n", L2_GetNodeType(instPtr));
-			{
+			return FAILURE;
-				if (instPtr->scanFSM->isAckPending == false)
-				{
-					DBG_INFO("Member node has no pending CFM-Ack frame.\n");
-					break;
-				}
-			}
-			memset(instPtr->sendPktData, 0xAA, L2_PACK_LEN_MAX);
-			if (ScanMsg_Packing(instPtr, L2_CFM_FRAME, rtneEntry->dst) != SUCCESS)
-			{
-				return FAILURE;
-			}
 		}
-		/* Antenna setting (reserved.) */
+		(void)Phy_SetAntIndex(instPtr->config.phyInstPtr, antIndex);
-		(void)L2_SetupNextSlot(instPtr, torState, L2_CFM_FRAME);
+		(void)L2_SetupNextSlot(instPtr, torState, L2_FRAME_ACK);
 		break;
 	default:
 		DBG_ERROR("Cannot start a routine for slot type [%" PRId8 "] properly.\n", rtneEntry->slotType);

df_datalink_sp/src/networking/phy_layer/phy_antenna.c

@@ -38,22 +38,10 @@
 
 #define CTRL_WORD_DEFAULT 0x00
 
-#define ANT_MODE_TX_MASK 0x70
+#define ANT_ENABLE 0x01
-#define ANT_MODE_RX_MASK 0x0F
+#define ANT_DISABLE 0x00
-
-#define ANT_MODE_TX_OFF 0x00
-#define ANT_MODE_TX1 BIT(4)
-#define ANT_MODE_TX2 BIT(5)
-#define ANT_MODE_TX3 BIT(6)
-
-#define ANT_MODE_RX_AJ BIT(0)
 #define ANT_MODE_RX_NORMAL 0x00
-
+#define ANT_MODE_RX_AJ 0x01
-#define ANT_MODE_RX_AJ1 (BIT(1) | ANT_MODE_RX_AJ)
-#define ANT_MODE_RX_AJ2 (BIT(2) | ANT_MODE_RX_AJ)
-#define ANT_MODE_RX_AJ3 (BIT(3) | ANT_MODE_RX_AJ)
-
-#define ATN_MODE_DEFAULT (ANT_MODE_TX_OFF | ANT_MODE_RX_NORMAL)
 
 #define DEFAULT_CENTRTAL_FREQ 300U // 4 GHz
 
@@ -265,8 +253,6 @@ void Phy_AntConfigInit(PHY_ANT_CONFIG *antConfig)
 {
 	ASSERT(antConfig != NULL);
 
-	antConfig->rfMode = ATN_MODE_DEFAULT;
-
 	// FIXME: Dummy default value.
 	for (uint8_t ii = 0; ii < L1_ANT_NUM; ii ++)
 	{
@@ -285,80 +271,108 @@ void Phy_AntConfigInit(PHY_ANT_CONFIG *antConfig)
 		antConfig->rfAntiAttn[ii] = 0;
 	}
 
+	antConfig->antControl.antMode = ANT_MODE_RX_NORMAL;
+	antConfig->antControl.antRx1En = ANT_DISABLE;
+	antConfig->antControl.antRx2En = ANT_DISABLE;
+	antConfig->antControl.antRx3En = ANT_DISABLE;
+	antConfig->antControl.antTx1En = ANT_DISABLE;
+	antConfig->antControl.antTx2En = ANT_DISABLE;
+	antConfig->antControl.antTx3En = ANT_DISABLE;
 }
 
 /*****************************************************************************/
 /**
- * @brief	Update antenna power mode setting
+ * @brief	Set tx antenna index
  *
- * @param   instPtr	pointer to physical layer instance
+ * @param   instPtr		pointer to physical layer instance
- * @param   mode	new antenna mode
+ * @param   antTxIndex	target tx antenna index
  *
  * @return	None.
  *
  ******************************************************************************/
-void Phy_AntConfigMode(PHY_INST *instPtr, PHY_ANT_MODE mode)
+void Phy_SetTxAntIndex(PHY_INST *instPtr, PHY_ANT_INDEX antIndex)
 {
 	ASSERT(instPtr != NULL);
-	uint8_t config = instPtr->antConfig.rfMode;
+
-	size_t antIndexCurr = Phy_GetCurrentAntIndex(instPtr);
+	switch (antIndex)
-	switch (mode)
 	{
-	case PHY_ANT_MODE_STANDBY:
+	case PHY_ANT_INDEX_1:
-		config &= ~ANT_MODE_TX_MASK;
+		instPtr->antConfig.antControl.antTx1En = ANT_ENABLE;
-		config |= ANT_MODE_TX_OFF;
+		instPtr->antConfig.antControl.antTx2En = ANT_DISABLE;
+		instPtr->antConfig.antControl.antTx3En = ANT_DISABLE;
 		break;
-	case PHY_ANT_MODE_NORMAL:
+	case PHY_ANT_INDEX_2:
-		config &=  ~(ANT_MODE_TX_MASK | ANT_MODE_RX_MASK);
+		instPtr->antConfig.antControl.antTx1En = ANT_DISABLE;
-		config |= ANT_MODE_RX_NORMAL;
+		instPtr->antConfig.antControl.antTx2En = ANT_ENABLE;
-
+		instPtr->antConfig.antControl.antTx3En = ANT_DISABLE;
-		switch (antIndexCurr)
-		{
-		case 0:
-			config |= ANT_MODE_TX1;
-			break;
-		case 1:
-			config |= ANT_MODE_TX2;
-			break;
-		case 2:
-			config |= ANT_MODE_TX3;
-			break;
-		default:
-			config |= ANT_MODE_TX_OFF;
-			DBG_WARNING("Unknown tx antenna number: %" PRIu8 ", tx is off.\n", antIndexCurr);
-			break;
-		}
 		break;
-	case PHY_ANT_MODE_ANTI_JAM:
+	case PHY_ANT_INDEX_3:
-		config &=  ~(ANT_MODE_TX_MASK | ANT_MODE_RX_MASK);
+		instPtr->antConfig.antControl.antTx1En = ANT_DISABLE;
-
+		instPtr->antConfig.antControl.antTx2En = ANT_DISABLE;
-		switch (antIndexCurr)
+		instPtr->antConfig.antControl.antTx3En = ANT_ENABLE;
-		{
-		case 0:
-			config |= ANT_MODE_TX1;
-			config |= ANT_MODE_RX_AJ1;
-			break;
-		case 1:
-			config |= ANT_MODE_TX2;
-			config |= ANT_MODE_RX_AJ2;
-			break;
-		case 2:
-			config |= ANT_MODE_TX3;
-			config |= ANT_MODE_RX_AJ3;
-			break;
-		default:
-			config |= ANT_MODE_TX_OFF;
-			config |= ANT_MODE_RX_NORMAL;
-			DBG_WARNING("Unknown tx antenna number: %" PRIu8 ", remain normal mode.\n", antIndexCurr);
-			break;
-		}
 		break;
 	default:
-		DBG_ERROR("Unknown antenna mode: %" PRIu8 ", remain previous mode.\n", mode);
+		instPtr->antConfig.antControl.antTx1En = ANT_DISABLE;
-		return;
+		instPtr->antConfig.antControl.antTx2En = ANT_DISABLE;
+		instPtr->antConfig.antControl.antTx3En = ANT_DISABLE;
+		break;
 	}
-	instPtr->phyLog.rfMode = mode;
+}
-	instPtr->antConfig.rfMode = config;
+
+/*****************************************************************************/
+/**
+ * @brief	Set rx antenna index
+ *
+ * @param   instPtr		pointer to physical layer instance
+ * @param   antRxIndex	target rx antenna index
+ *
+ * @return	None.
+ *
+ ******************************************************************************/
+void Phy_SetRxAntIndex(PHY_INST *instPtr, PHY_ANT_INDEX antRxIndex)
+{
+	ASSERT(instPtr != NULL);
+
+	switch (antRxIndex)
+	{
+	case PHY_ANT_INDEX_1:
+		instPtr->antConfig.antControl.antRx1En = ANT_ENABLE;
+		instPtr->antConfig.antControl.antRx2En = ANT_DISABLE;
+		instPtr->antConfig.antControl.antRx3En = ANT_DISABLE;
+		break;
+	case PHY_ANT_INDEX_2:
+		instPtr->antConfig.antControl.antRx1En = ANT_DISABLE;
+		instPtr->antConfig.antControl.antRx2En = ANT_ENABLE;
+		instPtr->antConfig.antControl.antRx3En = ANT_DISABLE;
+		break;
+	case PHY_ANT_INDEX_3:
+		instPtr->antConfig.antControl.antRx1En = ANT_DISABLE;
+		instPtr->antConfig.antControl.antRx2En = ANT_DISABLE;
+		instPtr->antConfig.antControl.antRx3En = ANT_ENABLE;
+		break;
+	default:
+		instPtr->antConfig.antControl.antRx1En = ANT_DISABLE;
+		instPtr->antConfig.antControl.antRx2En = ANT_DISABLE;
+		instPtr->antConfig.antControl.antRx3En = ANT_DISABLE;
+		break;
+	}
+}
+
+/*****************************************************************************/
+/**
+ * @brief	Set rx mode to normal or anti-jamming.
+ *
+ * @param   instPtr		pointer to physical layer instance
+ * @param   antRxMode	target rx mode
+ *
+ * @return	None.
+ *
+ ******************************************************************************/
+void Phy_SetRxMode(PHY_INST *instPtr, PHY_ANT_RX_MODE antRxMode)
+{
+	ASSERT(instPtr != NULL);
+
+	instPtr->antConfig.antControl.antMode = antRxMode;
 	// Sync logs to system monitor
 	SysMonitor_UpdatePhysicalLayerLog(&(instPtr->phyLog));
 }
@@ -374,7 +388,7 @@ void Phy_AntConfigMode(PHY_INST *instPtr, PHY_ANT_MODE mode)
  * 			EPARAM - antenna index exceeds predefined range
  *
  ******************************************************************************/
-int32_t Phy_SetAntIndex(PHY_INST *instPtr, size_t antIndex)
+int32_t Phy_SetAntIndex(PHY_INST *instPtr, PHY_ANT_INDEX antIndex)
 {
 	ASSERT(instPtr != NULL);
 
@@ -385,20 +399,13 @@ int32_t Phy_SetAntIndex(PHY_INST *instPtr, size_t antIndex)
 	}
 	DBG_INFO("Set new antenna index: %" PRId8 "\n", antIndex);
 	instPtr->antIndex.next = antIndex;
+	Phy_SetTxAntIndex(instPtr, antIndex);
+	Phy_SetRxAntIndex(instPtr, antIndex);
 	return SUCCESS;
 }
 
 /**
- * @brief   Get next antenna index.
+ * @brief   Get antenna index of the next slot.
- */
-inline size_t Phy_GetCurrentAntIndex(PHY_INST *instPtr)
-{
-	ASSERT(instPtr != NULL);
-	return instPtr->antIndex.curr;
-}
-
-/**
- * @brief   Get current antenna index.
  */
 inline size_t Phy_GetNextAntIndex(PHY_INST *instPtr)
 {
@@ -406,7 +413,6 @@ inline size_t Phy_GetNextAntIndex(PHY_INST *instPtr)
 	return instPtr->antIndex.next;
 }
 
-
 /** @} PhysicalLayer_AntennaControl*/
 
 /** @} PhysicalLayer*/

df_datalink_sp/src/networking/phy_layer/phy_layer.h

@@ -80,16 +80,19 @@ typedef struct
 	uint8_t rfNormComAttn[L1_ANT_NUM];
 						///< Normal mode RF attenuation for combined channel:
 						/// 0~30 dB, 1dB step
-	uint8_t rfMode;		///< Mode control:
+	struct
-						/// [7]: reserved
+	{
-						/// [6]: Antenna 3 tx control, 1 - enable, 0 - disable
+	  uint8_t antMode : 1; 	/// [0]: Anti-jamming mode control, 1 - enable, 0 - disable
-						/// [5]: Antenna 2 tx control, 1 - enable, 0 - disable
+							///      only one antenna can be selected in anti-jamming mode
-						/// [4]: Antenna 1 tx control, 1 - enable, 0 - disable
+	  uint8_t antRx1En : 1; /// [1]: Anti-jamming antenna 1 select, 1 - enable, 0 - disable
-						/// [3]: Anti-jamming antenna 3 select, 1 - enable, 0 - disable
+	  uint8_t antRx2En : 1; /// [2]: Anti-jamming antenna 2 select, 1 - enable, 0 - disable
-						/// [2]: Anti-jamming antenna 2 select, 1 - enable, 0 - disable
+	  uint8_t antRx3En : 1; /// [3]: Anti-jamming antenna 3 select, 1 - enable, 0 - disable
-						/// [1]: Anti-jamming antenna 1 select, 1 - enable, 0 - disable
+	  uint8_t antTx1En : 1;	/// [4]: Antenna 1 tx control, 1 - enable, 0 - disable
-						///      only one antenna can be selected in anti-jamming mode
+	  uint8_t antTx2En : 1;	/// [5]: Antenna 2 tx control, 1 - enable, 0 - disable
-						/// [0]: Anti-jamming mode control, 1 - enable, 0 - disable
+	  uint8_t antTx3En : 1;	/// [6]: Antenna 3 tx control, 1 - enable, 0 - disable
+	  uint8_t antRsvd : 1;	/// [7]: reserved
+	} antControl;
+
 	uint8_t rfAntiAttn[L1_ANT_CH_NUM];
 						///< Anti-jamming mode RF attenuation, 4 channels:
 						/// 0~60 dB, 1dB step
@@ -141,6 +144,26 @@ typedef enum
 	PHY_ANT_MODE_ANTI_JAM = 3
 } PHY_ANT_MODE;
 
+/**
+ * @enum PHY_ANT_RX_MODE
+ */
+typedef enum
+{
+	PHY_ANT_RX_MODE_NORMAL = 0,
+	PHY_ANT_RX_MODE_AJ = 1
+} PHY_ANT_RX_MODE;
+
+/**
+ * @enum PHY_ANT_INDEX
+ */
+typedef enum
+{
+	PHY_ANT_INDEX_NONE = 0,
+	PHY_ANT_INDEX_1 = 1,
+	PHY_ANT_INDEX_2 = 2,
+	PHY_ANT_INDEX_3 = 3
+} PHY_ANT_INDEX;
+
 /**
  * @struct PHY_RCD
  * @brief Physical Layer recode buffer
@@ -189,7 +212,7 @@ typedef struct
 	bool isValid;			  ///< indicates if last reception frame data valid (crc check pass)
 	TIME_WORD recvSlotTime;	  ///< last slot start time stamp
 	TIME_WORD recvFsTime;	  ///< last frame sync time stamp
-	PHY_RCD antIndex;			  ///< antenna number record
+	PHY_RCD antIndex;		  ///< antenna number record
 	PHY_RCD tor;			  ///< tx rx state record
 	PHY_RCD frameType;		  ///< frame type record
 	uint32_t sendDataOffset;  ///< antenna configuration bram offset (to implement ping-pong data flow)
@@ -198,7 +221,6 @@ typedef struct
 #ifndef EMULATION
 	XAdcPs hwXadc; ///< hardware Xadc instance
 #endif
-	PHY_ANT_ANGLE antNrrwPattern[L1_ANT_PATTERN_NUM]; ///< antenna beam scan pattern
 	HWSTATE hwSate;									  ///< hardware state log
 	PHYLOG phyLog;									  ///< physical state log
 	uint32_t lastLogTime;							  /// physical state log time stamp
@@ -258,9 +280,10 @@ void Phy_GetLastReceivedSlotStartTimeStamp(PHY_INST *instPtr, TIME_WORD *slotSta
  * @{
  */
 void Phy_AntConfigInit(PHY_ANT_CONFIG *antConfig);
-void Phy_AntConfigMode(PHY_INST *instPtr, PHY_ANT_MODE mode);
+void Phy_SetTxAntIndex(PHY_INST *instPtr, PHY_ANT_INDEX antIndex);
-int32_t Phy_SetAntIndex(PHY_INST *instPtr, size_t antIndex);
+void Phy_SetRxAntIndex(PHY_INST *instPtr, PHY_ANT_INDEX antRxIndex);
-size_t Phy_GetCurrentAntIndex(PHY_INST *instPtr);
+void Phy_SetRxMode(PHY_INST *instPtr, PHY_ANT_RX_MODE antRxMode);
+int32_t Phy_SetAntIndex(PHY_INST *instPtr, PHY_ANT_INDEX antIndex);
 size_t Phy_GetNextAntIndex(PHY_INST *instPtr);
 /** @} PhysicalLayer_AntennaControl*/
 

df_datalink_sp/src/system_monitor.h

@@ -141,16 +141,22 @@ typedef struct __attribute__((packed))
 	uint8_t cxnStatus;		///< current connection status
 	uint8_t linkStage;		///< current linklayer working stage
 	uint32_t recxnCnt;		///< reconnect trial count
-	uint8_t beamNo;			///< current working beam number
+	uint8_t antIndex;		///< current working antenna index
-	uint8_t beamWidth;		///< current working beam width
-	uint16_t beamAz;		///< current working beam angle Az
-	uint16_t beamEl;		///< current working beam angle Ez
 	uint16_t advTxCnt;		///< adv frame send count
 	uint16_t advRecvCnt;	///< adv frame received count
 	uint16_t advCorrectCnt; ///< adv frame received correctly count
-	uint32_t cfmTxCnt;		///< cfm frame send count
+	uint32_t ackTxCnt;		///< ack frame send count
-	uint32_t cfmRecvCnt;	///< cfm frame received count
+	uint32_t ackRecvCnt;	///< ack frame received count
-	uint32_t cfmCorrectCnt; ///< adv frame received correctly count
+	uint32_t ackCorrectCnt; ///< ack frame received correctly count
+	uint32_t distTxCnt;		///< dist frame send count
+	uint32_t distRecvCnt;	///< dist frame received count
+	uint32_t distCorrectCnt;///< dist frame received correctly count
+	uint32_t mngTxCnt;		///< mng frame send count
+	uint32_t mngRecvCnt;	///< mng frame received count
+	uint32_t mngCorrectCnt; ///< mng frame received correctly count
+	uint32_t rttTxCnt;		///< rtt frame send count
+	uint32_t rttRecvCnt;	///< rtt frame received count
+	uint32_t rttCorrectCnt; ///< rtt frame received correctly count
 	uint32_t svcTxCnt;		///< svc frame send count
 	uint32_t svcRecvCnt;	///< svc frame received count
 	uint32_t svcCorrectCnt; ///< svc frame received correctly count
@@ -178,7 +184,7 @@ typedef struct __attribute__((packed))
 	double fsyncPAPR;		///< last frame sync peak-average ration
 	uint8_t fsyncFreqCh;	///< last frame sync frequency estimation
 	uint16_t deintlvAmpEst; ///< de-interleave amplitude estimation
-	uint8_t antMode;		///< current antenna working mode
+	uint8_t antControl;		///< current antenna rf mode
 	uint8_t reserve[3];		///< reserved data
 } PHYLOG;