misc update

df_datalink_ge/src/config/app_config.h

@@ -35,6 +35,8 @@
 // 2 - print warnings and errors
 // 1 - print only errors
 // other - print nothing
+
+#define APP_EMULATE_DATA
 #define DATALINK_ENABLE_AUTORECONNECT
 #define DATALINK_ENABLE_AUTOTIMESYNC
 //#define DATALINK_ENABLE_BERTEST

df_datalink_ge/src/main.c

@@ -132,6 +132,47 @@ static MPC_CONFIG mpcConfig = {
 	.txQueueMax = 16,
 	.rxQueueMax = 16
 };
+
+#ifdef APP_EMULATE_DATA
+uint8_t testDataLj[] =
+{
+	0xEA, 0xDF, 0x3F, 0x27, 0xCE, 0x9B, 0xE6, 0x3F,
+	0xB5, 0xA3, 0x38, 0x47, 0x1D, 0x1D, 0xFA, 0x3F,
+	0x39, 0xB4, 0xC8, 0x76, 0xBE, 0xAB, 0x8E, 0x40,
+	0xC9, 0xE8, 0x80, 0x24, 0xEC, 0xCB, 0x13, 0x40,
+	0x37, 0x38, 0x7F, 0x22, 0x72, 0x06, 0xF0, 0x01,
+	0x00, 0x00, 0xB8, 0xAA, 0x08, 0x47, 0x1E, 0xC6,
+	0xB0, 0x47, 0x54, 0xFD, 0xEB, 0x45, 0xA1, 0x8A,
+	0x86, 0x44, 0x43, 0xB6, 0xC8, 0x44, 0x4E, 0x19,
+	0xA8, 0x42
+};
+
+uint8_t testDataFlj[] =
+{
+	0xFD, 0x1E, 0xA5, 0x22, 0x72, 0x02, 0x5A, 0x02,
+	0x00, 0x00, 0x81, 0x97, 0x39, 0x3F, 0xF1, 0xF4,
+	0xC0, 0x3F, 0x27, 0xF1, 0x65, 0x44, 0x53, 0x5C,
+	0xD3, 0x3F, 0xB5, 0x24, 0xA6, 0x22, 0x72, 0x02,
+	0x83, 0x01, 0x00, 0x00, 0xFC, 0xE0, 0x44, 0x47,
+	0xB7, 0x83, 0x35, 0x47, 0xA4, 0xBF, 0xE5, 0xC4,
+	0xE8, 0xDC, 0xD1, 0x44, 0x5D, 0x5D, 0xE7, 0x44,
+	0x7D, 0x1B, 0xE8, 0xC1, 0x60, 0x97, 0x57, 0x42,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x5D, 0x86, 0xA6, 0x22, 0x72, 0x02, 0xA5, 0x02,
+	0x00, 0x00, 0x97, 0x4E, 0xB5, 0x47, 0xC4, 0x2A,
+	0xB0, 0x47, 0x2D, 0x00, 0x21, 0xC5, 0x8A, 0x85,
+	0xD1, 0x44, 0x23, 0xFD, 0xC8, 0x44, 0xA1, 0xC4,
+	0xEA, 0xC1, 0x91, 0x4E, 0x71, 0xC2, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6D, 0xAD,
+	0xA6, 0x22, 0x72, 0x02, 0xA5, 0x02, 0x00, 0x00,
+	0xCD, 0x07, 0xD6, 0x47, 0x1D, 0xA4, 0xCE, 0x47,
+	0x6E, 0x61, 0x33, 0xC5, 0x85, 0x55, 0xD1, 0x44,
+	0x9C, 0x16, 0xBD, 0x44, 0x36, 0xC0, 0xEB, 0xC1,
+	0xF0, 0xFF, 0x5B, 0x42, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x78, 0x25, 0x03, 0x00
+};
+#endif
+
 /************************** Function Prototypes ******************************/
 static struct irq_ctrl_desc *intcDescPtr; // General interrupt controller descriptor
 static struct timer_desc *logTmPtr;
@@ -375,6 +416,10 @@ void ScuTimer_IntrHandler(void *context)
 	{
 		// Refresh log
 		Phy_RefreshHwSate(phyInstPtr);
+		if (TimeCtrl_GetIntCnt(tmcInstPtr) - phyInstPtr->lastLogTime >= PHY_LOG_EXPIRE)
+		{
+			Phy_UpdateLogging(phyInstPtr);
+		}
 
 		if (Mpc_IsEnable(mpcDescPtr))
 		{
@@ -382,6 +427,16 @@ void ScuTimer_IntrHandler(void *context)
 			{
 				DBG_ERROR("Failed to apply remote test.\n");
 			}
+#ifdef APP_EMULATE_DATA
+			if (L2_GetNodeType(linkInstPtr) == L2_NODE_HEAD)
+			{
+				SysMonitor_UpdateSendPayload(testDataFlj, PAYLOAD_LEN_FLJ_TX);
+			}
+			else
+			{
+				SysMonitor_UpdateSendPayload(testDataLj, PAYLOAD_LEN_LJ_TX);
+			}
+#endif
 		}
 
 		XScuTimer_ClearInterruptStatus((XScuTimer *)xdesc->instance);
@@ -443,7 +498,7 @@ int main(void)
 	}
 
 	/* Physical Layer Initialize */
-	Status = Phy_InstInit(&phyInstPtr, &phyConfig);
+	Status = Phy_Init(&phyInstPtr, &phyConfig);
 	if (Status == SUCCESS)
 	{
 		DBG_PRINT("Physical layer Init SUCCESS! \n");

df_datalink_ge/src/mpc/mpc.c

@@ -151,13 +151,14 @@ static int32_t Mpc_GenSelfTestRsp(MPC *instPtr)
 	ASSERT(instPtr != NULL);
 	MPC_HW_FRAME *mpcRsp;
 	uint8_t *msg;
-	if (instPtr->isEnable == false)
+	if (Mpc_IsEnable(instPtr) == false)
 	{
 		DBG_ERROR("System is not enabled!\n");
 		return EIGNORE;
 	}
 	mpcRsp = malloc(sizeof(MPC_HW_FRAME));
-	if (mpcRsp == NULL) {
+	if (mpcRsp == NULL)
+	{
 		DBG_ERROR("Failed to allocate memory for LJ REMOTE TEST Response!\n");
 		return ENOMEM;
 	}
@@ -169,13 +170,13 @@ static int32_t Mpc_GenSelfTestRsp(MPC *instPtr)
 	msg[WD_CMD] = CMD_SELF_TEST;
 	msg[WD_PRD] = MY_PRD_ID;
 	SysMonitor_GetHardwareStatus(hwStatsPtr);
-	if (linkInstPtr->isEnable == false)
+	if (Mpc_IsEnable(instPtr))
 	{
-		msg[WD_ST_RET] = (hwStatsPtr->isSpOk) ? ST_RET_OK : ST_RET_ERROR;
+		msg[WD_ST_RET] = (hwStatsPtr->isSpOk && hwStatsPtr->isAntOk) ? ST_RET_OK : ST_RET_ERROR;
 	}
 	else
 	{
-		msg[WD_ST_RET] = (hwStatsPtr->isSpOk && hwStatsPtr->isAntOk) ? ST_RET_OK : ST_RET_ERROR;
+		msg[WD_ST_RET] = (hwStatsPtr->isSpOk) ? ST_RET_OK : ST_RET_ERROR;
 	}
 	// apply status and omit 2 bytes of overhead.
 	memcpy(msg + WD_SP_FPGA_VOLT, &(hwStatsPtr->spFpgaVolt), ST_RET_INFO_LEN);
@@ -201,47 +202,49 @@ static int32_t Mpc_SystemConfig(MPC *instPtr, uint8_t *msg)
 	if (msg[WD_MODE_CMD] == MODE_CMD_HEAD)
 	{
 		// omit unnecessary reconfiguration
-		if (L2_GetNodeType(linkInstPtr) != L2_NODE_HEAD)
-		{
-			// head node config
+		reconfig = (L2_NODE_HEAD != L2_GetNodeType(linkInstPtr));
 		linkConfig.myType = L2_NODE_HEAD;
-			linkConfig.myId = 1;
-			reconfig = true;
-		}
+		linkConfig.myId = 2;
 	}
 
-	else if (msg[WD_MODE_CMD] == MODE_CMD_MEMBER )
+	else if (msg[WD_MODE_CMD] == MODE_CMD_MEMBER)
 	{
 		// omit unnecessary reconfiguration
-		if (L2_GetNodeType(linkInstPtr) != L2_NODE_MEMBER)
-		{
-			// member node config
+		reconfig = (L2_NODE_MEMBER != L2_GetNodeType(linkInstPtr));
 		linkConfig.myType = L2_NODE_MEMBER;
 		linkConfig.myId = 2;
-			reconfig = true;
-		}
 	}
 	else
 	{
 		// Ignore current command
 		DBG_ERROR("Unexpected config command 0x%02X:0x%02X",
 				  WD_MODE_CMD, msg[WD_MODE_CMD]);
-		return EPARAM;
+		return EIGNORE;
 	}
 
-	if(msg[WD_EN_CMD] == EN_CMD_ON_HIGH_POWER)
+	if (msg[WD_EN_CMD] == EN_CMD_ON_HIGH_POWER)
 	{
 		// high power config
 		Phy_AntConfigMode(phyRef, PHY_ANT_MODE_POWER_FULL);
+		if (reconfig == true || !Mpc_IsEnable(instPtr))
+		{
+			Linklayer_Reconfig(linkInstPtr, &linkConfig);
+		}
+		Linklayer_Start(linkInstPtr);
 		instPtr->isEnable = true;
 	}
-	else if(msg[WD_EN_CMD] == EN_CMD_ON_LOW_POWER)
+	else if (msg[WD_EN_CMD] == EN_CMD_ON_LOW_POWER)
 	{
 		// low power config
 		Phy_AntConfigMode(phyRef, PHY_ANT_MODE_POWER_LOW);
+		if (reconfig == true || !Mpc_IsEnable(instPtr))
+		{
+			Linklayer_Reconfig(linkInstPtr, &linkConfig);
+		}
+		Linklayer_Start(linkInstPtr);
 		instPtr->isEnable = true;
 	}
-	else if(msg[WD_EN_CMD] == EN_CMD_SILENT)
+	else if (msg[WD_EN_CMD] == EN_CMD_SILENT)
 	{
 		// silence config
 		// TODO: better approach?
@@ -256,20 +259,18 @@ static int32_t Mpc_SystemConfig(MPC *instPtr, uint8_t *msg)
 		}
 		Phy_SetupNextSlot(phyRef, PHY_TOR_RX, L1_10KBPS_10MS_FRAME, NULL);
 	}
-	if (reconfig == true)
+	else
 	{
-		Linklayer_Reconfig(linkInstPtr, &linkConfig);
-	}
-	if (instPtr->isEnable == true)
-	{
-		Linklayer_Start(linkInstPtr);
+		// Ignore current command
+		DBG_ERROR("Unexpected config command 0x%02X:0x%02X",
+				  WD_EN_CMD, msg[WD_EN_CMD]);
+		return EIGNORE;
 	}
 	instPtr->mpcLog.lastConfig[0] = msg[WD_MODE_CMD];
 	instPtr->mpcLog.lastConfig[1] = msg[WD_EN_CMD];
 	return SUCCESS;
 }
 
-
 /*****************************************************************************/
 /**
  * @brief   Initialize MPC instance.
@@ -371,13 +372,14 @@ int32_t Mpc_PendRemoteTest(MPC *instPtr)
 {
 	MPC_HW_FRAME *mpcRsp;
 	uint8_t *msg;
-	if (instPtr->isEnable == false)
+	if (!Mpc_IsEnable(instPtr))
 	{
 		DBG_ERROR("System is not enabled!\n");
 		return EIGNORE;
 	}
 	mpcRsp = malloc(sizeof(MPC_HW_FRAME));
-	if (mpcRsp == NULL) {
+	if (mpcRsp == NULL)
+	{
 		DBG_ERROR("Failed to allocate memory for LJ REMOTE TEST Response!\n");
 		return ENOMEM;
 	}
@@ -407,7 +409,8 @@ int32_t Mpc_PendRemoteTest(MPC *instPtr)
 	memcpy(msg + WD_PHY_LOG, &(instPtr->phyLog), WD_PHY_LOG_LEN);
 	memcpy(msg + WD_HARDWARE_ST, &(instPtr->hwState.spFpgaVolt), WD_HARDWARE_ST_LEN);
 
-	if (CircQueuePush(instPtr->txQueue, (void *)mpcRsp) == false){
+	if (CircQueuePush(instPtr->txQueue, (void *)mpcRsp) == false)
+	{
 		free(mpcRsp);
 		DBG_WARNING("SystemBus::TX Queue overflowed!\n");
 		return EQUEUE;

df_datalink_sp/bsp/ps7_cortexa9_0/include/xparameters.h

@@ -24,7 +24,7 @@
 
 /* Definitions for interface TMC */
 #define XPAR_TMC_BASEADDR 0x43C30000
-#define XPAR_TMC_HIGHADDR 0x43C3FFFF
+#define XPAR_TMC_HIGHADDR 0x43C30FFF
 
 #include "xparameters_ps.h"
 
@@ -62,22 +62,22 @@
 #define XPAR_PHY_DATA_INTERFACE_ANT_BEAM_BRAM_CTRL_S_AXI_CTRL_HIGHADDR 0xFFFFFFFFU  
 
 
-/* Definitions for peripheral PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL */
-#define XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_DEVICE_ID 1U
-#define XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_DATA_WIDTH 32U
-#define XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_ECC 0U
-#define XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_FAULT_INJECT 0U
-#define XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_CE_FAILING_REGISTERS 0U
-#define XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_UE_FAILING_REGISTERS 0U
-#define XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_ECC_STATUS_REGISTERS 0U
-#define XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_CE_COUNTER_WIDTH 0U
-#define XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_ECC_ONOFF_REGISTER 0U
-#define XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_ECC_ONOFF_RESET_VALUE 0U
-#define XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_WRITE_ACCESS 0U
-#define XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_S_AXI_BASEADDR 0x40004000U
-#define XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_S_AXI_HIGHADDR 0x40005FFFU
-#define XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_S_AXI_CTRL_BASEADDR 0xFFFFFFFFU  
-#define XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_S_AXI_CTRL_HIGHADDR 0xFFFFFFFFU  
+/* Definitions for peripheral PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL */
+#define XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_DEVICE_ID 1U
+#define XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_DATA_WIDTH 32U
+#define XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_ECC 0U
+#define XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_FAULT_INJECT 0U
+#define XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_CE_FAILING_REGISTERS 0U
+#define XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_UE_FAILING_REGISTERS 0U
+#define XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_ECC_STATUS_REGISTERS 0U
+#define XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_CE_COUNTER_WIDTH 0U
+#define XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_ECC_ONOFF_REGISTER 0U
+#define XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_ECC_ONOFF_RESET_VALUE 0U
+#define XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_WRITE_ACCESS 0U
+#define XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_S_AXI_BASEADDR 0x40004000U
+#define XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_S_AXI_HIGHADDR 0x40005FFFU
+#define XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_S_AXI_CTRL_BASEADDR 0xFFFFFFFFU  
+#define XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_S_AXI_CTRL_HIGHADDR 0xFFFFFFFFU  
 
 
 /* Definitions for peripheral PHY_DATA_INTERFACE_RX_FRAME_BRAM_CTRL */
@@ -93,7 +93,7 @@
 #define XPAR_PHY_DATA_INTERFACE_RX_FRAME_BRAM_CTRL_ECC_ONOFF_RESET_VALUE 0U
 #define XPAR_PHY_DATA_INTERFACE_RX_FRAME_BRAM_CTRL_WRITE_ACCESS 0U
 #define XPAR_PHY_DATA_INTERFACE_RX_FRAME_BRAM_CTRL_S_AXI_BASEADDR 0x40000000U
-#define XPAR_PHY_DATA_INTERFACE_RX_FRAME_BRAM_CTRL_S_AXI_HIGHADDR 0x40001FFFU
+#define XPAR_PHY_DATA_INTERFACE_RX_FRAME_BRAM_CTRL_S_AXI_HIGHADDR 0x40000FFFU
 #define XPAR_PHY_DATA_INTERFACE_RX_FRAME_BRAM_CTRL_S_AXI_CTRL_BASEADDR 0xFFFFFFFFU  
 #define XPAR_PHY_DATA_INTERFACE_RX_FRAME_BRAM_CTRL_S_AXI_CTRL_HIGHADDR 0xFFFFFFFFU  
 
@@ -111,7 +111,7 @@
 #define XPAR_PHY_DATA_INTERFACE_TX_FRAME_BRAM_CTRL_ECC_ONOFF_RESET_VALUE 0U
 #define XPAR_PHY_DATA_INTERFACE_TX_FRAME_BRAM_CTRL_WRITE_ACCESS 0U
 #define XPAR_PHY_DATA_INTERFACE_TX_FRAME_BRAM_CTRL_S_AXI_BASEADDR 0x40002000U
-#define XPAR_PHY_DATA_INTERFACE_TX_FRAME_BRAM_CTRL_S_AXI_HIGHADDR 0x40003FFFU
+#define XPAR_PHY_DATA_INTERFACE_TX_FRAME_BRAM_CTRL_S_AXI_HIGHADDR 0x40002FFFU
 #define XPAR_PHY_DATA_INTERFACE_TX_FRAME_BRAM_CTRL_S_AXI_CTRL_BASEADDR 0xFFFFFFFFU  
 #define XPAR_PHY_DATA_INTERFACE_TX_FRAME_BRAM_CTRL_S_AXI_CTRL_HIGHADDR 0xFFFFFFFFU  
 
@@ -135,8 +135,8 @@
 #define XPAR_BRAM_0_CTRL_BASEADDR 0xFFFFFFFFU  
 #define XPAR_BRAM_0_CTRL_HIGHADDR 0xFFFFFFFEU  
 
-/* Canonical definitions for peripheral PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL */
-#define XPAR_BRAM_1_DEVICE_ID XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_DEVICE_ID
+/* Canonical definitions for peripheral PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL */
+#define XPAR_BRAM_1_DEVICE_ID XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_DEVICE_ID
 #define XPAR_BRAM_1_DATA_WIDTH 32U
 #define XPAR_BRAM_1_ECC 0U
 #define XPAR_BRAM_1_FAULT_INJECT 0U
@@ -165,7 +165,7 @@
 #define XPAR_BRAM_2_ECC_ONOFF_RESET_VALUE 0U
 #define XPAR_BRAM_2_WRITE_ACCESS 0U
 #define XPAR_BRAM_2_BASEADDR 0x40000000U
-#define XPAR_BRAM_2_HIGHADDR 0x40001FFFU
+#define XPAR_BRAM_2_HIGHADDR 0x40000FFFU
 #define XPAR_BRAM_2_CTRL_BASEADDR 0xFFFFFFFFU  
 #define XPAR_BRAM_2_CTRL_HIGHADDR 0xFFFFFFFEU  
 
@@ -182,7 +182,7 @@
 #define XPAR_BRAM_3_ECC_ONOFF_RESET_VALUE 0U
 #define XPAR_BRAM_3_WRITE_ACCESS 0U
 #define XPAR_BRAM_3_BASEADDR 0x40002000U
-#define XPAR_BRAM_3_HIGHADDR 0x40003FFFU
+#define XPAR_BRAM_3_HIGHADDR 0x40002FFFU
 #define XPAR_BRAM_3_CTRL_BASEADDR 0xFFFFFFFFU  
 #define XPAR_BRAM_3_CTRL_HIGHADDR 0xFFFFFFFEU  
 
@@ -346,7 +346,7 @@
 
 /* Definitions for peripheral SYSTEMBUS */
 #define XPAR_SYSTEMBUS_BASEADDR 0x43C10000
-#define XPAR_SYSTEMBUS_HIGHADDR 0x43C11FFF
+#define XPAR_SYSTEMBUS_HIGHADDR 0x43C10FFF
 
 
 /******************************************************************/

df_datalink_sp/bsp/ps7_cortexa9_0/libsrc/bram_v4_3/src/xbram_g.c

@@ -62,23 +62,23 @@ XBram_Config XBram_ConfigTable[] =
 		XPAR_PHY_DATA_INTERFACE_ANT_BEAM_BRAM_CTRL_S_AXI_CTRL_HIGHADDR
 	},
 	{
-		XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_DEVICE_ID,
-		XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_DATA_WIDTH,
-		XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_ECC,
-		XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_FAULT_INJECT,
-		XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_CE_FAILING_REGISTERS,
+		XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_DEVICE_ID,
+		XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_DATA_WIDTH,
+		XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_ECC,
+		XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_FAULT_INJECT,
+		XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_CE_FAILING_REGISTERS,
 		0,
-		XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_UE_FAILING_REGISTERS,
+		XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_UE_FAILING_REGISTERS,
 		0,
-		XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_ECC_STATUS_REGISTERS,
-		XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_CE_COUNTER_WIDTH,
-		XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_ECC_ONOFF_REGISTER,
-		XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_ECC_ONOFF_RESET_VALUE,
-		XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_WRITE_ACCESS,
-		XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_S_AXI_BASEADDR,
-		XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_S_AXI_HIGHADDR,
-		XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_S_AXI_CTRL_BASEADDR,
-		XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_S_AXI_CTRL_HIGHADDR
+		XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_ECC_STATUS_REGISTERS,
+		XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_CE_COUNTER_WIDTH,
+		XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_ECC_ONOFF_REGISTER,
+		XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_ECC_ONOFF_RESET_VALUE,
+		XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_WRITE_ACCESS,
+		XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_S_AXI_BASEADDR,
+		XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_S_AXI_HIGHADDR,
+		XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_S_AXI_CTRL_BASEADDR,
+		XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_S_AXI_CTRL_HIGHADDR
 	},
 	{
 		XPAR_PHY_DATA_INTERFACE_RX_FRAME_BRAM_CTRL_DEVICE_ID,

df_datalink_sp/bsp/system.mss

@@ -33,7 +33,7 @@ END
 BEGIN DRIVER
  PARAMETER DRIVER_NAME = bram
  PARAMETER DRIVER_VER = 4.3
- PARAMETER HW_INSTANCE = phy_data_interface_ant_info_bram_ctrl
+ PARAMETER HW_INSTANCE = phy_data_interface_ant_config_bram_ctrl
 END
 
 BEGIN DRIVER

df_datalink_sp/src/config/app_config.h

@@ -10,7 +10,7 @@
  * History:
  * [2021-04-28]: Initial edition.
  *
- * Copyright(c) 2021 Beijing Institute of Technology.
+ * Copyright(c) 2024 Beijing Institute of Technology.
  * Lab of Communication and Networking
  *
  ******************************************************************************/
@@ -56,7 +56,7 @@
 #define PHY_BASEADDR	XPAR_PHYC_BASEADDR
 #define PHY_BEAM_FORMING_ENABLE
 // -- Antenna Bram Configs
-#define PHY_ANTCONFIG_BRAM_DEVICE_ID XPAR_PHY_DATA_INTERFACE_ANT_INFO_BRAM_CTRL_DEVICE_ID
+#define PHY_ANTCONFIG_BRAM_DEVICE_ID XPAR_PHY_DATA_INTERFACE_ANT_CONFIG_BRAM_CTRL_DEVICE_ID
 #define PHY_ANTINFO_BRAM_DEVICE_ID XPAR_PHY_DATA_INTERFACE_ANT_BEAM_BRAM_CTRL_DEVICE_ID
 // -- Buffers
 #define PHY_TXBUFF_BRAM_DEVICE_ID XPAR_PHY_DATA_INTERFACE_TX_FRAME_BRAM_CTRL_DEVICE_ID

df_datalink_sp/src/drivers/axi_core/spi_engine/spi_engine.c

@@ -697,7 +697,6 @@ int32_t spi_engine_write_and_read(struct spi_desc *desc,
 				  uint8_t *data,
 				  uint16_t bytes_number)
 {
-	uint8_t 		i;
 	uint8_t 		word_len;
 	uint8_t 		words_number;
 	int32_t 		ret;

df_datalink_sp/src/include/circ_queue.h

@@ -1,33 +1,25 @@
 /*****************************************************************************/
 /**
- * Description: A simple circular FIFO bounded queue
+ * @file circ_queue.h
+ * @author FanHao ([email protected])
+ * @brief A simple circular FIFO bounded queue
+ * @version 0.1
+ * @date 2023-02-23
+ * @note Forked from https://github.com/chrismerck/rpa_queue.git
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
  *
- * Author: Fan Hao
- * Date: 2023-02-23 10:29
- * LastEditors: Fan Hao
- * LastEditTime: 2023-02-23 12:53
- * Revisions: Rev 0.0
- * History: 
- * [2023-02-23]: Initial Version.
- * 
- * Copyright(c) 2023 Beijing Institute of Technology.
- * Lab of Communication and Networking
- * NOTE: Forked from https://github.com/chrismerck/rpa_queue.git
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-******************************************************************************/
+ ******************************************************************************/
+
+/**
+ * @addtogroup Utility
+ * @{
+ */
+
+/**
+ * @defgroup CircularQueue
+ * @{
+ */
 
 #ifndef CIRC_QUEUE_H
 #define CIRC_QUEUE_H
@@ -36,76 +28,77 @@
 #include <stdint.h>
 #include <stddef.h>
 
-
 /**
- * opaque structure
+ * @struct CIRC_QUEUE
+ * @brief Circular queue Instance
  */
-typedef struct {
+typedef struct
+{
     void **data;
-  volatile uint32_t nelts; /**< # elements */
-  uint32_t in;  /**< next empty location */
-  uint32_t out;   /**< next filled location */
-  uint32_t bounds;/**< max size of queue */
+    volatile uint32_t nelts; ///< number of elements
+    uint32_t in;             ///< next empty location
+    uint32_t out;            ///< next filled location
+    uint32_t bounds;         ///< max size of queue
 } CIRC_QUEUE;
 
-
-
 /**
- * create a FIFO queue
+ * @brief create a FIFO queue
  * @param queue The new queue
  * @param queue_capacity maximum size of the queue
  * @param a pool to allocate queue from
  */
 bool CircQueueCreate(CIRC_QUEUE **queue, uint32_t queue_capacity);
 
-/** free queue memory -- call after destroy 
+/**
+ * @brief free queue memory -- call after destroy
  * @note we do not free in destroy() to follow pthreads convention
-*/
-void CircQueueFree(CIRC_QUEUE * queue);
+ */
+void CircQueueFree(CIRC_QUEUE *queue);
 
 /**
- * Detects when the CIRC_QUEUE is full. This utility function is expected
+ * @brief Detects when the CIRC_QUEUE is full. This utility function is expected
  * to be called from within critical sections, and is not threadsafe.
  */
 bool isCircQueueFull(CIRC_QUEUE *queue);
 
 /**
- * Detects when the CIRC_QUEUE is empty. This utility function is expected
+ * @brief Detects when the CIRC_QUEUE is empty. This utility function is expected
  * to be called from within critical sections, and is not threadsafe.
  */
 bool isCircQueueEmpty(CIRC_QUEUE *queue);
 
 /**
- * push/add an object to the queue, blocking if the queue is already full
+ * @brief push/add an object to the queue, blocking if the queue is already full
  *
  * @param queue the queue
  * @param data the data
- * @returns RPA_EINTR the blocking was interrupted (try again)
- * @returns RPA_EOF the queue has been terminated
- * @returns RPA_SUCCESS on a successful push
+ * @return RPA_EINTR the blocking was interrupted (try again)
+ * @return RPA_EOF the queue has been terminated
+ * @return RPA_SUCCESS on a successful push
  */
 bool CircQueuePush(CIRC_QUEUE *queue, void *data);
 
-
 /**
- * pop/get an object from the queue, blocking if the queue is already empty
+ * @brief pop/get an object from the queue, blocking if the queue is already empty
  *
  * @param queue the queue
  * @param data the data
- * @returns RPA_EINTR the blocking was interrupted (try again)
- * @returns RPA_EOF if the queue has been terminated
- * @returns RPA_SUCCESS on a successful pop
+ * @return RPA_EINTR the blocking was interrupted (try again)
+ * @return RPA_EOF if the queue has been terminated
+ * @return RPA_SUCCESS on a successful pop
  */
 bool CircQueuePop(CIRC_QUEUE *queue, void **data);
 
 /**
- * returns the size of the queue.
+ * @brief returns the size of the queue.
  *
- * @warning this is not threadsafe, and is intended for reporting/monitoring
- * of the queue.
  * @param queue the queue
- * @returns the size of the queue
+ * @return the size of the queue
  */
 uint32_t CircQueueSize(CIRC_QUEUE *queue);
 
 #endif /* CIRC_QUEUE_H */
+
+/** @} CircularQueue*/
+
+/** @} Utility*/

df_datalink_sp/src/include/clist.h

@@ -1,9 +1,25 @@
+/*****************************************************************************/
+/**
+ * @file clist.h
+ * @author FanHao ([email protected])
+ * @brief A basic list data structure
+ * @version 0.1
+ * @date 2023-02-23
+ * @note Forked from https://github.com/clibs/list
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
+ *
+ ******************************************************************************/
 
-//
-// clist.h
-//
-// Copyright (c) 2010 TJ Holowaychuk <[email protected]>
-//
+/**
+ * @addtogroup Utility
+ * @{
+ */
+
+/**
+ * @defgroup cList
+ * @{
+ */
 
 #ifndef __CLIST_H__
 #define __CLIST_H__
@@ -16,48 +32,48 @@ extern "C"
 #include <stdlib.h>
 #include <stdint.h>
 
-  /*
-   * clist_t iterator direction.
+	/**
+	 * @enum clist_direction_t
+	 * @brief clist_t iterator direction.
 	 */
-
 	typedef enum
 	{
 		LIST_HEAD,
 		LIST_TAIL
 	} clist_direction_t;
 
-  /*
-   * clist_t node struct.
+	/**
+	 * @struct clist_node_t
+	 * @brief clist_t node struct.
 	 */
-
 	typedef struct clist_node
 	{
-    struct clist_node *prev;
-    struct clist_node *next;
+		struct clist_node *prev; ///< previous node
+		struct clist_node *next; ///< next node
 		void *val;
 	} clist_node_t;
 
-  /*
-   * clist_t struct.
+	/**
+	 * @struct clist_t
+	 * @brief clist_t struct.
 	 */
-
 	typedef struct
 	{
-    clist_node_t *head;
-    clist_node_t *tail;
-    uint32_t len;
-    void (*free)(void *val);
-    int8_t (*compare)(void *a, void *b);
+		clist_node_t *head;					 ///< first node
+		clist_node_t *tail;					 ///< last node
+		uint32_t len;						 ///< list length
+		void (*free)(void *val);			 ///< node free function handle
+		int8_t (*compare)(void *a, void *b); ///< node compare function handle
 	} clist_t;
 
-  /*
-   * clist_t iterator struct.
+	/**
+	 * @struct clist_iterator_t
+	 * @brief clist_t iterator struct.
 	 */
-
 	typedef struct
 	{
-    clist_node_t *next;
-    clist_direction_t direction;
+		clist_node_t *next;			 ///< next element
+		clist_direction_t direction; ///< iter direction
 	} clist_iterator_t;
 
 	// Node prototypes.
@@ -116,3 +132,7 @@ extern "C"
 #endif
 
 #endif /* __CLIBS_LIST_H__ */
+
+/** @} cList*/
+
+/** @} Utility*/

df_datalink_sp/src/include/common.h

@@ -1,20 +1,19 @@
 /*****************************************************************************/
 /**
- * Description: Common definitions
- *
- * Date: 2023-12-21 16:32
- * LastEditors: Fan Hao
- * LastEditTime: 2022-07-16 17:13
- * Revisions: Rev 0.1
- * History:
- * [2023-12-21]: Ensure the code conform ISO C11 standard.
- * [2022-07-16]: New branch for Dijian.
- * [2021-11-16]: Initial version.
- *
- * Copyright(c) 2021 Beijing Institute of Technology.
- * Lab of Communication and Networking
+ * @file common.h
+ * @author FanHao ([email protected])
+ * @brief Common macros
+ * @version 0.0
+ * @date 2022-07-16
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
  *
  ******************************************************************************/
+/**
+ * @defgroup COMMON_MACRO
+ * @{
+ */
+
 /***************************** Include Files *********************************/
 #ifndef __COMMON_H_
 #define __COMMON_H_
@@ -90,3 +89,5 @@
 /************************** Function Prototypes ******************************/
 void AppAssert(const char *file, int line);
 #endif /* __COMMON_H_ */
+
+/** @} */

df_datalink_sp/src/include/error.h

@@ -1,19 +1,19 @@
 /*****************************************************************************/
 /**
- * Description: Error code definitions.
+ * @file common.h
+ * @author FanHao ([email protected])
+ * @brief Common error numbers
+ * @version 0.0
+ * @date 2022-06-18
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
  *
- * Author: Fan Hao
- * Date: 2022-06-18 16:37
- * LastEditors: Fan Hao
- * LastEditTime: 2022-06-18 17:12
- * Revisions: Rev 0.0
- * History:
- * [2022-06-18]: Initial version.
- *
- * Copyright(c) 2022 Beijing Institute of Technology.
- * Lab of Communication and Networking
- *
-******************************************************************************/
+ ******************************************************************************/
+
+/**
+ * @addtogroup COMMON_MACRO
+ * @{
+ */
 
 #ifndef SRC_ERROR_H_
 #define SRC_ERROR_H_
@@ -24,6 +24,11 @@
 /********************** Macros and Constants Definitions **********************/
 /******************************************************************************/
 
+/**
+ * @name ERRORNO
+ * @{
+ */
+
 #ifdef SUCCESS
 #undef SUCCESS
 #endif
@@ -45,3 +50,7 @@
 #define IS_ERR_VALUE(x)	((x) != SUCCESS)
 
 #endif // ERROR_H_
+
+/** @} ERRORNO*/
+
+/** @} COMMON_MACRO*/

df_datalink_sp/src/include/util.h

@@ -1,41 +1,21 @@
-/*******************************************************************************
+/*****************************************************************************/
+/**
  * @file util.h
- *   @brief  Implementation of utility functions.
- *   @author DBogdan ([email protected])
-********************************************************************************
- * Copyright 2018(c) Analog Devices, Inc.
+ * @author FanHao ([email protected])
+ * @brief Utility functions header file
+ * @version 0.0
+ * @date 2023-05-06
  *
- * All rights reserved.
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *  - Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- *  - Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in
- *    the documentation and/or other materials provided with the
- *    distribution.
- *  - Neither the name of Analog Devices, Inc. nor the names of its
- *    contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *  - The use of this software may or may not infringe the patent rights
- *    of one or more patent holders.  This license does not release you
- *    from the requirement that you obtain separate licenses from these
- *    patent holders to use this software.
- *  - Use of the software either in source or binary form, must be run
- *    on or directly connected to an Analog Devices Inc. component.
- *
- * THIS SOFTWARE IS PROVIDED BY ANALOG DEVICES "AS IS" AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, NON-INFRINGEMENT,
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL ANALOG DEVICES BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, INTELLECTUAL PROPERTY RIGHTS, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*******************************************************************************/
+ ******************************************************************************/
+
+/**
+ * @defgroup Utility
+ * @{
+ */
+
 #ifndef __UTIL_H_
 #define __UTIL_H_
 
@@ -193,3 +173,5 @@ bool crc16_check(uint8_t *buffPtr, uint32_t dataLen, uint32_t crcOffset, uint16_
 int crc8_gen(uint8_t *buffPtr, uint32_t dataLen, uint16_t poly, uint8_t *crcVal);
 bool crc8_check(uint8_t *buffPtr, uint32_t dataLen, uint32_t crcOffset, uint16_t poly);
 #endif // __UTIL_H_
+
+/** @} */

df_datalink_sp/src/lscript.ld

@@ -23,9 +23,9 @@ _UNDEF_STACK_SIZE = DEFINED(_UNDEF_STACK_SIZE) ? _UNDEF_STACK_SIZE : 1024;
 
 MEMORY
 {
-   phy_data_interface_rx_frame_bram_ctrl_Mem0 : ORIGIN = 0x40000000, LENGTH = 0x2000
-   phy_data_interface_tx_frame_bram_ctrl_Mem0 : ORIGIN = 0x40002000, LENGTH = 0x2000
-   phy_data_interface_ant_info_bram_ctrl_Mem0 : ORIGIN = 0x40004000, LENGTH = 0x2000
+   phy_data_interface_rx_frame_bram_ctrl_Mem0 : ORIGIN = 0x40000000, LENGTH = 0x1000
+   phy_data_interface_tx_frame_bram_ctrl_Mem0 : ORIGIN = 0x40002000, LENGTH = 0x1000
+   phy_data_interface_ant_config_bram_ctrl_Mem0 : ORIGIN = 0x40004000, LENGTH = 0x2000
    phy_data_interface_ant_beam_bram_ctrl_Mem0 : ORIGIN = 0x42000000, LENGTH = 0x1000
    ps7_ddr_0 : ORIGIN = 0x100000, LENGTH = 0x1FF00000
    ps7_qspi_linear_0 : ORIGIN = 0xFC000000, LENGTH = 0x1000000

df_datalink_sp/src/main.c

@@ -10,7 +10,7 @@
  * History:
  * [2023-05-07]: Initial edition.
  *
- * Copyright(c) 2021 Beijing Institute of Technology.
+ * Copyright(c) 2024 Beijing Institute of Technology.
  *
  ******************************************************************************/
 
@@ -360,6 +360,11 @@ void ScuTimer_IntrHandler(void *context)
 	{
 		// Refresh log
 		Phy_RefreshHwSate(phyInstPtr);
+		if (TimeCtrl_GetIntCnt(tmcInstPtr) - phyInstPtr->lastLogTime >= PHY_LOG_EXPIRE)
+		{
+			Phy_UpdateLogging(phyInstPtr);
+		}
+
 		XScuTimer_ClearInterruptStatus((XScuTimer *)xdesc->instance);
 	}
 	else
@@ -420,7 +425,7 @@ int main(void)
 	}
 
 	/* Physical Layer Initialize */
-	Status = Phy_InstInit(&phyInstPtr, &phyConfig);
+	Status = Phy_Init(&phyInstPtr, &phyConfig);
 	if (Status == SUCCESS)
 	{
 		DBG_PRINT("Physical layer Init SUCCESS! \n");

df_datalink_sp/src/networking/link_layer/framing.c

@@ -1,19 +1,25 @@
 /*****************************************************************************/
 /**
- * Description:  Functions for framing operations.
+ * @file framing.h
+ * @author FanHao ([email protected])
+ * @brief DF Linklayer framing functions.
+ * @version 0.0
+ * @date 2023-05-06
  *
- * Date: 2022-07-16 14:17
- * LastEditors: Fan Hao
- * LastEditTime: 2022-07-16 17:11
- * Revisions: Rev 0.0
- * History:
- * [2022-07-16]: Description of modification.
- *
- * Copyright(c) 2022 Beijing Institute of Technology.
- * Lab of Communication and Networking
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
  *
  ******************************************************************************/
 
+/**
+ * @addtogroup LinkLayer
+ * @{
+ */
+
+/**
+ * @addtogroup LinkLayer_Framing
+ * @{
+ */
 /***************************** Include Files *********************************/
 #include <stdint.h>
 #include <string.h>
@@ -177,3 +183,7 @@ bool L2_CrcCheck(uint8_t *dataBuff, uint32_t dataLen, L2_CRC_TYPE crcType)
 		return false;
 	}
 }
+
+/** @} LinkLayer_Framing*/
+
+/** @} LinkLayer*/

df_datalink_sp/src/networking/link_layer/geometry/coord.c

@@ -1,8 +1,28 @@
-//
-// Copyright (C) 2020 OpenSim Ltd.
-//
-// SPDX-License-Identifier: LGPL-3.0-or-later
-//
+/*****************************************************************************/
+/**
+ * @file coord.c
+ * @author FanHao ([email protected])
+ * @version 0.0
+ * @date 2023-05-06
+ *
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
+ *
+ ******************************************************************************/
+/**
+ * @addtogroup LinkLayer
+ * @{
+ */
+
+/**
+ * @addtogroup LinkLayerGeometry
+ * @{
+ */
+
+/**
+ * @addtogroup LinkLayerGeometry_Coord
+ * @{
+ */
 
 #include <math.h>
 #include "coord.h"
@@ -209,3 +229,9 @@ COORD Coord_Launch2Inertia(COORD o, COORD p, double A, double B, double we, doub
 
 	return ret;
 }
+
+/** @} LinkLayerGeometry_Coord */
+
+/** @} LinkLayerGeometry */
+
+/** @} LinkLayer */

df_datalink_sp/src/networking/link_layer/geometry/coord.h

@@ -1,20 +1,36 @@
-//
-// Copyright (C) 2020 OpenSim Ltd.
-//
-// SPDX-License-Identifier: LGPL-3.0-or-later
-//
+/*****************************************************************************/
+/**
+ * @file coord.h
+ * @author FanHao ([email protected])
+ * @version 0.0
+ * @date 2023-05-06
+ *
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
+ *
+ ******************************************************************************/
 
 #ifndef _COORD_H
 #define _COORD_H
-
 /**
- * @brief Structure for storing 3D coordinates.
- *
- * Some comparison and basic arithmetic operators are implemented.
- *
- * @ingroup utils
+ * @addtogroup LinkLayer
+ * @{
  */
 
+/**
+ * @defgroup LinkLayerGeometry
+ * @{
+ */
+
+/**
+ * @defgroup LinkLayerGeometry_Coord
+ * @{
+ */
+
+/**
+ * @struct COORD
+ * @brief Structure for storing 3D coordinates.
+ */
 typedef struct
 {
 	double x;
@@ -78,3 +94,9 @@ COORD Coord_GetNormalized(COORD a);
 double Coord_Angle(COORD a, COORD b);
 
 #endif
+
+/** @} LinkLayerGeometry_Coord */
+
+/** @} LinkLayerGeometry */
+
+/** @} LinkLayer */

df_datalink_sp/src/networking/link_layer/geometry/eulerangles.c

@@ -1,8 +1,29 @@
-//
-// Copyright (C) 2020 OpenSim Ltd.
-//
-// SPDX-License-Identifier: LGPL-3.0-or-later
-//
+/*****************************************************************************/
+/**
+ * @file eulerangles.c
+ * @author FanHao ([email protected])
+ * @version 0.0
+ * @date 2023-05-06
+ *
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
+ *
+ ******************************************************************************/
+
+/**
+ * @addtogroup LinkLayer
+ * @{
+ */
+
+/**
+ * @addtogroup LinkLayerGeometry
+ * @{
+ */
+
+/**
+ * @addtogroup LinkLayerGeometry_EulerAngles
+ * @{
+ */
 
 #include <math.h>
 #include "eulerangles.h"
@@ -59,3 +80,9 @@ EULERANGLES EulerAngles_GetNormalize(EULERANGLES e)
 	EulerAngles_Normalize(&e);
 	return e;
 }
+
+/** @} LinkLayerGeometry_EulerAngles */
+
+/** @} LinkLayerGeometry */
+
+/** @} LinkLayer */

df_datalink_sp/src/networking/link_layer/geometry/eulerangles.h

@@ -1,3 +1,30 @@
+/*****************************************************************************/
+/**
+ * @file eulerangles.h
+ * @author FanHao ([email protected])
+ * @version 0.0
+ * @date 2023-05-06
+ *
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
+ *
+ ******************************************************************************/
+
+/**
+ * @addtogroup LinkLayer
+ * @{
+ */
+
+/**
+ * @addtogroup LinkLayerGeometry
+ * @{
+ */
+
+/**
+ * @defgroup LinkLayerGeometry_EulerAngles
+ * @{
+ */
+
 #ifndef __EULERANGLES_H
 #define __EULERANGLES_H
 
@@ -16,6 +43,11 @@
  * rotation along the Y axis rotates Z into X (leans forward), positive rotation
  * along the X axis rotates Y into Z (leans right).
  */
+
+/**
+ * @struct EULERANGLES
+ * @brief Structure for standard quaternion
+ */
 typedef struct
 {
 	double alpha; // unit rad
@@ -53,3 +85,9 @@ void EulerAngles_Normalize(EULERANGLES *e);
 EULERANGLES EulerAngles_GetNormalize(EULERANGLES e);
 
 #endif
+
+/** @} LinkLayerGeometry_EulerAngles */
+
+/** @} LinkLayerGeometry */
+
+/** @} LinkLayer */

df_datalink_sp/src/networking/link_layer/geometry/quaternion.c

@@ -1,8 +1,29 @@
-//
-// Copyright (C) 2014 OpenSim Ltd.
-//
-// SPDX-License-Identifier: LGPL-3.0-or-later
-//
+/*****************************************************************************/
+/**
+ * @file quaternion.c
+ * @author FanHao ([email protected])
+ * @version 0.0
+ * @date 2023-05-06
+ *
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
+ *
+ ******************************************************************************/
+
+/**
+ * @addtogroup LinkLayer
+ * @{
+ */
+
+/**
+ * @addtogroup LinkLayerGeometry
+ * @{
+ */
+
+/**
+ * @addtogroup LinkLayerGeometry_Quaternion
+ * @{
+ */
 
 #include <math.h>
 #include <stdint.h>
@@ -28,6 +49,7 @@ const SOFT_DOUBLE EPS_DOUBLE = {.raw = 0x3CB0000000000000};
 
 const QUATERNION QUATERNION_IDENTITY = {1.0, 0.0, 0.0, 0.0};
 const QUATERNION QUATERNION_NIL = {NAN, NAN, NAN, NAN};
+
 /** @brief Subtracts two quaternions. */
 QUATERNION Quaternion_Sub(QUATERNION q1, QUATERNION q2)
 {
@@ -450,3 +472,9 @@ QUATERNION Quaternion_Slerp(QUATERNION q1, QUATERNION q2, double t)
 		return Quaternion_Lerp(q1, q3, t);
 	}
 }
+
+/** @} LinkLayerGeometry_Quaternion */
+
+/** @} LinkLayerGeometry */
+
+/** @} LinkLayer */

df_datalink_sp/src/networking/link_layer/geometry/quaternion.h

@@ -1,3 +1,29 @@
+/*****************************************************************************/
+/**
+ * @file quaternion.h
+ * @author FanHao ([email protected])
+ * @version 0.0
+ * @date 2023-05-06
+ *
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
+ *
+ ******************************************************************************/
+
+/**
+ * @addtogroup LinkLayer
+ * @{
+ */
+
+/**
+ * @addtogroup LinkLayerGeometry
+ * @{
+ */
+
+/**
+ * @defgroup LinkLayerGeometry_Quaternion
+ * @{
+ */
 
 #ifndef __QUATERNION_H
 #define __QUATERNION_H
@@ -5,7 +31,10 @@
 #include "coord.h"
 #include "eulerangles.h"
 
-// borrowed and adapted from https://github.com/MegaManSE/willperone/blob/master/Math/quaternion.h
+/**
+ * @struct QUATERNION
+ * @brief Structure for standard quaternion
+ */
 typedef struct
 {
 	double s;
@@ -107,3 +136,9 @@ QUATERNION Quaternion_Lerp(QUATERNION q1, QUATERNION q2, double t);
 QUATERNION Quaternion_Slerp(QUATERNION q1, QUATERNION q2, double t);
 
 #endif
+
+/** @} LinkLayerGeometry_Quaternion */
+
+/** @} LinkLayerGeometry */
+
+/** @} LinkLayer */

df_datalink_sp/src/networking/link_layer/link_layer.c

@@ -1,19 +1,21 @@
 /*****************************************************************************/
 /**
- * Description: A brief description of this file
+ * @file link_layer.c
+ * @author FanHao ([email protected])
+ * @brief DF Linklayer implementation file.
+ * @version 0.1
+ * @date 2023-05-06
  *
- * Date: 2021-11-13 13:32
- * LastEditTime: 2021-11-23 10:57
- * Revisions: Rev 0.0
- * History:
- * [2021-11-23]: Initial version.
- * [2022-03-28]: Add bre test mode.
- *
- * Copyright(c) 2021 Beijing Institute of Technology.
- * Lab of Communication and Networking
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
  *
  ******************************************************************************/
 
+/**
+ * @addtogroup LinkLayer
+ * @{
+ */
+
 /***************************** Include Files *********************************/
 #include <stdlib.h>
 #include <string.h>
@@ -31,7 +33,7 @@
 #endif
 /************************** Constant Definitions *****************************/
 #define NET_START_TIME_INFTY UINT32_MAX
-#define LINK_BROCK_THRESHOLD (3 * 200) // 3 secods
+#define LINK_BROCK_THRESHOLD L2_SLOTS_PER_FRAME // 0.5 secods
 
 /************************** Variable Definitions *****************************/
 /***************** Macros (Inline Functions) Definitions *********************/
@@ -43,6 +45,18 @@ static void L2_SetSlotNum(L2_INST *instPtr, uint32_t newSlotNum);
 static void L2_SetFrameNum(L2_INST *instPtr, uint32_t newFrameNum);
 static void L2_UpdateSlotNum(L2_INST *instPtr);
 static void L2_DataAvailUpdate(L2_INST *instPtr, bool status);
+static void L2_FrameStateUpdate(L2_INST *instPtr);
+
+/**
+ * @brief   Shift L2 status record.(newval->next->curr->last)
+ */
+inline void L2_RcdShift(L2_RCD *rcd, int32_t netxVal)
+{
+	ASSERT(rcd != NULL);
+	rcd->last = rcd->curr;
+	rcd->curr = rcd->next;
+	rcd->next = netxVal;
+}
 
 /**
  * @brief	helper function to update linkelayer state
@@ -102,6 +116,79 @@ static inline void L2_DataAvailUpdate(L2_INST *instPtr, bool status)
 	instPtr->dataAvail = status;
 }
 
+/*****************************************************************************/
+/**
+ * @brief   Update L2 frame state, check if there is any valid L2 frame data in
+ * 			data buffer, update receive frame status.
+ *
+ * @param   instPtr		a pointer to linklayer instance
+ *
+ * @return	NONE.
+ *
+ ******************************************************************************/
+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);
+	// Update frame state.
+	if (Phy_IsFrameValid(phyRef) == false)
+	{
+		L2_DataAvailUpdate(instPtr, false);
+	}
+	else
+	{
+		DBG_INFO("A frame received, checking data validation...\n");
+		DBG_INFO("Last frame type is: %" PRId32 ".\n", instPtr->frame.last);
+		Phy_RetrieveRecvData(phyRef, instPtr->recvPktData);
+		instPtr->log.frameRecv++;
+
+		// Update frame state.
+		switch (recvType)
+		{
+		case L2_SCAN_FRAME:
+		case L2_ADV_FRAME:
+			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:
+			isValid = L2_CrcCheck(instPtr->recvPktData, L2_CMF_PACK_LEN, L2_CRC16_1021);
+			instPtr->log.cfmRecvCnt++;
+			instPtr->log.cfmCorrectCnt = isValid ? instPtr->log.cfmCorrectCnt + 1 : instPtr->log.cfmCorrectCnt;
+			break;
+		case L2_SVC_FRAME:
+#ifndef DATALINK_ENABLE_BERTEST
+			isValid = L2_CrcCheck(instPtr->recvPktData, L2_SVC_PACK_LEN, L2_CRC16_1021);
+#else
+			isValid = true;
+#endif
+			instPtr->log.svcRecvCnt++;
+			instPtr->log.svcCorrectCnt = isValid ? instPtr->log.svcCorrectCnt + 1 : instPtr->log.svcCorrectCnt;
+			break;
+
+		default:
+			isValid = false;
+			break;
+		}
+		if (isValid)
+		{
+			instPtr->log.frameCorrect++;
+			L2_DataAvailUpdate(instPtr, true);
+		}
+		else
+		{
+			L2_DataAvailUpdate(instPtr, false);
+		}
+	}
+}
+
+/**
+ * @addtogroup LinkLayer_Utility
+ * @{
+ */
+
 /**
  * @brief   Get the current node ID.
  */
@@ -147,6 +234,15 @@ inline L2_NODE_STATE L2_GetMainState(L2_INST *instPtr)
 	return instPtr->mainState;
 }
 
+/**
+ * @brief   Check if there is a valid l2 frame.
+ */
+inline bool L2_isStarted(L2_INST *instPtr)
+{
+	ASSERT(instPtr != NULL);
+	return instPtr->isEnable;
+}
+
 /**
  * @brief   Check if there is a valid l2 frame.
  */
@@ -165,6 +261,14 @@ inline bool L2_isCxn2Net(L2_INST *instPtr)
 	return instPtr->cxn2Net;
 }
 
+/**
+ * @brief   Get corresponding frame length in byte of L2 frame.
+ */
+inline uint32_t L2_GetFrameLen(L2_FRAME_TYPE l2FrameType)
+{
+	return Phy_GetFrameLen(L2_L2frame2L1frame(l2FrameType));
+}
+
 /**
  * @brief   Get last frame number.
  */
@@ -272,24 +376,6 @@ inline L2_TOR_TYPE L2_GetNextTor(L2_INST *instPtr)
 	return instPtr->tor.next;
 }
 
-/*****************************************************************************/
-/**
- * @brief   Shift L2 status record.(newval->next->curr->last)
- *
- * @param   instPtr  A pointer to physical layer control instance.
- *
- * @return  NONE.
- *
- ******************************************************************************/
-inline void L2_RcdShift(L2_RCD *rcd, int32_t netxVal)
-{
-	ASSERT(rcd != NULL);
-	rcd->last = rcd->curr;
-	rcd->curr = rcd->next;
-	rcd->next = netxVal;
-}
-
-// FIXME:
 /*****************************************************************************/
 /**
  * @brief   Infer last received frame type.
@@ -317,292 +403,6 @@ L2_FRAME_TYPE L2_GetLastOptFrameType(L2_INST *instPtr)
 		return L2_NONE_FRAME;
 	}
 }
-
-/*****************************************************************************/
-/**
- * @brief   Update L2 frame state, check if there is any valid L2 frame data in
- * 			data buffer, update receive frame status.
- *
- * @param   instPtr		a pointer to linklayer instance
- *
- * @return	NONE.
- *
- ******************************************************************************/
-void L2_FrameStateUpdate(L2_INST *instPtr)
-{
-	ASSERT(instPtr != NULL);
-	PHY_INST *phyRef = instPtr->config.phyInstPtr;
-	bool isValid;
-	L2_FRAME_TYPE recvType = L2_GetLastOptFrameType(instPtr);
-	// Update frame state.
-	if (Phy_IsFrameValid(phyRef) == false)
-	{
-		L2_DataAvailUpdate(instPtr, false);
-	}
-	else
-	{
-		DBG_INFO("A frame received, checking data validation...\n");
-		DBG_INFO("Last frame type is: %" PRId32 ".\n", instPtr->frame.last);
-		Phy_RetrieveRecvData(phyRef, instPtr->recvPktData);
-		instPtr->log.frameRecv++;
-
-		// Update frame state.
-		switch (recvType)
-		{
-		case L2_SCAN_FRAME:
-		case L2_ADV_FRAME:
-			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:
-			isValid = L2_CrcCheck(instPtr->recvPktData, L2_CMF_PACK_LEN, L2_CRC16_1021);
-			instPtr->log.cfmRecvCnt++;
-			instPtr->log.cfmCorrectCnt = isValid ? instPtr->log.cfmCorrectCnt + 1 : instPtr->log.cfmCorrectCnt;
-			break;
-		case L2_SVC_FRAME:
-#ifndef DATALINK_ENABLE_BERTEST
-			isValid = L2_CrcCheck(instPtr->recvPktData, L2_SVC_PACK_LEN, L2_CRC16_1021);
-#else
-			isValid = true;
-#endif
-			instPtr->log.svcRecvCnt++;
-			instPtr->log.svcCorrectCnt = isValid ? instPtr->log.svcCorrectCnt + 1 : instPtr->log.svcCorrectCnt;
-			break;
-
-		default:
-			isValid = false;
-			break;
-		}
-		if (isValid)
-		{
-			instPtr->log.frameCorrect++;
-			L2_DataAvailUpdate(instPtr, true);
-		}
-		else
-		{
-			L2_DataAvailUpdate(instPtr, false);
-		}
-	}
-}
-
-/*****************************************************************************/
-/**
- * @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.
- *
- ******************************************************************************/
-// FIXME: To Complete.
-int32_t L2_SteerBeam2Node(L2_INST *instPtr, uint8_t nodeId)
-{
-	ASSERT(instPtr != NULL);
-	ASSERT(instPtr->config.phyInstPtr != 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.
- *
- * @param   instPtr		a pointer to linklayer instance
- * @param   txrxMode	tx/rx state for next slot
- * @param   frameType	frame type of next slot.
- *
- * @return Corresponding frame length
- *         L2_FRAME_NONE_LEN if the frame type code cannot be recognized.
- *
- ******************************************************************************/
-int32_t L2_SetupNextSlot(L2_INST *instPtr, L2_TOR_TYPE txrxMode, L2_FRAME_TYPE frameType)
-{
-	ASSERT(instPtr != NULL);
-	PHY_INST *phyRef = instPtr->config.phyInstPtr;
-	int32_t Status;
-	if (frameType < L2_SCAN_FRAME || frameType > L2_SVC_FRAME)
-	{
-		return FAILURE;
-	}
-
-	// logging
-	if (txrxMode == L2_TOR_TX)
-	{
-		instPtr->log.frameTx++;
-		switch (frameType)
-		{
-		case L2_ADV_FRAME:
-			instPtr->log.advTxCnt++;
-			break;
-		case L2_CFM_FRAME:
-			instPtr->log.cfmTxCnt++;
-			break;
-		case L2_SVC_FRAME:
-			instPtr->log.svcTxCnt++;
-			break;
-		default:
-			break;
-		}
-	}
-	else if (txrxMode == L2_TOR_RX)
-	{
-		instPtr->log.frameRx++;
-		switch (frameType)
-		{
-		case L2_ADV_FRAME:
-			instPtr->log.advRxCnt++;
-			break;
-		case L2_CFM_FRAME:
-			instPtr->log.cfmRxCnt++;
-			break;
-		case L2_SVC_FRAME:
-			instPtr->log.svcRxCnt++;
-			break;
-		default:
-			break;
-		}
-	}
-
-#if _DEBUG_LEVEL >= 3
-	char *torStr = NULL;
-	char *frameStr = NULL;
-	switch (txrxMode)
-	{
-	case L2_TOR_SUSPEND:
-		torStr = "SUSPEND";
-		break;
-	case L2_TOR_TX:
-		torStr = "TX";
-		break;
-	case L2_TOR_RX:
-		torStr = "RX";
-		break;
-	}
-	switch (frameType)
-	{
-	case L2_SCAN_FRAME:
-		frameStr = "Scan";
-		break;
-	case L2_ADV_FRAME:
-		frameStr = "Advertisement";
-		break;
-	case L2_CFM_FRAME:
-		frameStr = "Confirm";
-		break;
-	case L2_SVC_FRAME:
-		frameStr = "Service";
-		break;
-	default:
-		frameStr = "UNKNOWN Frame";
-		break;
-	}
-	DBG_INFO("# Setup Next Slot # [%" PRIu32 "-%" PRIu32 "], %s, %s.\n",
-			 instPtr->frameNum.next,
-			 instPtr->slotNum.next,
-			 torStr, frameStr);
-#endif
-
-	// Update frame and tx/rx mode record.
-	// Frame types shift (last <- curr <- next)
-	L2_RcdShift(&(instPtr->frame), frameType);
-	L2_RcdShift(&(instPtr->tor), txrxMode);
-
-	TIME_WORD pullTime = {0, 0};
-	pullTime.int_part = TimeCtrl_GetIntCnt(instPtr->config.tmcInstPtr) + 1;
-	Status = Phy_SetTimeWord(phyRef, &pullTime, PHY_TIME_WORD_POLL);
-	if (Status != SUCCESS)
-	{
-		DBG_ERROR("Physical set pull time failed, with error code: %" PRId32 "\n", Status);
-	}
-
-	PHY_TOR_TYPE tor;
-	switch (txrxMode)
-	{
-	case L2_TOR_SUSPEND:
-		tor = PHY_TOR_SUSPEND;
-		break;
-	case L2_TOR_TX:
-		tor = PHY_TOR_TX;
-		break;
-	case L2_TOR_RX:
-		tor = PHY_TOR_RX;
-		break;
-	default:
-		DBG_ERROR("Invalid txrx mode :%" PRId8 ".\n", txrxMode);
-		return EPARAM;
-	}
-
-	Status = Phy_SetupNextSlot(phyRef, tor, L2_L2frame2L1frame(frameType), instPtr->sendPktData);
-	if (Status != SUCCESS)
-	{
-		DBG_ERROR("Physical setup failed, with error code: %" PRId32 "\n", Status);
-	}
-	return Status;
-}
-
-/*****************************************************************************/
-/**
- * @brief   Get corresponding frame length in byte of L2 frame.
- *
- * @param   l2FrameType
- *
- * @return Corresponding frame length
- *         L2_FRAME_NONE_LEN if the frame type code cannot be recognized.
- *
- ******************************************************************************/
-uint32_t L2_GetFrameLen(L2_FRAME_TYPE l2FrameType)
-{
-	return Phy_GetFrameLen(L2_L2frame2L1frame(l2FrameType));
-}
-
 /*****************************************************************************/
 /**
  * @brief   Convert L2 frame type to L1 frame type
@@ -627,6 +427,12 @@ L1_FRAME_TYPE L2_L2frame2L1frame(L2_FRAME_TYPE l2Frame)
 		return L1_NONE_FRAME;
 	}
 }
+/** @} LinkLayer_Utility*/
+
+/**
+ * @defgroup LinkLayer_Main
+ * @{
+ */
 
 /*****************************************************************************/
 /**
@@ -948,7 +754,7 @@ int32_t Linklayer_EventHandler(L2_INST *instPtr, const L2_EVENT *l2Event)
 	case L2_EV_LOST_CXN:
 	{
 		DBG_INFO("Event L2_EV_LOST_CXN asserted....\n");
-		if (instPtr->config.myType == L2_NODE_HEAD)
+		if (L2_GetNodeType(instPtr) == L2_NODE_HEAD)
 		{
 			DBG_ERROR("Illegal event, only None_Head node can assert L2_EV_LOST_CXN.\n");
 			break;
@@ -1171,6 +977,8 @@ int32_t Linklayer_Proc(L2_INST *instPtr)
 {
 	ASSERT(instPtr != NULL);
 	int32_t Status;
+	PHY_INST *phyRef = instPtr->config.phyInstPtr;
+	TMC_INST *tmcRef = instPtr->config.tmcInstPtr;
 
 	if (instPtr->isEnable == false)
 	{
@@ -1179,7 +987,7 @@ int32_t Linklayer_Proc(L2_INST *instPtr)
 	}
 
 	// FIXME: Consider time wrapping.
-	uint32_t nextTimeUnit = (TimeCtrl_GetIntCnt(instPtr->config.tmcInstPtr) + 1) / L2_SLOTS_PER_FRAME;
+	uint32_t nextTimeUnit = (TimeCtrl_GetIntCnt(tmcRef) + 1) / L2_SLOTS_PER_FRAME;
 	if (nextTimeUnit < instPtr->netStartTime)
 	{
 		DBG_WARNING("Linklayer not start yet, next time unit: %" PRIu32 ", start time unit: %" PRIu32 ".\n",
@@ -1211,19 +1019,19 @@ int32_t Linklayer_Proc(L2_INST *instPtr)
 	// Run Link layer routine, setup next slot procedure.
 	if (L2_GetNodeType(instPtr) == L2_NODE_HEAD)
 	{
-		Phy_SetMode(instPtr->config.phyInstPtr, PHY_MODE_PULL);
+		Phy_SetMode(phyRef, PHY_MODE_PULL);
 		Status = Linklayer_Routine(instPtr);
 	}
 	else
 	{ // L2_NODE_MEMBER
 		if (L2_isCxn2Net(instPtr))
 		{
-			Phy_SetMode(instPtr->config.phyInstPtr, PHY_MODE_PULL);
+			Phy_SetMode(phyRef, PHY_MODE_PULL);
 			Status = Linklayer_Routine(instPtr);
 		}
 		else
 		{
-			Phy_SetMode(instPtr->config.phyInstPtr, PHY_MODE_LISTEN);
+			Phy_SetMode(phyRef, PHY_MODE_LISTEN);
 			Status = L2_Scan_Proc(instPtr);
 		}
 	}
@@ -1241,14 +1049,14 @@ int32_t Linklayer_Proc(L2_INST *instPtr)
 	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.nodeType = (L2_GetNodeType(instPtr) == L2_NODE_HEAD) ? 0xAA : 0xCC;
 	instPtr->linkLog.cxnStatus = (instPtr->cxn2Net) ? 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.beamWidth = instPtr->log.lastBeamWidth;
-	instPtr->linkLog.beamAz = instPtr->config.phyInstPtr->antNrrwPattern[instPtr->scanFSM->beamNo].oaxis;
-	instPtr->linkLog.beamEl = instPtr->config.phyInstPtr->antNrrwPattern[instPtr->scanFSM->beamNo].raxis;
+	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;
@@ -1260,9 +1068,211 @@ int32_t Linklayer_Proc(L2_INST *instPtr)
 	instPtr->linkLog.svcCorrectCnt = instPtr->log.svcCorrectCnt;
 	instPtr->linkLog.timeDev = (instPtr->log.timeDev > INT32_MAX)
 								? INT32_MAX : ((instPtr->log.timeDev < INT32_MIN) ? INT32_MIN : (int32_t)instPtr->log.timeDev);
-	instPtr->linkLog.sendId = instPtr->serviceFSM->txLog.dataId;
-	instPtr->linkLog.recvId = instPtr->serviceFSM->rxLog.dataId;
+	instPtr->linkLog.sendId = instPtr->log.txLog.dataId;
+	instPtr->linkLog.recvId = instPtr->log.rxLog.dataId;
 
 	SysMonitor_UpdateLinklayerLog(&(instPtr->linkLog));
 	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.
+ *
+ * @param   instPtr		a pointer to linklayer instance
+ * @param   txrxMode	tx/rx state for next slot
+ * @param   frameType	frame type of next slot.
+ *
+ * @return Corresponding frame length
+ *         L2_FRAME_NONE_LEN if the frame type code cannot be recognized.
+ *
+ ******************************************************************************/
+int32_t L2_SetupNextSlot(L2_INST *instPtr, L2_TOR_TYPE txrxMode, L2_FRAME_TYPE frameType)
+{
+	ASSERT(instPtr != NULL);
+	PHY_INST *phyRef = instPtr->config.phyInstPtr;
+	int32_t Status;
+	if (frameType < L2_SCAN_FRAME || frameType > L2_SVC_FRAME)
+	{
+		return FAILURE;
+	}
+
+	// logging
+	if (txrxMode == L2_TOR_TX)
+	{
+		instPtr->log.frameTx++;
+		switch (frameType)
+		{
+		case L2_ADV_FRAME:
+			instPtr->log.advTxCnt++;
+			break;
+		case L2_CFM_FRAME:
+			instPtr->log.cfmTxCnt++;
+			break;
+		case L2_SVC_FRAME:
+			instPtr->log.svcTxCnt++;
+			break;
+		default:
+			break;
+		}
+	}
+	else if (txrxMode == L2_TOR_RX)
+	{
+		instPtr->log.frameRx++;
+		switch (frameType)
+		{
+		case L2_ADV_FRAME:
+			instPtr->log.advRxCnt++;
+			break;
+		case L2_CFM_FRAME:
+			instPtr->log.cfmRxCnt++;
+			break;
+		case L2_SVC_FRAME:
+			instPtr->log.svcRxCnt++;
+			break;
+		default:
+			break;
+		}
+	}
+
+#if _DEBUG_LEVEL >= 3
+	char *torStr = NULL;
+	char *frameStr = NULL;
+	switch (txrxMode)
+	{
+	case L2_TOR_SUSPEND:
+		torStr = "SUSPEND";
+		break;
+	case L2_TOR_TX:
+		torStr = "TX";
+		break;
+	case L2_TOR_RX:
+		torStr = "RX";
+		break;
+	}
+	switch (frameType)
+	{
+	case L2_SCAN_FRAME:
+		frameStr = "Scan";
+		break;
+	case L2_ADV_FRAME:
+		frameStr = "Advertisement";
+		break;
+	case L2_CFM_FRAME:
+		frameStr = "Confirm";
+		break;
+	case L2_SVC_FRAME:
+		frameStr = "Service";
+		break;
+	default:
+		frameStr = "UNKNOWN Frame";
+		break;
+	}
+	DBG_INFO("# Setup Next Slot # [%" PRIu32 "-%" PRIu32 "], %s, %s.\n",
+			 instPtr->frameNum.next,
+			 instPtr->slotNum.next,
+			 torStr, frameStr);
+#endif
+
+	// Update frame and tx/rx mode record.
+	// Frame types shift (last <- curr <- next)
+	L2_RcdShift(&(instPtr->frame), frameType);
+	L2_RcdShift(&(instPtr->tor), txrxMode);
+
+	TIME_WORD pullTime = {0, 0};
+	pullTime.int_part = TimeCtrl_GetIntCnt(instPtr->config.tmcInstPtr) + 1;
+	Status = Phy_SetTimeWord(phyRef, &pullTime, PHY_TIME_WORD_POLL);
+	if (Status != SUCCESS)
+	{
+		DBG_ERROR("Physical set pull time failed, with error code: %" PRId32 "\n", Status);
+	}
+
+	PHY_TOR_TYPE tor;
+	switch (txrxMode)
+	{
+	case L2_TOR_SUSPEND:
+		tor = PHY_TOR_SUSPEND;
+		break;
+	case L2_TOR_TX:
+		tor = PHY_TOR_TX;
+		break;
+	case L2_TOR_RX:
+		tor = PHY_TOR_RX;
+		break;
+	default:
+		DBG_ERROR("Invalid txrx mode :%" PRId8 ".\n", txrxMode);
+		return EPARAM;
+	}
+
+	Status = Phy_SetupNextSlot(phyRef, tor, L2_L2frame2L1frame(frameType), instPtr->sendPktData);
+	if (Status != SUCCESS)
+	{
+		DBG_ERROR("Physical setup failed, with error code: %" PRId32 "\n", Status);
+	}
+	return Status;
+}
+/** @} LinkLayer_Main*/
+/** @} LinkLayer*/

df_datalink_sp/src/networking/link_layer/link_layer.h

@@ -1,19 +1,21 @@
 /*****************************************************************************/
 /**
- * Description: Header file for df linklayer functions
+ * @file link_layer.h
+ * @author FanHao ([email protected])
+ * @brief DF Linklayer header file.
+ * @version 0.1
+ * @date 2023-05-06
  *
- * Date: 2021-11-13 13:33
- * LastEditTime: 2022-07-16 10:12
- * Revisions: Rev 0.1
- * History:
- * [2022-07-16]: New branch for DiJian.
- * [2021-11-23]: Initial version.
- *
- * Copyright(c) 2021 Beijing Institute of Technology.
- * Lab of Communication and Networking
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
  *
  ******************************************************************************/
 
+/**
+ * @defgroup LinkLayer
+ * @{
+ */
+
 #ifndef __LINK_LAYER_H_
 #define __LINK_LAYER_H_
 
@@ -30,78 +32,96 @@
 #define AssertL2Event(instPtr, event) Linklayer_EventHandler(instPtr, event)
 /**************************** Type Definitions *******************************/
 
+/**
+ * @struct L2_CONFIG
+ * @brief A struct holds all linklayer initialization parameters
+ */
 typedef struct
 {
-	L2_NODE_TYPE myType;
-	bool isInterHead;
-	uint8_t clustId;
-	uint8_t myId;
-	uint8_t headId;
-	uint8_t bkpHeadId;
-	uint8_t netScale;
-	PHY_INST *phyInstPtr;
-	TMC_INST *tmcInstPtr;
+	L2_NODE_TYPE myType;  ///< node type
+	bool isInterHead;	  ///< indicate if node is head node
+	uint8_t clustId;	  ///< node cluster id
+	uint8_t myId;		  ///< node id
+	uint8_t headId;		  ///< head node id
+	uint8_t bkpHeadId;	  ///< backup head id
+	uint8_t netScale;	  ///< net scale
+	PHY_INST *phyInstPtr; ///< pointer to system physical layer instance
+	TMC_INST *tmcInstPtr; ///< pointer to system timer controller layer instance
 } L2_CONFIG;
 
+/**
+ * @struct L2_LOG
+ *  @brief A struct holds linklayer operating log
+ */
 typedef struct
 {
-	uint32_t frameRx;
-	uint32_t frameTx;
-	uint32_t frameRecv;
-	uint32_t frameCorrect;
+	uint32_t frameRx;	   ///< total rx frame count
+	uint32_t frameTx;	   ///< total tx frame count
+	uint32_t frameRecv;	   ///< total received frame count
+	uint32_t frameCorrect; ///< total correctly received frame count
 
-	uint32_t advRxCnt;
-	uint32_t advTxCnt;
-	uint32_t advRecvCnt;
-	uint32_t advCorrectCnt;
+	uint32_t advRxCnt;		///< advertise rx frame count
+	uint32_t advTxCnt;		///< advertise tx frame count
+	uint32_t advRecvCnt;	///< advertise received frame count
+	uint32_t advCorrectCnt; ///< advertise correctly received frame count
 
-	uint32_t cfmRxCnt;
-	uint32_t cfmTxCnt;
-	uint32_t cfmRecvCnt;
-	uint32_t cfmCorrectCnt;
+	uint32_t cfmRxCnt;		///< confirm rx frame count
+	uint32_t cfmTxCnt;		///< confirm tx frame count
+	uint32_t cfmRecvCnt;	///< confirm received frame count
+	uint32_t cfmCorrectCnt; ///< confirm correctly received frame count
 
-	uint32_t svcRxCnt;
-	uint32_t svcTxCnt;
-	uint32_t svcRecvCnt;
-	uint32_t svcCorrectCnt;
+	uint32_t svcRxCnt;		///< service rx frame count
+	uint32_t svcTxCnt;		///< service tx frame count
+	uint32_t svcRecvCnt;	///< service received frame count
+	uint32_t svcCorrectCnt; ///< service correctly received frame count
 
-	int64_t timeDev;
-	uint8_t lastBeamWidth;
-	uint32_t reconnectCnt;
+	int64_t timeDev;	   ///< last time deviation estimation result
+	uint8_t lastBeamWidth; ///< last beam width
+	uint32_t reconnectCnt; ///< reconnect trial count
+
+	PAYLOAD rxLog;
+	PAYLOAD txLog;
 } L2_LOG;
 
+/**
+ * @struct L2_INST
+ * @brief A linklayer instance
+ */
 typedef struct
 {
-	L2_CONFIG config;
-	L2_NODE_INFO myInfo;
-	NODE_LIST *nodeList;
-	L2_SCHD_POOL *schdEventPool;
-	uint32_t netStartTime;
-	bool isEnable;			   // if the node is connected to the network
-	bool dataAvail;			   // if there is a valid received frame data in rx buffer
-	bool cxn2Net;			   // if the node is connected to the network
-	L2_RCD frameNum;		   // stores the last current and next frame number.
-	L2_RCD slotNum;			   // stores the last current and next slot number.
-	L2_RCD frame;			   // stores the last current and next link layer frame type.
-	L2_RCD tor;				   // stores the last current and next link layer tx/rx state.
-	L2_NODE_STATE mainState;   // the main state of link layer state
-	L2_NODE_STATE nextState;   // next state of link layer state, which will be applied to mainState every second.
-	L2_RTNE_CONFIG rtneConfig; // current routine table configuration and status.
-	L2_SCAN_FSM *scanFSM;   // FSM of scan net (link set up)
-	L2_SVC_FSM *serviceFSM; // FSM of service net (data service)
-	uint8_t *sendPktData;
-	uint8_t *recvPktData;
-	L2_LOG log;
+	L2_CONFIG config;			 ///< linklayer configuration parameters
+	L2_NODE_INFO myInfo;		 ///< current node info
+	NODE_LIST *nodeList;		 ///< discovered node list
+	L2_SCHD_POOL *schdEventPool; ///< event schedule pool
+	uint32_t netStartTime;		 ///< network start time
+	bool isEnable;				 ///< indicates if the node is connected to the network
+	bool dataAvail;				 ///< indicates if there is a valid received frame data in rx buffer
+	bool cxn2Net;				 ///< indicates if the node is connected to the network
+	L2_RCD frameNum;			 ///< stores the last current and next frame number.
+	L2_RCD slotNum;				 ///< stores the last current and next slot number.
+	L2_RCD frame;				 ///< stores the last current and next link layer frame type.
+	L2_RCD tor;					 ///< stores the last current and next link layer tx/rx state.
+	L2_NODE_STATE mainState;	 ///< the main state of link layer state
+	L2_NODE_STATE nextState;	 ///< next state of link layer state, which will be applied to mainState every second.
+	L2_RTNE_CONFIG rtneConfig;	 ///< current routine table configuration and status.
+	L2_SCAN_FSM *scanFSM;		 ///< FSM of scan net (link set up)
+	L2_SVC_FSM *serviceFSM;		 ///< FSM of service net (data service)
+	uint8_t *sendPktData;		 ///< send data buffer
+	uint8_t *recvPktData;		 ///< received data buffer
+	L2_LOG log;					 ///< Linklayer operating log
 	// for system log
-	SYSINFO sysInfo;
-	LINKLOG linkLog;
+	SYSINFO sysInfo; ///< system info
+	LINKLOG linkLog; ///< linklayer log for system monitor
 } L2_INST;
 
 /************************** Variable Definitions *****************************/
 extern L2_RTNE_TABLE_ENTRY *initTable[L2_INIT_RTNE_PERIOD];
 extern L2_RTNE_TABLE_ENTRY *normalTable[L2_NORMAL_RTNE_PERIOD];
 /************************** Function Prototypes ******************************/
-// Main
+/**
+ * @defgroup LinkLayer_Main
+ * @{
+ */
 int32_t Linklayer_Init(L2_INST **instPtr, const L2_CONFIG *config);
 int32_t Linklayer_Reconfig(L2_INST *instPtr, const L2_CONFIG *config);
 void Linklayer_Destroy(L2_INST *instPtr);
@@ -112,24 +132,33 @@ 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);
-void L2_FrameStateUpdate(L2_INST *instPtr);
-L2_FRAME_TYPE L2_GetLastOptFrameType(L2_INST *instPtr);
-L1_FRAME_TYPE L2_L2frame2L1frame(L2_FRAME_TYPE l2Frame);
+/** @} LinkLayer_Main*/
 
-// Scheduling Event
+/**
+ * @defgroup LinkLayer_Framing
+ * @{
+ */
+void L2_FrameInsertChunk(uint8_t *frame, size_t offset, size_t bytes, const void *chunk);
+void L2_FrameGetChunk(uint8_t *frame, size_t offset, size_t bytes, void *chunk);
+int32_t L2_CrcAppend(uint8_t *dataBuff, uint32_t dataLen, uint32_t crcPos, L2_CRC_TYPE crcType);
+bool L2_CrcCheck(uint8_t *dataBuff, uint32_t dataLen, L2_CRC_TYPE crcType);
+/** @} LinkLayer_Framing*/
+
+/**
+ * @defgroup LinkLayer_Scheduler
+ * @{
+ */
 void L2_EventPoolHandler(L2_INST *instPtr);
 int32_t L2_ScheduleEventAt(L2_INST *instPtr, L2_SCHD_EVENT *schdEvent, uint32_t frameNo, uint32_t slotNo);
 int32_t L2_ScheduleEventAfter(L2_INST *instPtr, L2_SCHD_EVENT *schdEvent, uint32_t numSlots);
 int32_t L2_RescheduleEventAt(L2_INST *instPtr, L2_SCHD_EVENT *schdEvent, uint32_t frameNo, uint32_t slotNo);
 int32_t L2_RescheduleEventAfter(L2_INST *instPtr, L2_SCHD_EVENT *schdEvent, uint32_t numSlots);
+/** @} LinkLayer_Scheduler*/
 
-// Framing
-void L2_FrameInsertChunk(uint8_t *frame, size_t offset, size_t bytes, const void *chunk);
-void L2_FrameGetChunk(uint8_t *frame, size_t offset, size_t bytes, void *chunk);
-int32_t L2_CrcAppend(uint8_t *dataBuff, uint32_t dataLen, uint32_t crcPos, L2_CRC_TYPE crcType);
-bool L2_CrcCheck(uint8_t *dataBuff, uint32_t dataLen, L2_CRC_TYPE crcType);
-
-// Scanning
+/**
+ * @defgroup LinkLayer_Scan
+ * @{
+ */
 int32_t L2_Scan_Init(L2_SCAN_FSM **scanFSMPtr);
 void L2_Scan_RefreashScanTable(L2_INST *instPtr);
 void L2_Scan_Reset(L2_SCAN_FSM *scanFSMPtr);
@@ -137,21 +166,38 @@ void L2_Scan_Destroy(L2_SCAN_FSM *scanFSMPtr);
 int32_t L2_Scan_Proc(L2_INST *instPtr);
 int32_t L2_Scan_PktHandler(L2_INST *instPtr, uint8_t *msg);
 int32_t L2_Scan_Routine(L2_INST *instPtr, const L2_RTNE_TABLE_ENTRY *schedEntry);
+/** @} LinkLayer_Scan*/
 
-// Service
+/**
+ * @defgroup LinkLayer_Service
+ * @{
+ */
 int32_t L2_Service_Init(L2_SVC_FSM **svcFSMPtr);
 void L2_Service_Reset(L2_SVC_FSM *svcFSMPtr);
 void L2_Service_Destroy(L2_SVC_FSM *svcFSMPtr);
 int32_t L2_Service_PktHandler(L2_INST *instPtr, uint8_t *msg);
 int32_t L2_Service_Proc(L2_INST *instPtr);
 int32_t L2_Service_Routine(L2_INST *instPtr, const L2_RTNE_TABLE_ENTRY *schedEntry);
+/** @} LinkLayer_Service*/
 
-// Miscellaneous
+/**
+ * @defgroup LinkLayer_TimeSync
+ * @{
+ */
+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);
+/** @} LinkLayer_TimeSync*/
+
+/**
+ * @defgroup LinkLayer_Utility
+ * @{
+ */
 uint8_t L2_GetNodeId(L2_INST *instPtr);
 uint8_t L2_GetClusterId(L2_INST *instPtr);
 uint8_t L2_GetHeadId(L2_INST *instPtr);
 L2_NODE_TYPE L2_GetNodeType(L2_INST *instPtr);
 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);
@@ -167,10 +213,10 @@ 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);
-
-// Time syncronization
-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);
-
+L2_FRAME_TYPE L2_GetLastOptFrameType(L2_INST *instPtr);
+L1_FRAME_TYPE L2_L2frame2L1frame(L2_FRAME_TYPE l2Frame);
+/** @} LinkLayer_Utility*/
 
 #endif /* __LINK_LAYER_H_ */
+
+/** @} LinkLayer*/

df_datalink_sp/src/networking/link_layer/link_layer_types.h

@@ -1,17 +1,19 @@
 /*****************************************************************************/
 /**
- * Description: A brief description of this file
+ * @file link_layer_types.h
+ * @author FanHao ([email protected])
+ * @brief DF Linklayer types definition.
+ * @version 0.1
+ * @date 2023-05-06
  *
- * Date: 2022-08-28 22:53
- * LastEditTime: 2022-08-29 00:45
- * Revisions: Rev 0.0
- * History:
- * [2022-08-29]: Initial version.
- *
- * Copyright(c) 2022 Beijing Institute of Technology.
- * Lab of Communication and Networking
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
  *
  ******************************************************************************/
+/**
+ * @defgroup LinkLayer
+ * @{
+ */
 
 #ifndef __LINK_LAYER_DEF_H_
 #define __LINK_LAYER_DEF_H_
@@ -26,6 +28,10 @@
 #include "../config/app_config.h"
 #endif
 /************************** Constant Definitions *****************************/
+/**
+ * @name Linklayer_Common_Constants
+ * @{
+ */
 // Common node ID definition
 #define L2_BROADCAST_ID 0xFF
 #define L2_NONE_ID 0
@@ -39,7 +45,7 @@
 #define L2_FRAMENO_NONE 0
 
 // Common number of slots definition
-#define L2_SLOTS_PER_FRAME 200
+#define L2_SLOTS_PER_FRAME 100
 #define L2_SLOTS_PER_SUBFRAME 20
 
 #define L2_NUM_SLOTS_NONE UINT32_MAX
@@ -48,9 +54,14 @@
 #define L2_NUM_SLOTS_10MS 2
 #define L2_NUM_SLOTS_5MS 1
 #define L2_NUM_SLOTS_SKIP 0
+/** @} Linklayer_Common_Constants*/
 
 /**************************** Type Definitions *******************************/
 
+/**
+ * @struct L2_RCD
+ * @brief Linklayer recode buffer
+ */
 typedef struct
 {
 	uint32_t last;
@@ -58,7 +69,8 @@ typedef struct
 	uint32_t next;
 } L2_RCD;
 
-/** @name Tx/Rx mode code
+/**
+ * @enum L2_TOR_TYPE
  */
 typedef enum
 {
@@ -67,7 +79,8 @@ typedef enum
 	L2_TOR_RX = 2
 } L2_TOR_TYPE;
 
-/** @name Prior information type definition
+/**
+ * @enum L2_NODE_TYPE
  */
 typedef enum
 {
@@ -77,7 +90,8 @@ typedef enum
 	L2_NODE_BACKUP = 3
 } L2_NODE_TYPE;
 
-/** @name Node state type definition
+/**
+ * @enum L2_NODE_STATE
  */
 typedef enum
 {
@@ -89,23 +103,24 @@ typedef enum
 	L2_SEEK_STATE = 5
 } L2_NODE_STATE;
 
-/** @name Node information type definition
- * The following types define the detail node info which needed by the link layer.
+/**
+ * @struct L2_NODE_INFO
+ * @brief Node information struct contains the detail node info which needed by the link layer.
  */
 typedef struct
 {
-	uint8_t nodeId;
-	uint8_t clustId;
-	uint8_t headId;
-	L2_NODE_TYPE nodeType;
-	uint8_t beamNo;
-	COORD pos;
-	COORD speed;
-	QUATERNION attitude;
+	uint8_t nodeId;		   ///< node ID
+	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
+	COORD pos;			   ///< node position
+	COORD speed;		   ///< node speed
+	QUATERNION attitude;   ///< node attitude
 } L2_NODE_INFO;
 
-/** @name L2 event enum
- * A enum of L2 event types.
+/**
+ * @enum L2_EVENT_TYPE
  */
 typedef enum
 {
@@ -123,17 +138,18 @@ typedef enum
 	L2_ROUTINE_UPDATE = 11
 } L2_EVENT_TYPE;
 
-/** @name L2 event
- * A definition of L2 event instance.
+/**
+ * @struct L2_EVENT
+ * @brief Linklayer event instance
  */
 typedef struct
 {
-	L2_EVENT_TYPE event;
-	void *msg;
+	L2_EVENT_TYPE event; ///< event type
+	void *msg;			 ///< event message
 } L2_EVENT;
 
-/** @name Slot types
- * A definition of different slots.
+/**
+ * @enum L2_SLOT_TYPE
  */
 typedef enum
 {
@@ -145,8 +161,8 @@ typedef enum
 	L2_SLOT_SERVICE = 5,
 } L2_SLOT_TYPE;
 
-/** @name Frame types
- * A definition of different frame types.
+/**
+ * @enum L2_FRAME_TYPE
  */
 typedef enum
 {
@@ -157,8 +173,8 @@ typedef enum
 	L2_SVC_FRAME = 4
 } L2_FRAME_TYPE;
 
-/** @name Frame types
- * A definition of different frame types.
+/**
+ * @enum L2_CRC_TYPE
  */
 typedef enum
 {
@@ -168,17 +184,21 @@ typedef enum
 	L2_CRC8_31 = 3
 } L2_CRC_TYPE;
 
-/** @name Schedule subtable entry
- * A definition of Schedule subtable entry.
+/**
+ * @struct L2_RTNE_TABLE_ENTRY
+ * @brief Linklayer routine table entry
  */
 typedef struct
 {
-	L2_SLOT_TYPE slotType : 8;
-	uint8_t slotSeq;
-	uint8_t src;
-	uint8_t dst;
+	L2_SLOT_TYPE slotType : 8; ///< slot type
+	uint8_t slotSeq;		   ///< slot sequence number
+	uint8_t src;			   ///< source node ID
+	uint8_t dst;			   ///< destination node ID
 } L2_RTNE_TABLE_ENTRY;
 
+/**
+ * @enum SCAN_STAGE
+ */
 typedef enum
 {
 	L2_SCAN_NONE_STAGE = 0,
@@ -187,47 +207,56 @@ typedef enum
 	L2_SCAN_CFM_STAGE = 3
 } SCAN_STAGE;
 
-/** @name Scan procedure FSM
+/**
+ * @struct L2_SCAN_FSM
+ * @brief Linklayer scan process FSM instance
  */
 typedef struct
 {
-	bool isLocked;	// init acq done.
-	bool isAdvRecvd; // bm received.
-	bool isAckPending;	// 2way acq done.
-	uint8_t scanCnt;
-	uint8_t advTimeout;
-	uint8_t cfmTimeout;
-	SCAN_STAGE scanStage;  // only for member node
-	uint8_t beamNo;
-	uint8_t tableNo;
+	bool isLocked;		  ///< indicates if init acq done(beam locked).
+	bool isAdvRecvd;	  ///< indicates if advertisement frame done(beam locked).
+	bool isAckPending;	  ///< indicates if confirm message acked
+	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;
 
-
-/** @name Service procedure FSM
+/**
+ * @struct L2_SVC_FSM
+ * @brief Linklayer service process FSM
  */
 typedef struct
 {
-	PAYLOAD rxLog;
-	PAYLOAD txLog;
-	uint32_t pktRecv;
-	uint32_t pktCorrect;
+	uint32_t txCnt;	 ///< tx frame count
+	uint32_t rxCnt;	 ///< rx frame count
+	uint32_t rxdCnt; ///< received frame count
 #ifdef DATALINK_ENABLE_BERTEST
-	uint32_t bitTotal;
-	uint32_t bitError;
-	double lossRate;
-	double errorRate;
+	uint32_t bitTotal; ///< received bits count
+	uint32_t bitError; ///< error bits count
+	double lossRate;   ///< packet loss rate
+	double errorRate;  ///< bit error rate
 #endif
 } L2_SVC_FSM;
 
+/**
+ * @struct L2_RTNE_CONFIG
+ * @brief Linklayer routine table configuration
+ */
 typedef struct
 {
-	L2_RTNE_TABLE_ENTRY **rtneTable;
-	uint32_t rtnePrd;
-	L2_RTNE_TABLE_ENTRY *last;
-	L2_RTNE_TABLE_ENTRY *curr;
-	L2_RTNE_TABLE_ENTRY *next;
+	L2_RTNE_TABLE_ENTRY **rtneTable; ///< routine table
+	uint32_t rtnePrd;				 ///< period of routine table
+	L2_RTNE_TABLE_ENTRY *last;		 ///< last routine entry
+	L2_RTNE_TABLE_ENTRY *curr;		 ///< curent routine entry
+	L2_RTNE_TABLE_ENTRY *next;		 ///< next routine entry
 } L2_RTNE_CONFIG;
 
 /************************** Variable Definitions *****************************/
 
 #endif /* __LINK_LAYER_DEF_H_ */
+
+/** @} LinkLayer*/

df_datalink_sp/src/networking/link_layer/msg_def.h

@@ -1,17 +1,25 @@
 /*****************************************************************************/
 /**
- * Description: Header of 814 linklayer messages
+ * @file msg_def.c
+ * @author FanHao ([email protected])
+ * @brief DF Linklayer message definition constants.
+ * @version 0.0
+ * @date 2023-05-06
  *
- * Date: 2022-07-14 00:08
- * LastEditTime: 2022-07-14 22:52
- * Revisions: Rev 0.0
- * History:
- * [2022-07-14]: Initial version.
- *
- * Copyright(c) 2021 Beijing Institute of Technology.
- * Lab of Communication and Networking
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
  *
  ******************************************************************************/
+
+/**
+ * @addtogroup LinkLayer
+ * @{
+ */
+
+/**
+ * @name LinkLayer_MSG_Constants
+ * @{
+ */
 #ifndef __L2_MSG_DEF_H_
 #define __L2_MSG_DEF_H_
 
@@ -115,5 +123,8 @@
 #define L2_MSG_SVC_CRC 266
 #define L2_MSG_SVC_CRC_LEN 2
 
-
 #endif //__L2_MSG_DEF_H_
+
+/** @} LinkLayer_MSG_Constants*/
+
+/** @} LinkLayer*/

df_datalink_sp/src/networking/link_layer/node_list.c

@@ -1,19 +1,25 @@
 /*****************************************************************************/
 /**
- * Description: Implementations of 814 linklayer local record.
+ * @file node_list.c
+ * @author FanHao ([email protected])
+ * @brief DF Linklayer node list implementation file
+ * @version 0.0
+ * @date 2023-05-06
  *
- * Date: 2022-07-14 00:08
- * LastEditors: Fan Hao
- * LastEditTime: 2022-07-14 22:52
- * Revisions: Rev 0.0
- * History:
- * [2022-07-14]: Initial version.
- *
- * Copyright(c) 2021 Beijing Institute of Technology.
- * Lab of Communication and Networking
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
  *
  ******************************************************************************/
 
+/**
+ * @addtogroup LinkLayer
+ * @{
+ */
+
+/**
+ * @addtogroup LinkLayer_NodeList
+ * @{
+ */
 /***************************** Include Files *********************************/
 #include <stdlib.h>
 #include <string.h>
@@ -94,7 +100,7 @@ int32_t L2_NodeList_Init(NODE_LIST **list)
  * @brief   Clear all nodes in the node list, free allocated memory.
  *
  * @param   list
- *NONE
+ * @return NONE
  *
  ******************************************************************************/
 void L2_NodeList_Clear(NODE_LIST *list)
@@ -123,7 +129,7 @@ void L2_NodeList_Destroy(NODE_LIST *list)
  * @param   list
  * @param   nodeId
  *
- * @return  Node entry
+ * @return  Node entry \n
  *          NULL if node dose not exist.
  *
  ******************************************************************************/
@@ -154,7 +160,7 @@ NODE_ENTRY *L2_GetNodeById(NODE_LIST *list, uint8_t nodeId)
  * @param   nodeId
  * @param   nodeType
  *
- * @return  SUCCESS Node was added successfully.
+ * @return  SUCCESS Node was added successfully.\n
  *          Other       Error occurred.(Node already exist, memory alloc error ect.)
  *
  ******************************************************************************/
@@ -201,7 +207,7 @@ NODE_ENTRY *L2_AppendNode(NODE_LIST *list, uint8_t nodeId, L2_NODE_TYPE nodeType
  * @param   list
  * @param   nodeId
  *
- * @return  SUCCESS Node has been successfully deleted.
+ * @return  SUCCESS Node has been successfully deleted.\n
  *          Other       Node not exist.
  *
  ******************************************************************************/
@@ -227,7 +233,7 @@ int32_t L2_DeleteNodeById(NODE_LIST *list, uint8_t nodeId)
  * @param   list
  * @param   nodeId
  *
- * @return  true node in the list
+ * @return  true node in the list\n
  *          false node not in the list
  *
  ******************************************************************************/
@@ -245,7 +251,7 @@ bool L2_isNodeInList(NODE_LIST *list, uint8_t nodeId)
  * @param   nodeId
  * @param	dst     A pointer to store distance.
  *
- * @return  SUCCESS distance has been successfully store in dst
+ * @return  SUCCESS distance has been successfully store in dst\n
  *          FAILURE Node dose not exit.
  *
  ******************************************************************************/
@@ -273,7 +279,7 @@ int32_t L2_GetDistance(NODE_LIST *list, COORD myCoord, uint8_t nodeId, double *d
  * @param   nodeId
  * @param   newPos A structure stores the corresponding node position info.
  *
- * @return  SUCCESS update successfully.
+ * @return  SUCCESS update successfully.\n
  *          FAILURE node not exist.
  *
  ******************************************************************************/
@@ -300,7 +306,7 @@ int32_t L2_UpdateNodePos(NODE_LIST *list, uint8_t nodeId, const COORD *newPos)
  * @param   nodeId
  * @param   newPos A structure stores the corresponding node position info.
  *
- * @return  SUCCESS update successfully.
+ * @return  SUCCESS update successfully.\n
  *          FAILURE node not exist.
  *
  ******************************************************************************/
@@ -327,7 +333,7 @@ int32_t L2_GetNodePos(NODE_LIST *list, uint8_t nodeId, COORD *pos)
  * @param   nodeId
  * @param   newSpeed A structure stores the corresponding node speed info.
  *
- * @return  SUCCESS update successfully.
+ * @return  SUCCESS update successfully.\n
  *          FAILURE node not exist.
  *
  ******************************************************************************/
@@ -354,7 +360,7 @@ int32_t L2_UpdateNodeSpeed(NODE_LIST *list, uint8_t nodeId, const COORD *newSpee
  * @param   nodeId
  * @param   newSpeed A structure stores the corresponding node speed info.
  *
- * @return  SUCCESS update successfully.
+ * @return  SUCCESS update successfully.\n
  *          FAILURE node not exist.
  *
  ******************************************************************************/
@@ -380,7 +386,7 @@ int32_t L2_GetNodeSpeed(NODE_LIST *list, uint8_t nodeId, COORD *speed)
  * @param   nodeId
  * @param   devi
  *
- * @return  SUCCESS update successfully.
+ * @return  SUCCESS update successfully.\n
  *          FAILURE Node not exist.
  *
  ******************************************************************************/
@@ -432,7 +438,7 @@ int32_t L2_IncNodeTTL(NODE_LIST *list, uint8_t nodeId, uint32_t inc)
  * @param   list
  * @param   nodeId
  *
- * @return  SUCCESS TTL has been successfully cleared.
+ * @return  SUCCESS TTL has been successfully cleared.\n
  *          FAILURE Node not exist.
  *
  ******************************************************************************/
@@ -486,7 +492,7 @@ int32_t L2_GetNodeTTL(NODE_LIST *list, uint8_t nodeId, uint32_t *ttl)
  * @param   operation  A pointer to a function handled "NODE_ENTRY*" as input
  *                  which defines the operations need to be apply.
  *
- * @return SUCCESS Operations has been applied successfully to all nodes.
+ * @return SUCCESS Operations has been applied successfully to all nodes.\n
  *         Other       Error occurred.
  *
  ******************************************************************************/
@@ -545,3 +551,7 @@ int32_t L2_IterDeleteNode(NODE_LIST *list, bool (*condition)(NODE_ENTRY *))
 	clist_iterator_destroy(iter);
 	return SUCCESS;
 }
+
+/** @} LinkLayer_NodeList*/
+
+/** @} LinkLayer*/

df_datalink_sp/src/networking/link_layer/node_list.h

@@ -1,19 +1,27 @@
 /*****************************************************************************/
 /**
- * Description: Header of 814 linklayer local record.
+ * @file node_list.h
+ * @author FanHao ([email protected])
+ * @brief DF Linklayer node list header file
+ * @version 0.0
+ * @date 2023-05-06
  *
- * Date: 2022-07-14 00:08
- * LastEditors: Fan Hao
- * LastEditTime: 2022-07-14 22:52
- * Revisions: Rev 0.0
- * History:
- * [2022-07-14]: Initial version.
- *
- * Copyright(c) 2021 Beijing Institute of Technology.
- * Lab of Communication and Networking
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
  *
  ******************************************************************************/
 
+/**
+ * @addtogroup LinkLayer
+ * @{
+ */
+
+/**
+ * @defgroup LinkLayer_NodeList
+ * @{
+ */
+
+
 /***************************** Include Files *********************************/
 #ifndef NODE_LIST_H_
 #define NODE_LIST_H_
@@ -29,7 +37,11 @@
 /************************** Constant Definitions *****************************/
 /***************** Macros (Inline Functions) Definitions *********************/
 /**************************** Type Definitions *******************************/
-typedef struct NODE_LIST_ENTRY
+/**
+ * @struct NODE_ENTRY
+ * @brief Linklayer discovered node list node entry
+ */
+typedef struct
 {
 	L2_NODE_INFO nodeInfo;
 	uint32_t ttlCnt;
@@ -62,3 +74,6 @@ int32_t L2_IterEditNode(NODE_LIST *list, const void *param, int32_t (*operation)
 int32_t L2_IterDeleteNode(NODE_LIST *list, bool (*condition)(NODE_ENTRY *));
 
 #endif /* NODE_LIST_H_ */
+
+/** @} LinkLayer_NodeList*/
+/** @} LinkLayer*/

df_datalink_sp/src/networking/link_layer/routine_table.c

@@ -1,467 +1,30 @@
 /*****************************************************************************/
 /**
- * Description: Time allocations for df datalink,
- * Date: 2022-07-16 17:05
- * LastEditTime: 2022-07-16 17:05
- * Revisions: Rev 0.1
- * History:
- * [2021-11-13]: Initial version.
+ * @file routine_table.c
+ * @author FanHao ([email protected])
+ * @brief DF Linklayer node list implementation file
+ * @version 0.0
+ * @date 2023-05-06
  *
- * Copyright(c) 2021 Beijing Institute of Technology.
- * Lab of Communication and Networking
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
  *
  ******************************************************************************/
 
+/**
+ * @addtogroup LinkLayer
+ * @{
+ */
+
+/**
+ * @name RoutineTable
+ * @{
+ */
+
 #include <inttypes.h>
 #include "link_layer.h"
 #include "link_layer_types.h"
 
-#define LINKLAYER_INSERT_EXTRGAP
-
-#ifndef LINKLAYER_INSERT_EXTRGAP
-L2_RTNE_TABLE_ENTRY intraScanSubT[L2_SLOTS_PER_FRAME] = {
-// SubFrame 0
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-
-// SubFrame 1
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-
-// SubFrame 2
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-
-// SubFrame 3
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
-	{L2_SLOT_SCAN, 0x01, 0x01, 0xFF},
-	{L2_SLOT_ADVERTISE, 0x00, 0x01, 0xFF},
-	{L2_SLOT_ADVERTISE, 0x01, 0x01, 0xFF},
-	{L2_SLOT_ADVERTISE, 0x02, 0x01, 0xFF},
-	{L2_SLOT_ADVERTISE, 0x03, 0x01, 0xFF},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-// SubFrame 4
-	{L2_SLOT_CONFIRM, 0x00, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x01, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x02, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x03, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x00, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x01, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x02, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x03, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x00, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x01, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x02, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x03, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x00, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x01, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x02, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x03, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x00, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x01, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x02, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x03, 0x01, 0xFF},
-
-// SubFrame 5
-	{L2_SLOT_CONFIRM, 0x00, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x01, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x02, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x03, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x00, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x01, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x02, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x03, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x00, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x01, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x02, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x03, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x00, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x01, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x02, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x03, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x00, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x01, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x02, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x03, 0x01, 0xFF},
-
-// SubFrame 6
-	{L2_SLOT_CONFIRM, 0x00, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x01, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x02, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x03, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x00, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x01, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x02, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x03, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x00, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x01, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x02, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x03, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x00, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x01, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x02, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x03, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x00, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x01, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x02, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x03, 0xFF, 0x01},
-
-// SubFrame 7
-	{L2_SLOT_CONFIRM, 0x00, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x01, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x02, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x03, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x00, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x01, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x02, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x03, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x00, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x01, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x02, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x03, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x00, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x01, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x02, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x03, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x00, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x01, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x02, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x03, 0xFF, 0x01},
-
-// SubFrame 8
-	{L2_SLOT_CONFIRM, 0x00, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x01, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x02, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x03, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x00, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x01, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x02, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x03, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x00, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x01, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x02, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x03, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x00, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x01, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x02, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x03, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x00, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x01, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x02, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x03, 0x01, 0xFF},
-
-// SubFrame 9
-	{L2_SLOT_CONFIRM, 0x00, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x01, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x02, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x03, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x00, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x01, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x02, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x03, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x00, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x01, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x02, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x03, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x00, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x01, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x02, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x03, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x00, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x01, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x02, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x03, 0x01, 0xFF},
-};
-
-L2_RTNE_TABLE_ENTRY normalSub[L2_SLOTS_PER_FRAME] = {
-// SubFrame 0
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-
-// SubFrame 1
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-
-// SubFrame 2
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-
-// SubFrame 3
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-
-// SubFrame 4
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-
-// SubFrame 5
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-
-// SubFrame 6
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-
-// SubFrame 7
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-
-// SubFrame 8
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-
-// SubFrame 9
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-};
-#else
 L2_RTNE_TABLE_ENTRY intraScanSubT[L2_SLOTS_PER_FRAME] = {
 // SubFrame 0
 	{L2_SLOT_SCAN, 0x00, 0x01, 0xFF},
@@ -572,116 +135,6 @@ L2_RTNE_TABLE_ENTRY intraScanSubT[L2_SLOTS_PER_FRAME] = {
 	{L2_SLOT_CONFIRM, 0x02, 0xFF, 0x01},
 	{L2_SLOT_CONFIRM, 0x03, 0xFF, 0x01},
 	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-
-// SubFrame 5
-	{L2_SLOT_CONFIRM, 0x00, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x01, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x02, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x03, 0x01, 0xFF},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_CONFIRM, 0x00, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x01, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x02, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x03, 0x01, 0xFF},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_CONFIRM, 0x00, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x01, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x02, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x03, 0xFF, 0x01},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_CONFIRM, 0x00, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x01, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x02, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x03, 0xFF, 0x01},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-
-// SubFrame 6
-	{L2_SLOT_CONFIRM, 0x00, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x01, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x02, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x03, 0x01, 0xFF},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_CONFIRM, 0x00, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x01, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x02, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x03, 0x01, 0xFF},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_CONFIRM, 0x00, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x01, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x02, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x03, 0xFF, 0x01},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_CONFIRM, 0x00, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x01, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x02, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x03, 0xFF, 0x01},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-
-// SubFrame 7
-	{L2_SLOT_CONFIRM, 0x00, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x01, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x02, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x03, 0x01, 0xFF},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_CONFIRM, 0x00, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x01, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x02, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x03, 0x01, 0xFF},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_CONFIRM, 0x00, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x01, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x02, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x03, 0xFF, 0x01},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_CONFIRM, 0x00, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x01, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x02, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x03, 0xFF, 0x01},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-
-// SubFrame 8
-	{L2_SLOT_CONFIRM, 0x00, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x01, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x02, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x03, 0x01, 0xFF},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_CONFIRM, 0x00, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x01, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x02, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x03, 0x01, 0xFF},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_CONFIRM, 0x00, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x01, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x02, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x03, 0xFF, 0x01},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_CONFIRM, 0x00, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x01, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x02, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x03, 0xFF, 0x01},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-
-// SubFrame 9
-	{L2_SLOT_CONFIRM, 0x00, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x01, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x02, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x03, 0x01, 0xFF},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_CONFIRM, 0x00, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x01, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x02, 0x01, 0xFF},
-	{L2_SLOT_CONFIRM, 0x03, 0x01, 0xFF},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_CONFIRM, 0x00, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x01, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x02, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x03, 0xFF, 0x01},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_CONFIRM, 0x00, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x01, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x02, 0xFF, 0x01},
-	{L2_SLOT_CONFIRM, 0x03, 0xFF, 0x01},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
 };
 
 L2_RTNE_TABLE_ENTRY normalSub[L2_SLOTS_PER_FRAME] = {
@@ -794,118 +247,7 @@ L2_RTNE_TABLE_ENTRY normalSub[L2_SLOTS_PER_FRAME] = {
 	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
 	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
 	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-
-// SubFrame 5
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-
-// SubFrame 6
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-
-// SubFrame 7
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-
-// SubFrame 8
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-
-// SubFrame 9
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x02, 0x01, 0x02},
-	{L2_SLOT_SERVICE, 0x03, 0x01, 0x02},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x02, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x03, 0x02, 0x01},
-	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
 };
-#endif
 
 L2_RTNE_TABLE_ENTRY *initTable[L2_INIT_RTNE_PERIOD] =
 {
@@ -916,3 +258,6 @@ L2_RTNE_TABLE_ENTRY *normalTable[L2_NORMAL_RTNE_PERIOD] =
 {
 	normalSub
 };
+
+/** @} RoutineTable*/
+/** @} LinkLayer*/

df_datalink_sp/src/networking/link_layer/scan.c

@@ -1,18 +1,24 @@
 /*****************************************************************************/
 /**
- * Description: Implementations of df linklayer scan net.
+ * @file scan.c
+ * @author FanHao ([email protected])
+ * @brief DF Linklayer scan implementation file.
+ * @version 0.1
+ * @date 2023-05-06
  *
- * Date: 2021-11-10 19:04
- * LastEditTime: 2022-07-16 17:04
- * Revisions: Rev 0.1
- * History:
- * [2022-07-16]: New branch for DiJian.
- * [2021-11-10]: Initial version.
- *
- * Copyright(c) 2021 Beijing Institute of Technology.
- * Lab of Communication and Networking
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
  *
  ******************************************************************************/
+/**
+ * @addtogroup LinkLayer
+ * @{
+ */
+
+/**
+ * @addtogroup LinkLayer_Scan
+ * @{
+ */
 
 /***************************** Include Files *********************************/
 #include <string.h>
@@ -26,7 +32,7 @@
 
 /************************** Constant Definitions *****************************/
 #define ADV_LISTEN_TIMEOUT 40
-#define CFM_LISTEN_TIMEOUT 25
+#define CFM_LISTEN_TIMEOUT 5
 #define ADV_FRAME_SLOTS 4
 #define CFM_FRAME_SLOTS 5
 /***************** Macros (In-line Functions) Definitions *********************/
@@ -198,30 +204,34 @@ static int32_t Scan_InitScanHandler(L2_INST *instPtr)
 	L2_SCAN_FSM *scanFsmPtr = instPtr->scanFSM;
 	DBG_INFO("** Net-Setup - InitScan Procedure (Attempts: %" PRIu8 ")**\n", scanFsmPtr->scanCnt);
 
-	if(scanFsmPtr->scanCnt == 0)
+	if (scanFsmPtr->scanCnt == 0)
 	{
 		// Update scan beam table
 		L2_Scan_RefreashScanTable(instPtr);
 	}
-	else if(Phy_IsFrameDetected(phyRef))
+	else if (Phy_IsFrameDetected(phyRef))
 	{
 		// last scan beam number
-		instPtr->scanFSM->beamNo = Phy_LastScanBeamNo(instPtr->config.phyInstPtr);
+		scanFsmPtr->beamNo = Phy_LastScanBeamNo(phyRef);
 		// Update scan beam table
 		L2_Scan_RefreashScanTable(instPtr);
 	}
 
 	if (scanFsmPtr->isLocked == true)
 	{
-		StageUpdate(scanFsmPtr, L2_SCAN_ADV_STAGE);
-		/* Antenna setting (reserved.) */
+		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 setting (reserved.) */
+		/* 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;
 }
@@ -239,19 +249,22 @@ static int32_t Scan_InitScanHandler(L2_INST *instPtr)
  ******************************************************************************/
 static int32_t Scan_AdvHandler(L2_INST *instPtr)
 {
+	ASSERT(instPtr != NULL);
 	L2_SCAN_FSM *scanFsmPtr = instPtr->scanFSM;
+	PHY_INST *phyRef = instPtr->config.phyInstPtr;
 	DBG_INFO("** Net-Setup - Advertisement Procedure (Timeout: %" PRIu8 ") **\n", scanFsmPtr->advTimeout);
 
 	// if received a valid bm frame.
 	if (scanFsmPtr->isAdvRecvd == true)
 	{
 		// last scan beam number
-		instPtr->scanFSM->beamNo = Phy_LastScanBeamNo(instPtr->config.phyInstPtr);
+		scanFsmPtr->beamNo = Phy_LastScanBeamNo(phyRef);
+		// reset listen counter.
+		scanFsmPtr->advTimeout = 0;
 
-		scanFsmPtr->advTimeout = 0; /* reset listen counter. */
-		DBG_INFO("Received Adv frame, skipping 10ms for turn around...\n");
-		// TODO: check functionality.
+		// Update scan stage
 		StageUpdate(scanFsmPtr, L2_SCAN_CFM_STAGE);
+		DBG_INFO("Received Adv frame, skipping 10ms for turn around...\n");
 		return SUCCESS;
 	}
 	// no valid bm frame was received.
@@ -260,16 +273,20 @@ static int32_t Scan_AdvHandler(L2_INST *instPtr)
 		/* if time out reached, go back to init scan stage. */
 		if (scanFsmPtr->advTimeout > ADV_LISTEN_TIMEOUT)
 		{
-			/* Antenna setting (reserved.) */
+			/* 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);
 			DBG_WARNING("Adv timeout, restart net scan from L2_SCAN_INIT_STAGE.\n");
 			L2_Scan_Reset(scanFsmPtr);
+			instPtr->log.lastBeamWidth = PHY_ANT_BEAM_16;
 		}
 		else
 		{
-			/* Antenna setting (reserved.) */
+			/* Antenna steering (reserved, automatically accomplished by physical layer) */
+			Phy_SetBeamNo(phyRef, scanFsmPtr->beamNo, PHY_ANT_BEAM_16);
 			L2_SetupNextSlot(instPtr, L2_TOR_RX, L2_ADV_FRAME);
 			scanFsmPtr->advTimeout++;
+			instPtr->log.lastBeamWidth = PHY_ANT_BEAM_16;
 		}
 		return SUCCESS;
 	}
@@ -286,7 +303,9 @@ static int32_t Scan_AdvHandler(L2_INST *instPtr)
  ******************************************************************************/
 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.
@@ -300,9 +319,9 @@ static int32_t Scan_CfmHandler(L2_INST *instPtr)
 	{
 		// using pull mode to receive confirm frame
 		// since first time sync procedure is accomplished in ADV stage.
-		Phy_SetBeamWidth(instPtr->config.phyInstPtr, PHY_ANT_BEAM_16);
-		Phy_SetBeamNo(instPtr->config.phyInstPtr, scanFsmPtr->beamNo, PHY_ANT_BEAM_16);
-		Phy_SetMode(instPtr->config.phyInstPtr, PHY_MODE_PULL);
+		Phy_SetBeamWidth(phyRef, PHY_ANT_BEAM_16);
+		Phy_SetBeamNo(phyRef, scanFsmPtr->beamNo, PHY_ANT_BEAM_16);
+		Phy_SetMode(phyRef, PHY_MODE_PULL);
 		L2_SetupNextSlot(instPtr, L2_TOR_RX, L2_CFM_FRAME);
 		scanFsmPtr->cfmTimeout++; // increase counter.
 		instPtr->log.lastBeamWidth = PHY_ANT_BEAM_16;
@@ -327,12 +346,13 @@ static int32_t ScanMsg_Packing(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t dst
 	int32_t Status;
 	uint32_t dataChunk;
 	uint8_t *buff = instPtr->sendPktData;
-	if(type < L2_ADV_FRAME || type > L2_CFM_FRAME)
+	if (type < L2_ADV_FRAME || type > L2_CFM_FRAME)
 	{
 		DBG_ERROR("Unexpected frame type: %" PRId8 ".\n", type);
 		return EPARAM;
 	}
 
+	// Common section of link layer package
 	dataChunk = L2_GetNextFrameNum(instPtr);
 	L2_FrameInsertChunk(buff, L2_MSG_FRAME_NUM, L2_MSG_FRAME_NUM_LEN, &dataChunk);
 	dataChunk = L2_GetNextSlotNum(instPtr);
@@ -382,7 +402,7 @@ static int32_t ScanMsg_Packing(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t dst
 
 		// Packing extra payload
 		uint32_t dataId;
-		if(L2_GetNodeType(instPtr) == L2_NODE_HEAD)
+		if (L2_GetNodeType(instPtr) == L2_NODE_HEAD)
 		{
 			SysMonitor_GetSendPayload(buff + L2_MSG_CFM_PAYLOAD, &dataId, PAYLOAD_LEN_FLJ_TX);
 		}
@@ -404,6 +424,10 @@ static int32_t ScanMsg_Packing(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t dst
 			DBG_ERROR("Fail to append CRC, error code: %" PRId32 ".\n", Status);
 			return Status;
 		}
+
+		// Logging...
+		memcpy(instPtr->log.txLog.data, buff, L2_CMF_PACK_LEN);
+		instPtr->log.txLog.dataId = dataId;
 		break;
 	}
 	default:
@@ -415,6 +439,208 @@ static int32_t ScanMsg_Packing(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t dst
 	return SUCCESS;
 }
 
+/*****************************************************************************/
+/**
+ * @brief   Scan net packet handler.
+ *
+ * @param   instPtr	a pointer to linklayer layer instance
+ * @param   msg A pointer to frame data buffer.
+ *
+ * @return
+ *
+ ******************************************************************************/
+int32_t L2_Scan_PktHandler(L2_INST *instPtr, uint8_t *msg)
+{
+	ASSERT(instPtr != NULL);
+	ASSERT(msg != NULL);
+	int32_t Status;
+	L2_SCAN_FSM *scanFsmPtr = instPtr->scanFSM;
+	L2_FRAME_TYPE frameType = L2_NONE_FRAME;
+	L2_FrameGetChunk(msg, L2_MSG_TYPE, L2_MSG_TYPE_LEN, &frameType);
+	switch (frameType)
+	{
+	case L2_SCAN_FRAME:
+	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");
+			Status = EUNEXP;
+			break;
+		}
+		uint8_t nodeId;
+		L2_FrameGetChunk(msg, L2_MSG_SRC_ID, L2_MSG_SRC_ID_LEN, &nodeId);
+		NODE_ENTRY *node;
+		node = L2_GetNodeById(instPtr->nodeList, nodeId);
+		if (node == NULL)
+		{
+			node = L2_AppendNode(instPtr->nodeList, nodeId, L2_NODE_MEMBER);
+			if (node == NULL)
+			{
+				DBG_ERROR("Failed to append new node [id: %" PRId8 "]", nodeId);
+				Status = ENOMEM;
+				break;
+			}
+		}
+		// Update node info.
+		float nodePos;
+		L2_FrameGetChunk(msg, L2_MSG_ADV_SRC_POSX, L2_MSG_ADV_SRC_POSX_LEN, &nodePos);
+		node->nodeInfo.pos.x = (double)nodePos;
+		L2_FrameGetChunk(msg, L2_MSG_ADV_SRC_POSY, L2_MSG_ADV_SRC_POSY_LEN, &nodePos);
+		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);
+		L2_EVENT netSetupDoneEvent = {
+			.event = L2_EV_NET_ADV_UPDATE,
+			.msg = &netstartTime};
+		AssertL2Event(instPtr, &netSetupDoneEvent);
+
+		// 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;
+		}
+
+		// Time sync.
+		L2_TimeAdjust(instPtr, &(instPtr->log.timeDev));
+
+		// trigger flag
+		AdvRecvStateUpdate(scanFsmPtr, true);
+		Status = SUCCESS;
+		break;
+	}
+	case L2_CFM_FRAME:
+	{
+		uint8_t nodeId;
+		L2_FrameGetChunk(msg, L2_MSG_SRC_ID, L2_MSG_SRC_ID_LEN, &nodeId);
+		NODE_ENTRY *node;
+		node = L2_GetNodeById(instPtr->nodeList, nodeId);
+		if (node == NULL)
+		{
+			node = L2_AppendNode(instPtr->nodeList, nodeId, L2_NODE_MEMBER);
+			if (node == NULL)
+			{
+				DBG_ERROR("Failed to append new node [id: %" PRId8 "]", nodeId);
+				Status = ENOMEM;
+				break;
+			}
+		}
+		// Update node info.
+		float nodePos;
+		L2_FrameGetChunk(msg, L2_MSG_CFM_SRC_POSX, L2_MSG_CFM_SRC_POSX_LEN, &nodePos);
+		node->nodeInfo.pos.x = (double)nodePos;
+		L2_FrameGetChunk(msg, L2_MSG_CFM_SRC_POSY, L2_MSG_CFM_SRC_POSY_LEN, &nodePos);
+		node->nodeInfo.pos.y = (double)nodePos;
+		L2_FrameGetChunk(msg, L2_MSG_CFM_SRC_POSZ, L2_MSG_CFM_SRC_POSZ_LEN, &nodePos);
+		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;
+		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.
+			if (L2_isCxn2Net(instPtr) == false)
+			{
+				// Assert Net-Setup Done.
+				L2_EVENT l2Event;
+				l2Event.event = L2_EV_NET_SETUP_DONE;
+				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);
+				AssertL2Event(instPtr, &rtneUpEvent);
+			}
+			PendCfmAck(instPtr->scanFSM);
+		}
+		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;
+				AssertL2Event(instPtr, &l2Event);
+			}
+			// Time sync.
+			L2_TimeAdjust(instPtr, &(instPtr->log.timeDev));
+		}
+
+		// Get data payload
+		uint32_t dataId;
+		L2_FrameGetChunk(msg, L2_MSG_CFM_PAYLOAD_ID, L2_MSG_CFM_PAYLOAD_ID_LEN, &dataId);
+
+		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);
+		instPtr->log.rxLog.dataId = dataId;
+
+		Status = SUCCESS;
+		break;
+	}
+	default:
+		DBG_ERROR("Unsupported frame type: %" PRId8 ".\n", frameType);
+		Status = EUNEXP;
+		break;
+	}
+	return Status;
+}
+
 /*****************************************************************************/
 /**
  * @brief   Initialize scan FSM.
@@ -500,204 +726,6 @@ void L2_Scan_RefreashScanTable(L2_INST *instPtr)
 	}
 }
 
-/*****************************************************************************/
-/**
- * @brief   Scan net packet handler.
- *
- * @param   instPtr	a pointer to linklayer layer instance
- * @param   msg A pointer to frame data buffer.
- *
- * @return
- *
- ******************************************************************************/
-int32_t L2_Scan_PktHandler(L2_INST *instPtr, uint8_t *msg)
-{
-	ASSERT(instPtr != NULL);
-	ASSERT(msg != NULL);
-	int32_t Status;
-	L2_SCAN_FSM *scanFsmPtr = instPtr->scanFSM;
-	L2_FRAME_TYPE frameType = L2_GetLastOptFrameType(instPtr);
-	switch (frameType)
-	{
-	case L2_SCAN_FRAME:
-		LockStateUpdate(scanFsmPtr, true);
-		StageUpdate(scanFsmPtr, L2_SCAN_ADV_STAGE);
-	case L2_ADV_FRAME:
-	{
-		if (instPtr->config.myType == L2_NODE_HEAD)
-		{
-			DBG_ERROR("Unexpected call from head node, only member Node can handle L2_SCAN_FRAME and L2_ADV_FRAME.\n");
-			Status = EUNEXP;
-			break;
-		}
-		uint8_t nodeId;
-		L2_FrameGetChunk(msg, L2_MSG_SRC_ID, L2_MSG_SRC_ID_LEN, &nodeId);
-		NODE_ENTRY *node;
-		node = L2_GetNodeById(instPtr->nodeList, nodeId);
-		if (node == NULL)
-		{
-			node = L2_AppendNode(instPtr->nodeList, nodeId, L2_NODE_MEMBER);
-			if(node == NULL)
-			{
-				DBG_ERROR("Failed to append new node [id: %" PRId8 "]", nodeId);
-				Status = ENOMEM;
-				break;
-			}
-		}
-		// Update node info.
-		float nodePos;
-		L2_FrameGetChunk(msg, L2_MSG_ADV_SRC_POSX, L2_MSG_ADV_SRC_POSX_LEN, &nodePos);
-		node->nodeInfo.pos.x = (double) nodePos;
-		L2_FrameGetChunk(msg, L2_MSG_ADV_SRC_POSY, L2_MSG_ADV_SRC_POSY_LEN, &nodePos);
-		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);
-		L2_EVENT netSetupDoneEvent = {
-			.event = L2_EV_NET_ADV_UPDATE,
-			.msg = &netstartTime};
-		AssertL2Event(instPtr, &netSetupDoneEvent);
-
-		// 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;
-		}
-
-		// Time sync.
-		L2_TimeAdjust(instPtr, &(instPtr->log.timeDev));
-
-		// trigger flag
-		AdvRecvStateUpdate(scanFsmPtr, true);
-		Status = SUCCESS;
-		break;
-	}
-	case L2_CFM_FRAME:
-	{
-		uint8_t nodeId;
-		L2_FrameGetChunk(msg, L2_MSG_SRC_ID, L2_MSG_SRC_ID_LEN, &nodeId);
-		NODE_ENTRY *node;
-		node = L2_GetNodeById(instPtr->nodeList, nodeId);
-		if (node == NULL)
-		{
-			node = L2_AppendNode(instPtr->nodeList, nodeId, L2_NODE_MEMBER);
-			if(node == NULL)
-			{
-				DBG_ERROR("Failed to append new node [id: %" PRId8 "]", nodeId);
-				Status = ENOMEM;
-				break;
-			}
-		}
-		// Update node info.
-		float nodePos;
-		L2_FrameGetChunk(msg, L2_MSG_CFM_SRC_POSX, L2_MSG_CFM_SRC_POSX_LEN, &nodePos);
-		node->nodeInfo.pos.x = (double) nodePos;
-		L2_FrameGetChunk(msg, L2_MSG_CFM_SRC_POSY, L2_MSG_CFM_SRC_POSY_LEN, &nodePos);
-		node->nodeInfo.pos.y = (double) nodePos;
-		L2_FrameGetChunk(msg, L2_MSG_CFM_SRC_POSZ, L2_MSG_CFM_SRC_POSZ_LEN, &nodePos);
-		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;
-		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.
-			if (L2_isCxn2Net(instPtr) == false)
-			{
-				// Assert Net-Setup Done.
-				L2_EVENT l2Event;
-				l2Event.event = L2_EV_NET_SETUP_DONE;
-				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);
-				AssertL2Event(instPtr, &rtneUpEvent);
-			}
-			PendCfmAck(instPtr->scanFSM);
-		}
-		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;
-				AssertL2Event(instPtr, &l2Event);
-			}
-			// Time sync.
-			L2_TimeAdjust(instPtr, &(instPtr->log.timeDev));
-		}
-
-		// Get data payload
-		uint32_t dataId;
-		L2_FrameGetChunk(msg, L2_MSG_CFM_PAYLOAD_ID, L2_MSG_CFM_PAYLOAD_ID_LEN, &dataId);
-
-		if(dataId != DATA_ID_NONE)
-		{
-			if(L2_GetNodeType(instPtr) == L2_NODE_HEAD)
-			{
-				SysMonitor_UpdateRecvPayload(msg+L2_MSG_CFM_PAYLOAD, PAYLOAD_LEN_FLJ_RX);
-			}
-			else
-			{
-				SysMonitor_UpdateRecvPayload(msg+L2_MSG_CFM_PAYLOAD, PAYLOAD_LEN_LJ_RX);
-			}
-		}
-
-		Status = SUCCESS;
-		break;
-	}
-	default:
-		DBG_ERROR("Unsupported frame type: %" PRId8 ".\n", frameType);
-		Status = EUNEXP;
-		break;
-	}
-	return Status;
-}
-
-
 /*****************************************************************************/
 /**
  * @brief   Execute a member node scan net procedure.
@@ -756,7 +784,8 @@ int32_t L2_Scan_Routine(L2_INST *instPtr, const L2_RTNE_TABLE_ENTRY *rtneEntry)
 	ASSERT(instPtr != NULL);
 	L2_TOR_TYPE torState;
 	int32_t Status;
-	const NODE_ENTRY* commNode;
+	const NODE_ENTRY *commNode;
+	PHY_INST *phyRef = instPtr->config.phyInstPtr;
 	DBG_INFO("-------- Scan Routine --------\n");
 
 	if (rtneEntry->slotSeq != 0)
@@ -782,11 +811,11 @@ int32_t L2_Scan_Routine(L2_INST *instPtr, const L2_RTNE_TABLE_ENTRY *rtneEntry)
 		}
 
 		// Setup antenna beam
-		Phy_SetBeamWidth(instPtr->config.phyInstPtr, PHY_ANT_BEAM_16);
+		Phy_SetBeamWidth(phyRef, PHY_ANT_BEAM_16);
 		instPtr->log.lastBeamWidth = PHY_ANT_BEAM_16;
 		if (commNode != NULL)
 		{
-			Phy_SetBeamNo(instPtr->config.phyInstPtr, commNode->nodeInfo.beamNo, PHY_ANT_BEAM_16);
+			Phy_SetBeamNo(phyRef, commNode->nodeInfo.beamNo, PHY_ANT_BEAM_16);
 		}
 	}
 	else
@@ -804,7 +833,7 @@ int32_t L2_Scan_Routine(L2_INST *instPtr, const L2_RTNE_TABLE_ENTRY *rtneEntry)
 			torState = L2_TOR_SUSPEND;
 		}
 		// Setup antenna beam
-		Phy_SetBeamWidth(instPtr->config.phyInstPtr, PHY_ANT_BEAM_120);
+		Phy_SetBeamWidth(phyRef, PHY_ANT_BEAM_120);
 		instPtr->log.lastBeamWidth = PHY_ANT_BEAM_120;
 	}
 
@@ -870,3 +899,6 @@ int32_t L2_Scan_Routine(L2_INST *instPtr, const L2_RTNE_TABLE_ENTRY *rtneEntry)
 routine_err:
 	return Status;
 }
+
+/** @} LinkLayer_Scan*/
+/** @} LinkLayer*/

df_datalink_sp/src/networking/link_layer/schdevent.c

@@ -1,19 +1,24 @@
 /*****************************************************************************/
 /**
- * Description: Event scheduling implementation
+ * @file schdevent.c
+ * @author FanHao ([email protected])
+ * @brief DF Linklayer Event scheduling implementation file.
+ * @version 0.1
+ * @date 2023-05-06
  *
- * Date: 2023-12-21 13:32
- * LastEditors: Fan Hao
- * LastEditTime: 2023-12-21 13:32
- * Revisions: Rev 0.0
- * History:
- * [2023-12-21]: Initial version.
- *
- * Copyright(c) 2021 Beijing Institute of Technology.
- * Lab of Communication and Networking
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
  *
  ******************************************************************************/
+/**
+ * @addtogroup LinkLayer
+ * @{
+ */
 
+/**
+ * @addtogroup LinkLayer_Scheduler
+ * @{
+ */
 /***************************** Include Files *********************************/
 #include <stdlib.h>
 #include "schdevent.h"
@@ -428,3 +433,6 @@ inline bool L2_isEventScheduled(const L2_SCHD_EVENT *schdEvent)
 	ASSERT(schdEvent != NULL);
 	return schdEvent->isSchd;
 }
+
+/** @} LinkLayer_Scheduler*/
+/** @} LinkLayer*/

df_datalink_sp/src/networking/link_layer/schdevent.h

@@ -1,18 +1,24 @@
 /*****************************************************************************/
 /**
- * Description: Event scheduling implementation
+ * @file schdevent.c
+ * @author FanHao ([email protected])
+ * @brief DF Linklayer Event scheduling header file.
+ * @version 0.1
+ * @date 2023-05-06
  *
- * Date: 2023-12-21 13:32
- * LastEditors: Fan Hao
- * LastEditTime: 2023-12-21 13:32
- * Revisions: Rev 0.0
- * History:
- * [2023-12-21]: Initial version.
- *
- * Copyright(c) 2021 Beijing Institute of Technology.
- * Lab of Communication and Networking
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
  *
  ******************************************************************************/
+/**
+ * @addtogroup LinkLayer
+ * @{
+ */
+
+/**
+ * @addtogroup LinkLayer_Scheduler
+ * @{
+ */
 #ifndef SCHDEVENT_H_
 #define SCHDEVENT_H_
 
@@ -24,8 +30,9 @@
 #include "clist.h"
 /***************** Macros (Inline Functions) Definitions *********************/
 /**************************** Type Definitions *******************************/
-/** @name L2 event
- * A definition of L2 event instance.
+/**
+ * @struct L2_SCHD_EVENT
+ * @brief Linklayer scheduled event descriptor
  */
 typedef struct
 {
@@ -38,8 +45,9 @@ typedef struct
 	uint32_t schdSlot;
 } L2_SCHD_EVENT;
 
-/** @name L2 event
- * A definition of L2 event instance.
+/**
+ * @struct L2_SCHD_POOL
+ * @brief Linklayer schedule event pool instance
  */
 typedef struct
 {
@@ -63,3 +71,6 @@ bool L2_isEventScheduled(const L2_SCHD_EVENT *schdEvent);
 int32_t L2_CancelEvent(L2_SCHD_EVENT *schdEvent);
 
 #endif // SCHDEVENT_H_
+
+/** @} LinkLayer_Scheduler*/
+/** @} LinkLayer*/

df_datalink_sp/src/networking/link_layer/service.c

@@ -1,18 +1,24 @@
 /*****************************************************************************/
 /**
- * Description: Implementations for df datalink service net.
- * Date: 2021-11-16 00:08
- * LastEditTime: 2022-07-16 17:04
- * Revisions: Rev 0.1
- * History:
- * [2022-07-16]: New branch for DiJian.
- * [2021-11-16]: Initial version.
+ * @file service.c
+ * @author FanHao ([email protected])
+ * @brief DF Linklayer service implementation file.
+ * @version 0.0
+ * @date 2023-05-06
  *
- * Copyright(c) 2021 Beijing Institute of Technology.
- * Lab of Communication and Networking
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
  *
  ******************************************************************************/
+/**
+ * @addtogroup LinkLayer
+ * @{
+ */
 
+/**
+ * @addtogroup LinkLayer_Service
+ * @{
+ */
 /***************************** Include Files *********************************/
 #include <string.h>
 #include <stdint.h>
@@ -88,6 +94,7 @@ static int32_t Service_Packing(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t dst
 	uint32_t dataChunk;
 	uint8_t *buff = instPtr->sendPktData;
 
+	// Common section of link layer package
 	dataChunk = L2_GetNextFrameNum(instPtr);
 	L2_FrameInsertChunk(buff, L2_MSG_FRAME_NUM, L2_MSG_FRAME_NUM_LEN, &dataChunk);
 	dataChunk = L2_GetNextSlotNum(instPtr);
@@ -113,7 +120,7 @@ static int32_t Service_Packing(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t dst
 		L2_FrameInsertChunk(buff, L2_MSG_SVC_SRC_SPEEDZ, L2_MSG_SVC_SRC_SPEEDZ_LEN, &(instPtr->sysInfo.vZ));
 
 		uint32_t dataId;
-		if(L2_GetNodeType(instPtr) == L2_NODE_HEAD)
+		if (L2_GetNodeType(instPtr) == L2_NODE_HEAD)
 		{
 			SysMonitor_GetSendPayload(buff + L2_MSG_SVC_PAYLOAD, &dataId, PAYLOAD_LEN_FLJ_TX);
 		}
@@ -128,12 +135,6 @@ static int32_t Service_Packing(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t dst
 			L2_FrameInsertChunk(buff, L2_MSG_SVC_PAYLOAD, L2_MSG_SVC_PAYLOAD_LEN, testData);
 		}
 
-		// // packing payload
-		// uint32_t dataId;
-		// dataId = DATA_ID_TEST;
-		// L2_FrameInsertChunk(buff, L2_MSG_SVC_PAYLOAD_ID, L2_MSG_SVC_PAYLOAD_ID_LEN, &dataId);
-		// L2_FrameInsertChunk(buff, L2_MSG_SVC_PAYLOAD, L2_MSG_SVC_PAYLOAD_LEN, testData);
-
 		Status = L2_CrcAppend(buff, L2_SVC_PACK_LEN - L2_MSG_SVC_CRC_LEN, L2_MSG_SVC_CRC, L2_CRC16_1021);
 		if (Status != SUCCESS)
 		{
@@ -141,8 +142,8 @@ static int32_t Service_Packing(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t dst
 			return Status;
 		}
 
-		memcpy(instPtr->serviceFSM->txLog.data, buff, L2_SVC_PACK_LEN);
-		instPtr->serviceFSM->txLog.dataId = dataId;
+		memcpy(instPtr->log.txLog.data, buff, L2_SVC_PACK_LEN);
+		instPtr->log.txLog.dataId = dataId;
 		break;
 	}
 	default:
@@ -159,62 +160,6 @@ static int32_t Service_Packing(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t dst
 #endif
 }
 
-/*****************************************************************************/
-/**
- * @brief   Initialize service net FSM
- *
- * @param   serviceFSM  A pointer to service FSM instance.
- *
- * @return  SUCCESS Initialize successfully.
- *          Other       Initialize failed.
- *
- ******************************************************************************/
-int32_t L2_Service_Init(L2_SVC_FSM **svcFSMPtr)
-{
-	ASSERT(svcFSMPtr != NULL);
-	*svcFSMPtr = (L2_SVC_FSM *)malloc(sizeof(L2_SVC_FSM));
-	if (*svcFSMPtr == NULL)
-	{
-		return ENOMEM;
-	}
-	L2_Service_Reset(*svcFSMPtr);
-	return SUCCESS;
-}
-
-/*****************************************************************************/
-/**
- * @brief  Reset ServiceNet FSM
- *
- * @param   scanFsmPtr a pointer to service net finite state machine
- *
- * @return  NONE
- *
- ******************************************************************************/
-void L2_Service_Reset(L2_SVC_FSM *svcFSMPtr)
-{
-	ASSERT(svcFSMPtr != NULL);
-	memset((&svcFSMPtr->rxLog), 0x00, sizeof(PAYLOAD));
-	memset((&svcFSMPtr->txLog), 0x00, sizeof(PAYLOAD));
-#ifdef DATALINK_ENABLE_BERTEST
-	svcFSMPtr->bitTotal = 0;
-	svcFSMPtr->bitError = 0;
-#endif
-}
-
-/*****************************************************************************/
-/**
- * @brief  Destroy ServiceNet FSM, free memory
- *
- * @param   scanFsmPtr a pointer to service net finite state machine
- *
- * @return  NONE
- *
- ******************************************************************************/
-void L2_Service_Destroy(L2_SVC_FSM *serviceFSM)
-{
-	free(serviceFSM);
-}
-
 /*****************************************************************************/
 /**
  * @brief   Handle service received packet. Send data up to MPC
@@ -231,7 +176,7 @@ int32_t L2_Service_PktHandler(L2_INST *instPtr, uint8_t *msg)
 	ASSERT(msg != NULL);
 	int32_t Status;
 #ifndef DATALINK_ENABLE_BERTEST
-	uint8_t frameType;
+	L2_FRAME_TYPE frameType = L2_NONE_FRAME;
 	L2_FrameGetChunk(msg, L2_MSG_TYPE, L2_MSG_TYPE_LEN, &frameType);
 	switch (frameType)
 	{
@@ -244,7 +189,7 @@ int32_t L2_Service_PktHandler(L2_INST *instPtr, uint8_t *msg)
 		if (node == NULL)
 		{
 			node = L2_AppendNode(instPtr->nodeList, nodeId, L2_NODE_MEMBER);
-			if(node == NULL)
+			if (node == NULL)
 			{
 				DBG_ERROR("Failed to append new node [id: %" PRIu8 "]", nodeId);
 				Status = ENOMEM;
@@ -255,18 +200,18 @@ int32_t L2_Service_PktHandler(L2_INST *instPtr, uint8_t *msg)
 		// Update node info.
 		float nodePos;
 		L2_FrameGetChunk(msg, L2_MSG_SVC_SRC_POSX, L2_MSG_SVC_SRC_POSX_LEN, &nodePos);
-		node->nodeInfo.pos.x = (double) nodePos;
+		node->nodeInfo.pos.x = (double)nodePos;
 		L2_FrameGetChunk(msg, L2_MSG_SVC_SRC_POSY, L2_MSG_SVC_SRC_POSY_LEN, &nodePos);
-		node->nodeInfo.pos.y = (double) nodePos;
+		node->nodeInfo.pos.y = (double)nodePos;
 		L2_FrameGetChunk(msg, L2_MSG_SVC_SRC_POSZ, L2_MSG_SVC_SRC_POSZ_LEN, &nodePos);
-		node->nodeInfo.pos.z = (double) nodePos;
+		node->nodeInfo.pos.z = (double)nodePos;
 		float nodeSpeed;
 		L2_FrameGetChunk(msg, L2_MSG_SVC_SRC_SPEEDX, L2_MSG_SVC_SRC_SPEEDX_LEN, &nodeSpeed);
-		node->nodeInfo.speed.x = (double) nodePos;
+		node->nodeInfo.speed.x = (double)nodePos;
 		L2_FrameGetChunk(msg, L2_MSG_SVC_SRC_SPEEDY, L2_MSG_SVC_SRC_SPEEDY_LEN, &nodeSpeed);
-		node->nodeInfo.speed.y = (double) nodePos;
+		node->nodeInfo.speed.y = (double)nodePos;
 		L2_FrameGetChunk(msg, L2_MSG_SVC_SRC_SPEEDZ, L2_MSG_SVC_SRC_SPEEDZ_LEN, &nodeSpeed);
-		node->nodeInfo.speed.z = (double) nodePos;
+		node->nodeInfo.speed.z = (double)nodePos;
 
 		// Reset node ttl
 		node->ttlCnt = 0;
@@ -285,21 +230,19 @@ int32_t L2_Service_PktHandler(L2_INST *instPtr, uint8_t *msg)
 		uint32_t dataId;
 		L2_FrameGetChunk(msg, L2_MSG_SVC_PAYLOAD_ID, L2_MSG_SVC_PAYLOAD_ID_LEN, &dataId);
 
-		if(dataId != DATA_ID_NONE)
+		if (L2_GetNodeType(instPtr) == L2_NODE_HEAD)
 		{
-			if(L2_GetNodeType(instPtr) == L2_NODE_HEAD)
-			{
-				SysMonitor_UpdateRecvPayload(msg+L2_MSG_SVC_PAYLOAD, PAYLOAD_LEN_FLJ_RX);
+			SysMonitor_UpdateRecvPayload(msg + L2_MSG_SVC_PAYLOAD, dataId, PAYLOAD_LEN_FLJ_RX);
 		}
 		else
 		{
-				SysMonitor_UpdateRecvPayload(msg+L2_MSG_SVC_PAYLOAD, PAYLOAD_LEN_LJ_RX);
-			}
+			SysMonitor_UpdateRecvPayload(msg + L2_MSG_SVC_PAYLOAD, dataId, PAYLOAD_LEN_LJ_RX);
 		}
 
 		// Logging
-		memcpy(instPtr->serviceFSM->rxLog.data, msg, L2_SVC_PACK_LEN);
-		instPtr->serviceFSM->rxLog.dataId = dataId;
+		memcpy(instPtr->log.rxLog.data, msg, L2_SVC_PACK_LEN);
+		instPtr->log.rxLog.dataId = dataId;
+		instPtr->serviceFSM->rxdCnt++;
 
 #ifdef DATALINK_ENABLE_AUTOTIMESYNC
 		// Implement a auto time sync.
@@ -346,6 +289,65 @@ int32_t L2_Service_PktHandler(L2_INST *instPtr, uint8_t *msg)
 #endif
 }
 
+/*****************************************************************************/
+/**
+ * @brief   Initialize service net FSM
+ *
+ * @param   serviceFSM  A pointer to service FSM instance.
+ *
+ * @return  SUCCESS Initialize successfully.
+ *          Other       Initialize failed.
+ *
+ ******************************************************************************/
+int32_t L2_Service_Init(L2_SVC_FSM **svcFSMPtr)
+{
+	ASSERT(svcFSMPtr != NULL);
+	*svcFSMPtr = (L2_SVC_FSM *)malloc(sizeof(L2_SVC_FSM));
+	if (*svcFSMPtr == NULL)
+	{
+		return ENOMEM;
+	}
+	L2_Service_Reset(*svcFSMPtr);
+	return SUCCESS;
+}
+
+/*****************************************************************************/
+/**
+ * @brief  Reset ServiceNet FSM
+ *
+ * @param   scanFsmPtr a pointer to service net finite state machine
+ *
+ * @return  NONE
+ *
+ ******************************************************************************/
+void L2_Service_Reset(L2_SVC_FSM *svcFSMPtr)
+{
+	ASSERT(svcFSMPtr != NULL);
+	svcFSMPtr->txCnt = 0;
+	svcFSMPtr->rxCnt = 0;
+	svcFSMPtr->rxdCnt = 0;
+#ifdef DATALINK_ENABLE_BERTEST
+	svcFSMPtr->bitTotal = 0;
+	svcFSMPtr->bitError = 0;
+	svcFSMPtr->lossRate = 0;
+	svcFSMPtr->errorRate = 0;
+#endif
+}
+
+/*****************************************************************************/
+/**
+ * @brief  Destroy ServiceNet FSM, free memory
+ *
+ * @param   scanFsmPtr a pointer to service net finite state machine
+ *
+ * @return  NONE
+ *
+ ******************************************************************************/
+void L2_Service_Destroy(L2_SVC_FSM *serviceFSM)
+{
+	free(serviceFSM);
+}
+
 /*****************************************************************************/
 /**
  * @brief   Service FSM Routine.
@@ -366,9 +368,10 @@ int32_t L2_Service_Routine(L2_INST *instPtr, const L2_RTNE_TABLE_ENTRY *rtneEntr
 		return SUCCESS; // skip
 	}
 
-	PHY_INST* phyRef = instPtr->config.phyInstPtr;
+	PHY_INST *phyRef = instPtr->config.phyInstPtr;
+	L2_SVC_FSM *svcFSMPtr = instPtr->serviceFSM;
 	L2_TOR_TYPE torState;
-	const NODE_ENTRY* commNode;
+	const NODE_ENTRY *commNode;
 	if (rtneEntry->src == L2_GetNodeId(instPtr))
 	{
 		torState = L2_TOR_TX;
@@ -402,6 +405,7 @@ int32_t L2_Service_Routine(L2_INST *instPtr, const L2_RTNE_TABLE_ENTRY *rtneEntr
 	case L2_SLOT_SERVICE:
 		if (torState == L2_TOR_TX)
 		{
+			svcFSMPtr->txCnt++;
 #ifndef DATALINK_ENABLE_BERTEST
 			// Packing service data
 			Service_Packing(instPtr, L2_SVC_FRAME, rtneEntry->dst);
@@ -409,6 +413,10 @@ int32_t L2_Service_Routine(L2_INST *instPtr, const L2_RTNE_TABLE_ENTRY *rtneEntr
 			memcpy(instPtr->sendPktData, testData, L2_SVC_PACK_LEN);
 #endif
 		}
+		else
+		{
+			svcFSMPtr->rxCnt++;
+		}
 		L2_SetupNextSlot(instPtr, torState, L2_SVC_FRAME);
 		break;
 	default:
@@ -417,11 +425,14 @@ int32_t L2_Service_Routine(L2_INST *instPtr, const L2_RTNE_TABLE_ENTRY *rtneEntr
 	}
 #ifdef DATALINK_ENABLE_BERTEST
 	uint32_t pktLoss;
-	pktLoss = instPtr->log.svcRecvCnt - instPtr->log.svcCorrectCnt;
-	instPtr->serviceFSM->lossRate = (instPtr->log.svcRecvCnt == 0) ? 0 : (double)pktLoss / (double)instPtr->serviceFSM->pktRecv;
-	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("Bit Error Rate -- Total:%lu, Error:%lu.\n", instPtr->serviceFSM->bitTotal, instPtr->serviceFSM->bitError);
+	pktLoss = svcFSMPtr->rxCnt - svcFSMPtr->rxdCnt;
+	svcFSMPtr->lossRate = (svcFSMPtr->rxCnt == 0) ? 0 : (double)pktLoss / (double)svcFSMPtr->rxCnt;
+	svcFSMPtr->errorRate = (svcFSMPtr->bitTotal == 0) ? 0 : (double)svcFSMPtr->bitError / (double)svcFSMPtr->bitTotal;
+	DBG_PRINT("Packet Loss Rate -- Total: %lu, Loss: %lu.\n", instPtr->log.svcRxCnt, pktLoss);
+	DBG_PRINT("Bit Error Rate -- Total:%lu, Error:%lu.\n", svcFSMPtr->bitTotal, svcFSMPtr->bitError);
 #endif
 	return SUCCESS;
 }
+
+/** @} LinkLayer_Service*/
+/** @} LinkLayer*/

df_datalink_sp/src/networking/link_layer/time_sync.c

@@ -1,21 +1,24 @@
 /*****************************************************************************/
 /**
- * Description: Time sync implementation file.
+ * @file time_sync.c
+ * @author FanHao ([email protected])
+ * @brief DF Linklayer time sync implementation file.
+ * @version 0.0
+ * @date 2023-05-06
  *
- * Author: Author's name
- * Date: 2021-12-04 16:32
- * LastEditors: FanHao
- * LastEditTime: 2022-07-10 20:43
- * Revisions: Rev 0.0
- * History:
- * [2022-07-10]: New branch for Dijian.
- * [2021-12-04]: Initial version.
- *
- * Copyright(c) 2021 Beijing Institute of Technology.
- * Lab of Communication and Networking
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
  *
  ******************************************************************************/
+/**
+ * @addtogroup LinkLayer
+ * @{
+ */
 
+/**
+ * @addtogroup LinkLayer_TimeSync
+ * @{
+ */
 /***************************** Include Files *********************************/
 #include <string.h>
 #include <stdlib.h>
@@ -49,7 +52,8 @@ int32_t L2_GetTimeDeviation(L2_INST *instPtr, uint32_t frameNum, uint32_t slotNu
 	ASSERT(instPtr != NULL);
 	ASSERT(timeDev != NULL);
 	L1_FRAME_TYPE lastRecvdFrame;
-	lastRecvdFrame = Phy_GetLastRecvFrameType(instPtr->config.phyInstPtr);
+	PHY_INST *phyRef = instPtr->config.phyInstPtr;
+	lastRecvdFrame = Phy_GetLastRecvFrameType(phyRef);
 	if (lastRecvdFrame == L1_NONE_FRAME)
 	{
 		DBG_ERROR("Invalid TimeAlign operation, no frame was received.");
@@ -68,7 +72,7 @@ int32_t L2_GetTimeDeviation(L2_INST *instPtr, uint32_t frameNum, uint32_t slotNu
 		expectTime += (uint64_t)instPtr->netStartTime * L2_SLOTS_PER_FRAME * TIME_FRAC_MAX;
 	}
 
-	Phy_GetLastReceivedFrameSyncTimeStamp(instPtr->config.phyInstPtr, &timeStamp);
+	Phy_GetLastReceivedFrameSyncTimeStamp(phyRef, &timeStamp);
 	currTime = (uint64_t)timeStamp.frac_part;
 	currTime += ((uint64_t)timeStamp.int_part) * TIME_FRAC_MAX;
 
@@ -76,7 +80,6 @@ int32_t L2_GetTimeDeviation(L2_INST *instPtr, uint32_t frameNum, uint32_t slotNu
 	return SUCCESS;
 }
 
-
 /*****************************************************************************/
 /**
  * @brief    Implement time adjustment by applying time deviation.
@@ -96,3 +99,7 @@ void L2_TimeAdjust(L2_INST *instPtr, const int64_t *timeDev)
 	slotTimerAdjmet.frac_part = (uint32_t)(*timeDev % TIME_FRAC_MAX);
 	TimeCtrl_TimeAdjust(instPtr->config.tmcInstPtr, &slotTimerAdjmet, TM_ADJ_ADD);
 }
+
+/** @} LinkLayer_TimeSync*/
+
+/** @} LinkLayer*/

df_datalink_sp/src/networking/phy_layer/phy_antenna.c

@@ -15,12 +15,26 @@
  * Lab of Communication and Networking
  *
  ******************************************************************************/
+/**
+ * @addtogroup PhysicalLayer
+ * @{
+ */
+
+/**
+ * @addtogroup PhysicalLayer_AntennaControl
+ * @{
+ */
 #include <string.h>
 #include <stdint.h>
 #include <math.h>
 #include "error.h"
 #include "phy_layer.h"
 
+/**
+ * @name PhysicalLayer_AntennaConfig_Constants
+ * @{
+ */
+
 #define ANT_PI 3.14159265358979323846
 
 #define ANT_COINFO_HEAD 0xAA
@@ -57,17 +71,12 @@
 
 // Pair by regex
 // Regex: (([0-9]+, ){8})
-uint16_t hopPattern_Config[L1_FRAME_MAX_HOPS] =
-{
-	0
-};
-
-uint16_t hopPattern_2KBPS_20MS[L1_FRAME_2KBPS_20MS_HOPS] =
+const uint16_t hopPattern_2KBPS_20MS[L1_FRAME_2KBPS_20MS_HOPS] =
 {
 	1500
 };
 
-uint16_t hopPattern_2KBPS_100MS[L1_FRAME_2KBPS_100MS_HOPS] =
+const uint16_t hopPattern_2KBPS_100MS[L1_FRAME_2KBPS_100MS_HOPS] =
 {
 	0, 44, 88, 131, 175, 219, 263, 306,
 	350, 394, 438, 481, 525, 569, 613, 656,
@@ -82,57 +91,46 @@ uint16_t hopPattern_2KBPS_100MS[L1_FRAME_2KBPS_100MS_HOPS] =
 	3500
 };
 
-uint16_t hopPattern_10KBPS_10MS[L1_FRAME_10KBPS_10MS_HOPS] =
+const uint16_t hopPattern_10KBPS_10MS[L1_FRAME_10KBPS_10MS_HOPS] =
 {
 	1500
 };
 
-//uint16_t hopPattern_10KBPS_20MS[L1_FRAME_10KBPS_20MS_HOPS] =
-//{
-//	1500, 1600, 1700, 1800, 1900, 1400, 1300, 1200,
-//	1100, 1000,  900
-//};
-
-uint16_t hopPattern_10KBPS_20MS[L1_FRAME_10KBPS_20MS_HOPS] =
+const uint16_t hopPattern_10KBPS_20MS[L1_FRAME_10KBPS_20MS_HOPS] =
 {
 	1500, 1500, 1500, 1500, 1500, 1500, 1500, 1500,
 	1500, 1500, 1500
 };
 
-uint16_t hopPattern_40KBPS_10MS[L1_FRAME_40KBPS_10MS_HOPS] =
+const uint16_t hopPattern_40KBPS_10MS[L1_FRAME_40KBPS_10MS_HOPS] =
 {
 	1600, 1650, 1700, 1750, 1800, 1850, 1900, 1550,
 	1500
 };
 
-//uint16_t hopPattern_40KBPS_20MS[L1_FRAME_40KBPS_20MS_HOPS] =
-//{
-//	1600, 1650, 1700, 1750, 1800, 1850, 1900, 1550,
-//	1500, 1450, 1400, 1350, 1300, 1250, 1200, 1150,
-//	1100, 1050, 1000
-//};
-
-uint16_t hopPattern_40KBPS_20MS[L1_FRAME_40KBPS_20MS_HOPS] =
+const uint16_t hopPattern_40KBPS_20MS[L1_FRAME_40KBPS_20MS_HOPS] =
 {
 	1700, 1800, 1900, 2000, 1700, 1700, 1700, 1700,
 	1700, 1700, 1700, 1700, 1700, 1700, 1700, 1700,
 	1700, 1700, 1700
 };
 
-uint16_t hopPattern_200KBPS_5MS[L1_FRAME_200KBPS_5MS_HOPS] =
+const uint16_t hopPattern_200KBPS_5MS[L1_FRAME_200KBPS_5MS_HOPS] =
 {
 	500, 1600, 1700, 1800, 1900, 2000, 1500, 1600,
 	1700, 1800, 1900, 2000, 1500, 1600, 1700, 1800,
 	1900, 2000, 1500, 1500
 };
 
-uint16_t hopPattern_1M2BPS_5MS[L1_FRAME_1M2BPS_5MS_HOPS] =
+const uint16_t hopPattern_1M2BPS_5MS[L1_FRAME_1M2BPS_5MS_HOPS] =
 {
 	500, 600, 700, 800, 900, 1000, 500, 600,
 	700, 800, 900, 1000, 500, 600, 700, 800,
 	900, 1000, 500, 500
 };
 
+/** @} PhysicalLayer_AntennaConfig_Constants*/
+
 /*****************************************************************************/
 /**
  * @brief	Initialize antenna configurations (load preset values)
@@ -224,6 +222,8 @@ void Phy_AntConfigMode(PHY_INST *instPtr, PHY_ANT_MODE mode)
 	}
 	instPtr->phyLog.antMode = mode;
 	instPtr->antConfig.antMode = config;
+	// Sync logs to system monitor
+	SysMonitor_UpdatePhysicalLayerLog(&(instPtr->phyLog));
 }
 
 /*****************************************************************************/
@@ -243,10 +243,10 @@ void Phy_SetBeamTable(PHY_INST *instPtr, PHY_ANT_ANGLE *table, uint32_t offset)
 	ASSERT(table != NULL);
 	for (int i = 0; i < L1_NUM_ANT_NRRW_PATTERN; i++)
 	{
-		instPtr->antNrrwPattern[i] = table[(i+offset) % L1_NUM_ANT_NRRW_PATTERN];
+		instPtr->antNrrwPattern[i] = table[(i + offset) % L1_NUM_ANT_NRRW_PATTERN];
 	}
-	memcpy((uint32_t*)instPtr->antInfoAddr, instPtr->antNrrwPattern,
-				L1_NUM_ANT_NRRW_PATTERN*sizeof(PHY_ANT_ANGLE));
+	memcpy((uint32_t *)instPtr->antInfoAddr, instPtr->antNrrwPattern,
+		   L1_NUM_ANT_NRRW_PATTERN * sizeof(PHY_ANT_ANGLE));
 }
 
 /*****************************************************************************/
@@ -365,3 +365,7 @@ int32_t Phy_SetBeamAngle(PHY_INST *instPtr, double offAx, double rndAx)
 	instPtr->antConfig.raxis[1] = (uint8_t)rndAxDeg;
 	return SUCCESS;
 }
+
+/** @} PhysicalLayer_AntennaControl*/
+
+/** @} PhysicalLayer*/

df_datalink_sp/src/networking/phy_layer/phy_layer.h

@@ -1,26 +1,21 @@
 /*****************************************************************************/
 /**
- * Description: Physical layer control definitions and function prototypes.
+ * @file phy_layer.c
+ * @author FanHao ([email protected])
+ * @brief Physical layer control header file.
+ * @version 0.0
+ * @date 2023-04-24
  *
- * Date: 2021-12-04 16:32
- * LastEditTime: 2024-01-20 17:41
- * Revisions: Rev 0.1
- * History:
- * [2021-12-08]: Initial version.
- * [2022-06-18]: New branch for glink control purpose:
- * 				 -Add poll mode, physical layer will start Tx/Rx procedure
- * 				  at specific time stamp.
- * 				 -Add 61/37 beam switch
- * 				 -Code simplification.
- * [2023-04-24]: Feature add:
- * 				- Read frame type from PL status register.
- * [2024-01-20]: New branch for DUIFEI.
- *
- * Copyright(c) 2021 Beijing Institute of Technology.
- * Lab of Communication and Networking
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
  *
  ******************************************************************************/
 
+/**
+ * @defgroup PhysicalLayer
+ * @{
+ */
+
 #ifndef PHY_CTRL_H_
 #define PHY_CTRL_H_
 
@@ -35,6 +30,10 @@
 #include "../../system_monitor.h"
 #include "../../time_ctrl/time_ctrl.h"
 /************************** Constant Definitions *****************************/
+/**
+ * @name PhysicalLayer_Common_Constant
+ * @{
+ */
 #define L1_NUM_ANT_NRRW_PATTERN 37
 #define L1_INIT_BEAM_NO 0
 #define L1_INIT_ANT_WD PHY_ANT_BEAM_120
@@ -52,11 +51,13 @@
 #define L1_FRAME_40KBPS_10MS_HOPS 9
 #define L1_FRAME_200KBPS_5MS_HOPS 20
 #define L1_FRAME_1M2BPS_5MS_HOPS 20
-
-#define PHY_TIME_WORD_H_MAX UINT32_MAX
-#define PHY_TIME_WORD_L_MAX 0x0007A120 // 5ms/10ns
+#define PHY_LOG_EXPIRE 40 // 50*5ms
+/** @} */
 /***************** Macros (Inline Functions) Definitions *********************/
 /**************************** Type Definitions *******************************/
+/**
+ * @enum L1_FRAME_TYPE
+ */
 typedef enum
 {
 	L1_NONE_FRAME = 0,
@@ -70,71 +71,63 @@ typedef enum
 	L1_1M2BPS_5MS_FRAME = 8
 } L1_FRAME_TYPE;
 
+/**
+ * @struct PHY_ANT_CONFIG
+ * @brief PhysicalLayer antenna config
+ */
 typedef struct
 {
 	/*** Ant Control ***/
-	/* Antenna control frame head 0xAA */
-	/* default 0, reserved for further use */
-	uint8_t ctrlWord;
-	/* high 4 bits specified beam mode.
-	 * low 4 bits specified power control */
-	uint8_t antMode;
-	/* off-axis angle range is 0~60,
-	 * 0.1 degree each LSB */
-	uint8_t oaxis[2];
-	/* round-axis angle range is 0~360,
-	 * 0.1 degree each LSB */
-	uint8_t raxis[2];
-	/* 0~3500Mhz, step 1MHz */
-	uint8_t antFreq[2];
-	/* in single tr mode, 0~63 specified tr channel
-	 * in single subarray mode, 0~3 specified the subarray
-	 * Only in debug mode*/
-	uint8_t trSlect;
-	/* Antenna attenuation 0~31, 0.5dB each LSB, Only in debug mode */
-	uint8_t antAtt;
-	/* 0~63, 5.625 degree each LSB, Only in debug mode*/
-	uint8_t phase;
-	/* Only for debug */
-	/* default 0x00 */
-	uint8_t rxtxMode;
-	/* 0x00 Normal, 0x01 single tr calibration */
-	uint8_t calibrMode;
-	/* reserved for further use */
-	uint8_t antReserved;
+	uint8_t ctrlWord;	 ///< Antenna control frame head 0xAA\n
+						 /// default 0, reserved for further use
+	uint8_t antMode;	 ///< high 4 bits specified beam mode.\n
+						 /// low 4 bits specified power control
+	uint8_t oaxis[2];	 ///< off-axis angle range is 0~60 \n
+						 /// 0.1 degree each LSB
+	uint8_t raxis[2];	 ///< round-axis angle range is 0~360, \n
+						 /// 0.1 degree each LSB
+	uint8_t antFreq[2];	 ///< 0~3500Mhz, step 1MHz
+	uint8_t trSlect;	 ///< in single tr mode, 0~63 specified tr channel \n
+						 /// in single subarray mode, 0~3 specified the subarray
+						 /// ! Only in debug mode!
+	uint8_t antAtt;		 ///< Antenna attenuation 0~31, 0.5dB each LSB, Only in debug mode
+	uint8_t phase;		 ///< 0~63, 5.625 degree each LSB, Only in debug mode
+	uint8_t rxtxMode;	 ///< Only for debug \n
+						 /// default 0x00
+	uint8_t calibrMode;	 ///< 0x00 Normal, 0x01 single tr calibration
+	uint8_t antReserved; ///< reserved for further use
 
 	/*** RF Control ***/
-	/* [7:4]RF enable: 0-On, 1-Off(Default); [3:0]Work mode: 0(default) */
-	uint8_t rfCtrl;
-	/* 0~3500Mhz, step 1MHz */
-	uint8_t rfFreq[2];
-	/* RF MGC control: 0~31, 1dB each LSB*/
-	uint8_t rfTxMgc;
-	/* RF channel 1&2 calibration mgc: [7:4] Channle1 - max 15db, 1dB each LSB
-	 * 								   [3:0] Channle2 - max 15db, 1dB each LSB*/
-	uint8_t rf12CalMgc;
-	/* RF channel 3&4 calibration mgc: [7:4] Channle3 - max 15db, 1dB each LSB
-	 * 								   [3:0] Channle4 - max 15db, 1dB each LSB*/
-	uint8_t rf34CalMgc;
-	/* Receive channel 1-4 MGC: 0~31, 1dB each LSB */
-	uint8_t rcvMgc;
-	/* Receive monitor, 0-normal, 1-switch to monitor port */
-	uint8_t rfMonitor;
-	/* reserved for further use */
-	uint8_t rfReserved0;
-	uint8_t rfReserved1;
+	uint8_t rfCtrl;		 ///< [7:4]RF enable: 0-On, 1-Off(Default); [3:0]Work mode: 0(default)
+	uint8_t rfFreq[2];	 ///< 0~3500Mhz, step 1MHz
+	uint8_t rfTxMgc;	 ///< RF MGC control: 0~31, 1dB each LSB
+	uint8_t rf12CalMgc;	 ///< RF channel 1&2 calibration mgc\n
+						 /// [7:4] Channle1 - max 15db, 1dB each LSB \n
+						 /// [3:0] Channle2 - max 15db, 1dB each LSB
+	uint8_t rf34CalMgc;	 ///< RF channel 3&4 calibration mgc\n
+						 /// [7:4] Channle3 - max 15db, 1dB each LSB
+						 /// [3:0] Channle4 - max 15db, 1dB each LSB
+	uint8_t rcvMgc;		 ///< Receive channel 1-4 MGC: 0~31, 1dB each LSB
+	uint8_t rfMonitor;	 ///< Receive monitor, 0-normal, 1-switch to monitor port
+	uint8_t rfReserved0; ///< reserved for further use
+	uint8_t rfReserved1; ///< reserved for further use
 } PHY_ANT_CONFIG;
 
+/**
+ * @struct PHY_ANT_ANGLE
+ * @brief Describe the PhysicalLayer antenna angle
+ */
 typedef struct
 {
-	/* off-axis angle range is 0~60,
-	 * 0.1 degree each LSB */
-	uint16_t oaxis;
-	/* round-axis angle range is 0~360,
-	 * 0.1 degree each LSB */
-	uint16_t raxis;
+	uint16_t oaxis; ///< off-axis angle range is 0~60
+					/// 0.1 degree each LSB
+	uint16_t raxis; ///< round-axis angle range is 0~360
+					/// 0.1 degree each LSB
 } PHY_ANT_ANGLE;
 
+/**
+ * @enum PHY_TIME_WORD_TYPE
+ */
 typedef enum
 {
 	PHY_TIME_WORD_NONE = 0,
@@ -142,6 +135,9 @@ typedef enum
 	PHY_TIME_WORD_LISTEN_TIMEOUT = 2
 } PHY_TIME_WORD_TYPE;
 
+/**
+ * @enum PHY_ANT_BEAM_WIDTH
+ */
 typedef enum
 {
 	PHY_ANT_BEAM_NONE = 0,
@@ -151,6 +147,9 @@ typedef enum
 	PHY_ANT_BEAM_16 = 4
 } PHY_ANT_BEAM_WIDTH;
 
+/**
+ * @enum PHY_TOR_TYPE
+ */
 typedef enum
 {
 	PHY_TOR_SUSPEND = 0,
@@ -158,6 +157,9 @@ typedef enum
 	PHY_TOR_RX = 2
 } PHY_TOR_TYPE;
 
+/**
+ * @enum PHY_MODE
+ */
 typedef enum
 {
 	PHY_MODE_NONE = 0,
@@ -166,6 +168,9 @@ typedef enum
 	PHY_MODE_PULL = 3
 } PHY_MODE;
 
+/**
+ * @enum PHY_ANT_MODE
+ */
 typedef enum
 {
 	PHY_ANT_MODE_NONE = 0,
@@ -174,23 +179,10 @@ typedef enum
 	PHY_ANT_MODE_POWER_FULL = 3,
 } PHY_ANT_MODE;
 
-typedef struct
-{
-	uint32_t devId;
-	uint32_t txBramId;
-	uint32_t rxBramId;
-	uint32_t antBramId;
-	uint32_t antInfoBramId;
-	uint32_t hwXadcId;
-	uintptr_t baseAddr;
-#ifndef EMULATION
-	uint8_t (*get_clk_state)(void);
-	uint8_t (*get_ad_lock_state)(void);
-	int8_t (*get_ad0_temp)(void);
-	int8_t (*get_ad1_temp)(void);
-#endif
-} PHY_CONFIG;
-
+/**
+ * @struct PHY_RCD
+ * @brief Physical Layer recode buffer
+ */
 typedef struct
 {
 	int32_t last;
@@ -198,84 +190,101 @@ typedef struct
 	int32_t next;
 } PHY_RCD;
 
+/**
+ * @struct PHY_CONFIG
+ * @brief struct holds all physical layer initialization parameters
+ */
 typedef struct
 {
-	PHY_CONFIG phyCofig; // Device address configs
-	uintptr_t recvDataAddr;
-	uintptr_t sendDataAddr;
-	uintptr_t antConfigAddr;
-	uintptr_t antInfoAddr;
-	bool isPhyEn;			  // if physical layer running
-	bool isAcq;				  // if last reception acquisition success
-	bool isFrameSync;		  // if last reception frame sync success
-	bool isDecode;			  // if last reception decode success
-	bool isValid;			  // if last reception frame data valid (crc check pass)
-	bool isPresetHop;		  // if using preset frequency hop
-	TIME_WORD recvSlotTime;	  // last slot start time stamp
-	TIME_WORD recvFsTime;	  // last frame sync time stamp
-	PHY_RCD antNo;			  // antenna number record
-	PHY_RCD beamNo;			  // beam number record
-	PHY_RCD beamWd;			  // beam width 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)
-	uint32_t antConfigOffset; // antenna configuration bram offset (to implement ping-pong data flow)
-	PHY_ANT_CONFIG antConfig; // antenna configuration pointer
+	uint32_t devId;			///< device ID
+	uint32_t txBramId;		///< tx bram ID
+	uint32_t rxBramId;		///< rx bram ID
+	uint32_t antBramId;		///< antenna config bram ID
+	uint32_t antInfoBramId; ///< antenna beam info bram ID
+	uint32_t hwXadcId;		///< hardware xadc device ID
+	uintptr_t baseAddr;		///< Physical layer controller base address
 #ifndef EMULATION
-	XAdcPs hwXadc;
+	uint8_t (*get_clk_state)(void);		///< function handle returns hardware clock state
+	uint8_t (*get_ad_lock_state)(void); ///< function handle returns adc lock state
+	int8_t (*get_ad0_temp)(void);		///< function handle returns adc0 temperature state
+	int8_t (*get_ad1_temp)(void);		///< function handle returns adc1 temperature state
 #endif
-	PHY_ANT_ANGLE antNrrwPattern[L1_NUM_ANT_NRRW_PATTERN];
-	HWSTATE hwSate;
-	PHYLOG phyLog;
+} PHY_CONFIG;
+
+/**
+ * @struct PHY_INST
+ * @brief Physical Layer operating instance
+ */
+typedef struct
+{
+	PHY_CONFIG phyCofig;	  ///< physical layer configuration parameters
+	uintptr_t recvDataAddr;	  ///< receive data bram address
+	uintptr_t sendDataAddr;	  ///< send data bram address
+	uintptr_t antConfigAddr;  ///< antenna config data bram address
+	uintptr_t antInfoAddr;	  ///< antenna beam info data bram address
+	bool isPhyEn;			  ///< indicates if physical layer running
+	bool isAcq;				  ///< indicates if last reception acquisition success
+	bool isFrameSync;		  ///< indicates if last reception frame sync success
+	bool isDecode;			  ///< indicates if last reception decode success
+	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 antNo;			  ///< antenna number record
+	PHY_RCD beamNo;			  ///< beam number record
+	PHY_RCD beamWd;			  ///< beam width 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)
+	uint32_t antConfigOffset; ///< antenna configuration bram offset (to implement ping-pong data flow)
+	PHY_ANT_CONFIG antConfig; ///< antenna configuration pointer
+#ifndef EMULATION
+	XAdcPs hwXadc; ///< hardware Xadc instance
+#endif
+	PHY_ANT_ANGLE antNrrwPattern[L1_NUM_ANT_NRRW_PATTERN]; ///< antenna beam scan pattern
+	HWSTATE hwSate;										   ///< hardware state log
+	PHYLOG phyLog;										   ///< physical state log
+	uint32_t lastLogTime;								   /// physical state log time stamp
 } PHY_INST;
 
-/************************** Variable Definitions *****************************/
-extern uint16_t hopPattern_Config[L1_FRAME_MAX_HOPS];
-extern uint16_t hopPattern_2KBPS_20MS[L1_FRAME_2KBPS_20MS_HOPS];
-extern uint16_t hopPattern_2KBPS_100MS[L1_FRAME_2KBPS_100MS_HOPS];
-extern uint16_t hopPattern_10KBPS_10MS[L1_FRAME_10KBPS_10MS_HOPS];
-extern uint16_t hopPattern_10KBPS_20MS[L1_FRAME_10KBPS_20MS_HOPS];
-extern uint16_t hopPattern_40KBPS_10MS[L1_FRAME_40KBPS_10MS_HOPS];
-extern uint16_t hopPattern_40KBPS_20MS[L1_FRAME_40KBPS_20MS_HOPS];
-
-extern uint16_t hopPattern_200KBPS_5MS[L1_FRAME_200KBPS_5MS_HOPS];
-extern uint16_t hopPattern_1M2BPS_5MS[L1_FRAME_1M2BPS_5MS_HOPS];
-
 /************************** Function Prototypes ******************************/
-int32_t Phy_InstInit(PHY_INST **instPtr, PHY_CONFIG *phyConfig);
+
+/**
+ * @defgroup PhysicalLayer_Main
+ * @{
+ */
+int32_t Phy_Init(PHY_INST **instPtr, PHY_CONFIG *phyConfig);
 void Phy_Destroy(PHY_INST *instPtr);
-
-void Phy_UpdateState(PHY_INST *instPtr);
-void Phy_RefreshHwSate(PHY_INST *instPtr);
-
 void Phy_Start(PHY_INST *instPtr);
 void Phy_Halt(PHY_INST *instPtr);
-int32_t Phy_SetMode(PHY_INST *instPtr, PHY_MODE modeCod);
 
+int32_t Phy_SetMode(PHY_INST *instPtr, PHY_MODE modeCod);
+int32_t Phy_SetTimeWord(PHY_INST *instPtr, const TIME_WORD *tmWord, PHY_TIME_WORD_TYPE tmType);
 int32_t Phy_SetupNextSlot(PHY_INST *instPtr, PHY_TOR_TYPE txrxMode, L1_FRAME_TYPE frameType, uint8_t *dataBuff);
+void Phy_UpdateState(PHY_INST *instPtr);
 void Phy_PeekRecvData(PHY_INST *instPtr, uint8_t *dataBuff);
 void Phy_RetrieveRecvData(PHY_INST *instPtr, uint8_t *dataBuff);
+void Phy_UpdateLogging(PHY_INST *instPtr);
+void Phy_RefreshHwSate(PHY_INST *instPtr);
+/** @} PhysicalLayer_Main*/
 
+/**
+ * @defgroup PhysicalLayer_Utility
+ * @{
+ */
 bool Phy_IsFrameDetected(PHY_INST *instPtr);
 bool Phy_IsFrameReceived(PHY_INST *instPtr);
 bool Phy_IsFrameValid(PHY_INST *instPtr);
 uint32_t Phy_GetFrameLen(L1_FRAME_TYPE frameType);
-
-L1_FRAME_TYPE Phy_GetLastRecvFrameType(PHY_INST *instPtr);
-L1_FRAME_TYPE Phy_GetLastSendFrameType(PHY_INST *instPtr);
-
-int32_t Phy_SetHopPattern(void *patternBuff, uint32_t patternLen);
 uint32_t Phy_GetHopLength(L1_FRAME_TYPE frameType);
 uint32_t Phy_GetTimeComp(L1_FRAME_TYPE frameType);
+L1_FRAME_TYPE Phy_GetLastRecvFrameType(PHY_INST *instPtr);
+L1_FRAME_TYPE Phy_GetLastSendFrameType(PHY_INST *instPtr);
+/** @} PhysicalLayer_Utility*/
 
-void Phy_AntConfigInit(PHY_ANT_CONFIG *antConfig);
-void Phy_AntConfigMode(PHY_INST *instPtr, PHY_ANT_MODE mode);
-void Phy_SetBeamTable(PHY_INST *instPtr, PHY_ANT_ANGLE *table, uint32_t offset);
-int32_t Phy_SetBeamWidth(PHY_INST *instPtr, PHY_ANT_BEAM_WIDTH beamWidth);
-int32_t Phy_SetBeamNo(PHY_INST *instPtr, int32_t beamNo, PHY_ANT_BEAM_WIDTH beamWidth);
-int32_t Phy_SetBeamAngle(PHY_INST *phyInstPtr, double offAx, double rndAx);
-int32_t Phy_SetTimeWord(PHY_INST *instPtr, const TIME_WORD *tmWord, PHY_TIME_WORD_TYPE tmType);
-
+/**
+ * @defgroup PhysicalLayer_Receive_Estimations
+ * @{
+ */
 uint8_t Phy_LastScanBeamNo(PHY_INST *instPtr);
 double Phy_GetFreqEst(PHY_INST *instPtr);
 double Phy_GetCoarseFreqEst(PHY_INST *instPtr);
@@ -284,4 +293,20 @@ void Phy_GetFrameSyncTimeStamp(PHY_INST *instPtr, TIME_WORD *frameSyncT);
 void Phy_GetLastReceivedFrameSyncTimeStamp(PHY_INST *instPtr, TIME_WORD *frameSyncT);
 void Phy_GetSlotStartTimeStamp(PHY_INST *instPtr, TIME_WORD *slotStart);
 void Phy_GetLastReceivedSlotStartTimeStamp(PHY_INST *instPtr, TIME_WORD *slotStart);
+/** @} PhysicalLayer_Receive_Estimations*/
+
+/**
+ * @defgroup PhysicalLayer_AntennaControl
+ * @{
+ */
+void Phy_AntConfigInit(PHY_ANT_CONFIG *antConfig);
+void Phy_AntConfigMode(PHY_INST *instPtr, PHY_ANT_MODE mode);
+void Phy_SetBeamTable(PHY_INST *instPtr, PHY_ANT_ANGLE *table, uint32_t offset);
+int32_t Phy_SetBeamWidth(PHY_INST *instPtr, PHY_ANT_BEAM_WIDTH beamWidth);
+int32_t Phy_SetBeamNo(PHY_INST *instPtr, int32_t beamNo, PHY_ANT_BEAM_WIDTH beamWidth);
+int32_t Phy_SetBeamAngle(PHY_INST *phyInstPtr, double offAx, double rndAx);
+/** @} PhysicalLayer_AntennaControl*/
+
 #endif // PHY_CTRL_H_
+
+/** @} PhysicalLayer*/

df_datalink_sp/src/networking/phy_layer/phy_reg.h

@@ -1,24 +1,24 @@
 /*****************************************************************************/
 /**
- * Description: Physical layer register definitions
+ * @file phy_layer.h
+ * @author FanHao ([email protected])
+ * @brief Physical layer controller register definition
+ * @version 0.0
+ * @date 2023-04-24
  *
- * Author: Fan Hao
- * Date: 2021-11-16 00:08
- * LastEditors: Fan Hao
- * LastEditTime: 2023-04-24 17:32
- * Revisions: Rev 0.1
- * History:
- * [2021-11-16]: Initial version.
- * [2022-06-18]: New branch for glink control purpose:
- *               -Add poll mode physical layer will start Tx/Rx procedure
- * 				  at specific time stamp.
- * [2023-04-24]: Porting for DUIFEI.
- *
- * Copyright(c) 2021 Beijing Institute of Technology.
- * Lab of Communication and Networking
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
  *
  ******************************************************************************/
+/**
+ * @defgroup PhysicalLayer
+ * @{
+ */
 
+/**
+ * @name  PhysicalLayer_REG_Constants
+ * @{
+ */
 #ifndef PHY_REG_H_
 #define PHY_REG_H_
 
@@ -491,3 +491,7 @@
 #define PHY_DEINTLV_AMPEST_MASK 0x0000FFFFU
 
 #endif /* PHY_REG_H_ */
+
+/** @} PhysicalLayer_REG_Constants*/
+
+/** @} PhysicalLayer*/

df_datalink_sp/src/system_monitor.c

@@ -1,9 +1,19 @@
+/**
+ * @addtogroup SystemMonitor
+ * @{
+ */
+
+/***************************** Include Files *********************************/
 #include <string.h>
 #include <stdlib.h>
 #include <stdint.h>
 #include "common.h"
 #include "system_monitor.h"
-
+/************************** Constant Definitions *****************************/
+/**
+ * @name SystemMonitor_Private_Constants
+ * @{
+ */
 #define BUFF_A 0x00
 #define BUFF_B 0x01
 #define BUFF_NONE 0xFF
@@ -13,14 +23,23 @@
 #define SLOTLOG_PACK_LEN 88	 // bytes
 #define PRTCLLOG_PACK_ELN 24 // bytes
 #define HWSTATE_PACK_ELN 12	 // bytes
-
+/** @} SystemMonitor_Private_Constants*/
+/************************** Data Type Definitions ****************************/
+/**
+ * @struct PINGPONG
+ * @brief PingPing Control
+ */
 typedef struct
 {
-	uint8_t latest;
-	uint8_t rBusy;
-	uint8_t wBusy;
+	uint8_t latest; ///< latest available index
+	uint8_t rBusy;	///< current read busy index
+	uint8_t wBusy;	///< current write busy index
 } PINGPONG;
 
+/**
+ * @struct SYSMONITOR
+ * @brief System Monitor struct holds all the system log info
+ */
 typedef struct
 {
 	PINGPONG recvCtrl;
@@ -37,12 +56,14 @@ typedef struct
 	HWSTATE hwState[2];
 } SYSMONITOR;
 
+/************************** Function Prototypes ******************************/
+static uint8_t GetWritable(PINGPONG ctrllor);
+static uint8_t GetReadable(PINGPONG ctrllor);
+/************************** Variable Definitions *****************************/
 static SYSMONITOR *sysMonitorInst;
 
-uint8_t GetWritable(PINGPONG ctrllor);
-uint8_t GetReadable(PINGPONG ctrllor);
-
-inline uint8_t GetWritable(PINGPONG ctrllor)
+/*********************** Function Implementations  ***************************/
+inline static uint8_t GetWritable(PINGPONG ctrllor)
 {
 	// Allow only one write.
 	ASSERT(ctrllor.wBusy == BUFF_NONE);
@@ -52,7 +73,7 @@ inline uint8_t GetWritable(PINGPONG ctrllor)
 		return ((ctrllor.rBusy == BUFF_B) ? BUFF_A : BUFF_B);
 }
 
-inline uint8_t GetReadable(PINGPONG ctrllor)
+inline static uint8_t GetReadable(PINGPONG ctrllor)
 {
 	if (ctrllor.wBusy == BUFF_NONE || ctrllor.wBusy != ctrllor.latest)
 		return ((ctrllor.latest == BUFF_NONE) ? BUFF_A : BUFF_B);
@@ -60,7 +81,11 @@ inline uint8_t GetReadable(PINGPONG ctrllor)
 		return ((ctrllor.wBusy == BUFF_B) ? BUFF_A : BUFF_B);
 }
 
-// System monitor initialise
+/**
+ * @brief Initialize System monitor
+ *
+ * @return SUCCESS
+ */
 int32_t SysMonitor_Init(void)
 {
 	sysMonitorInst = calloc(1, sizeof(SYSMONITOR));
@@ -82,15 +107,23 @@ int32_t SysMonitor_Init(void)
 	return SUCCESS;
 }
 
-// System monitor initialise
+/**
+ * @brief Destroy system monitor release all allocated memory
+ */
 void SysMonitor_Destroy(void)
 {
 	free(sysMonitorInst);
 }
 
-// @System Info
 /**
- * Update system info.
+ * @name SystemInfo_API
+ * @{
+ */
+
+/**
+ * @brief Update system info.
+ *
+ * @param info
  */
 void SysMonitor_UpdateSysinfo(const SYSINFO *info)
 {
@@ -103,7 +136,9 @@ void SysMonitor_UpdateSysinfo(const SYSINFO *info)
 }
 
 /**
- * Get system info.
+ * @brief Get system info.
+ *
+ * @param info
  */
 void SysMonitor_GetSysinfo(SYSINFO *info)
 {
@@ -118,14 +153,26 @@ void SysMonitor_GetSysinfo(SYSINFO *info)
 	memcpy(info, &(sysMonitorInst->sysInfo[buffIndx]), sizeof(SYSINFO));
 	sysMonitorInst->sysInfoCtrl.rBusy = buffIndex_old;
 }
+/** @} SystemInfo_API*/
 
-// @Send Payload
 /**
- * Update send payload by.
+ * @name ServicePayload_API
+ * @{
+ */
+
+/**
+ * @brief Update send payload by
+ *
+ * @param buff
+ * @param len
  */
 void SysMonitor_UpdateSendPayload(const uint8_t *buff, size_t len)
 {
 	ASSERT(sysMonitorInst != NULL);
+	if (len > PAYLOAD_LEN_MAX)
+	{
+		return;
+	}
 	uint8_t buffIndx;
 	buffIndx = GetWritable(sysMonitorInst->sendCtrl);
 	sysMonitorInst->sendCtrl.wBusy = buffIndx;
@@ -136,11 +183,21 @@ void SysMonitor_UpdateSendPayload(const uint8_t *buff, size_t len)
 }
 
 /**
- * Get the latest send payload.
+ * @brief Get the latest send payload.
+ *
+ * @param buff
+ * @param id
+ * @param len
  */
 void SysMonitor_GetSendPayload(uint8_t *buff, uint32_t *id, size_t len)
 {
 	ASSERT(sysMonitorInst != NULL);
+	ASSERT(buff != NULL);
+	ASSERT(id != NULL);
+	if (len > PAYLOAD_LEN_MAX)
+	{
+		return;
+	}
 	uint8_t buffIndx, buffIndex_old;
 	buffIndex_old = sysMonitorInst->sendCtrl.rBusy;
 	if (buffIndex_old != BUFF_NONE)
@@ -156,28 +213,46 @@ void SysMonitor_GetSendPayload(uint8_t *buff, uint32_t *id, size_t len)
 	sysMonitorInst->sendCtrl.rBusy = buffIndex_old;
 }
 
-// @Receive Payload
 /**
- * Update receive payload.
+ * @brief Update receive payload.
+ *
+ * @param buff
+ * @param id
+ * @param len
  */
-void SysMonitor_UpdateRecvPayload(const uint8_t *buff, size_t len)
+void SysMonitor_UpdateRecvPayload(const uint8_t *buff, uint32_t id, size_t len)
 {
 	ASSERT(sysMonitorInst != NULL);
+	ASSERT(buff != NULL);
+	if (id == DATA_ID_NONE || len > PAYLOAD_LEN_MAX)
+	{
+		return;
+	}
 	uint8_t buffIndx;
 	buffIndx = GetWritable(sysMonitorInst->recvCtrl);
 	sysMonitorInst->recvCtrl.wBusy = buffIndx;
 	memcpy(sysMonitorInst->recv[buffIndx].data, buff, len);
-	sysMonitorInst->recv[buffIndx].dataId++;
+	sysMonitorInst->recv[buffIndx].dataId = id;
 	sysMonitorInst->recvCtrl.latest = buffIndx;
 	sysMonitorInst->recvCtrl.wBusy = BUFF_NONE;
 }
 
 /**
- * Get the latest receive payload.
+ * @brief Get the latest receive payload.
+ *
+ * @param buff
+ * @param id
+ * @param len
  */
 void SysMonitor_GetRecvPayload(uint8_t *buff, uint32_t *id, size_t len)
 {
 	ASSERT(sysMonitorInst != NULL);
+	ASSERT(buff != NULL);
+	ASSERT(id != NULL);
+	if (len > PAYLOAD_LEN_MAX)
+	{
+		return;
+	}
 	uint8_t buffIndx, buffIndex_old;
 	buffIndex_old = sysMonitorInst->recvCtrl.rBusy;
 	if (buffIndex_old != BUFF_NONE)
@@ -192,14 +267,22 @@ void SysMonitor_GetRecvPayload(uint8_t *buff, uint32_t *id, size_t len)
 	*id = sysMonitorInst->recv[buffIndx].dataId;
 	sysMonitorInst->recvCtrl.rBusy = buffIndex_old;
 }
+/** @} ServicePayload_API*/
 
-// @Link layer log
 /**
- * Update link layer log
+ * @name Linklayer_Log_API
+ * @{
+ */
+
+/**
+ * @brief Update link layer log
+ *
+ * @param log
  */
 void SysMonitor_UpdateLinklayerLog(const LINKLOG *log)
 {
 	ASSERT(sysMonitorInst != NULL);
+	ASSERT(log != NULL);
 	uint8_t buffIndx;
 	buffIndx = GetWritable(sysMonitorInst->linkLogCtrl);
 	sysMonitorInst->linkLogCtrl.wBusy = buffIndx;
@@ -209,11 +292,14 @@ void SysMonitor_UpdateLinklayerLog(const LINKLOG *log)
 }
 
 /**
- * Get the latest link layer log
+ * @brief Get the latest link layer log
+ *
+ * @param log
  */
 void SysMonitor_GetLinklayerLog(LINKLOG *log)
 {
 	ASSERT(sysMonitorInst != NULL);
+	ASSERT(log != NULL);
 	uint8_t buffIndx, buffIndex_old;
 	buffIndex_old = sysMonitorInst->linkLogCtrl.rBusy;
 	if (buffIndex_old != BUFF_NONE)
@@ -224,14 +310,22 @@ void SysMonitor_GetLinklayerLog(LINKLOG *log)
 	memcpy(log, &(sysMonitorInst->linkLog[buffIndx]), sizeof(LINKLOG));
 	sysMonitorInst->linkLogCtrl.rBusy = buffIndex_old;
 }
+/** @} Linklayer_Log_API*/
 
-// @Physical layer log
 /**
- * Update physical layer log
+ * @name PhysicalLayer_Log_API
+ * @{
+ */
+
+/**
+ * @brief Update physical layer log
+ *
+ * @param log
  */
 void SysMonitor_UpdatePhysicalLayerLog(const PHYLOG *log)
 {
 	ASSERT(sysMonitorInst != NULL);
+	ASSERT(log != NULL);
 	uint8_t buffIndx;
 	buffIndx = GetWritable(sysMonitorInst->phyLogCtrl);
 	sysMonitorInst->phyLogCtrl.wBusy = buffIndx;
@@ -241,11 +335,14 @@ void SysMonitor_UpdatePhysicalLayerLog(const PHYLOG *log)
 }
 
 /**
- * Get the latest physical layer log
+ * @brief Get the latest physical layer log
+ *
+ * @param log
  */
 void SysMonitor_GetPhysicalLayerLog(PHYLOG *log)
 {
 	ASSERT(sysMonitorInst != NULL);
+	ASSERT(log != NULL);
 	uint8_t buffIndx, buffIndex_old;
 	buffIndex_old = sysMonitorInst->phyLogCtrl.rBusy;
 	if (buffIndex_old != BUFF_NONE)
@@ -256,15 +353,22 @@ void SysMonitor_GetPhysicalLayerLog(PHYLOG *log)
 	memcpy(log, &(sysMonitorInst->phyLog[buffIndx]), sizeof(PHYLOG));
 	sysMonitorInst->phyLogCtrl.rBusy = buffIndex_old;
 }
+/** @} */
 
-
-// @Hardware state
 /**
- * Log hardware running status.
+ * @name HardwareState_Log_API
+ * @{
+ */
+
+/**
+ * @brief Log hardware running status.
+ *
+ * @param state
  */
 void SysMonitor_UpdateHardwareStatus(const HWSTATE *state)
 {
 	ASSERT(sysMonitorInst != NULL);
+	ASSERT(state != NULL);
 	uint8_t buffIndx;
 	buffIndx = GetWritable(sysMonitorInst->hwStateCtrl);
 	sysMonitorInst->hwStateCtrl.wBusy = buffIndx;
@@ -274,11 +378,14 @@ void SysMonitor_UpdateHardwareStatus(const HWSTATE *state)
 }
 
 /**
- * Get the latest hardware running status.
+ * @brief Get the latest hardware running status.
+ *
+ * @param state
  */
 void SysMonitor_GetHardwareStatus(HWSTATE *state)
 {
 	ASSERT(sysMonitorInst != NULL);
+	ASSERT(state != NULL);
 	uint8_t buffIndx, buffIndex_old;
 	buffIndex_old = sysMonitorInst->hwStateCtrl.rBusy;
 	if (buffIndex_old != BUFF_NONE)
@@ -289,3 +396,7 @@ void SysMonitor_GetHardwareStatus(HWSTATE *state)
 	memcpy(state, &(sysMonitorInst->hwState[buffIndx]), sizeof(HWSTATE));
 	sysMonitorInst->hwStateCtrl.rBusy = buffIndex_old;
 }
+
+/** @} HardwareState_Log_API */
+
+/** @} SystemMonitor*/

df_datalink_sp/src/system_monitor.h

@@ -1,10 +1,21 @@
+/**
+ * @defgroup SystemMonitor
+ * @{
+ */
+
 #ifndef __SYSTEM_MONITOR_H_
 #define __SYSTEM_MONITOR_H_
 
+/***************************** Include Files *********************************/
 #include <stdint.h>
 #include <stdbool.h>
 #include "util.h"
 
+/************************* Constant Definitions ******************************/
+/**
+ * @name SystemMonitor_Constants
+ * @{
+ */
 #define PAYLOAD_LEN_MAX 256
 #define PAYLOAD_LEN_FLJ_RX 168
 #define PAYLOAD_LEN_FLJ_TX 66
@@ -36,12 +47,19 @@
 #define VOLT_ANT_NIL_OK BIT(4)
 #define ANT_STATE_OK BIT(6)
 
+// Xilinx Recommended
+// #define IS_PS_VALID(x) (x <= 1.05 && x >= 0.95)
+// #define IS_PSAUX_VALID(x) (x <= 1.89 && x >= 1.71)
+// #define IS_DDR_VALID(x) (x <= 1.89 && x >= 1.14)
+// #define IS_PL_VALID(x) (x <= 1.03 && x >= 0.97)
+// #define IS_PLAUX_VALID(x) (x <= 1.89 && x >= 1.71)
+// #define IS_BRAM_VALID(x) (x <= 1.03 && x >= 0.97)
 #define IS_PS_VALID(x) (x <= 1.05 && x >= 0.95)
 #define IS_PSAUX_VALID(x) (x <= 1.89 && x >= 1.71)
 #define IS_DDR_VALID(x) (x <= 1.89 && x >= 1.14)
-#define IS_PL_VALID(x) (x <= 1.03 && x >= 0.97)
+#define IS_PL_VALID(x) (x <= 1.03 && x >= 0.96)
 #define IS_PLAUX_VALID(x) (x <= 1.89 && x >= 1.71)
-#define IS_BRAM_VALID(x) (x <= 1.03 && x >= 0.97)
+#define IS_BRAM_VALID(x) (x <= 1.03 && x >= 0.96)
 
 #define CLK_SP_PLL0_LOCK BIT(0)
 #define CLK_SP_PLL1_LOCK BIT(2)
@@ -58,131 +76,147 @@
 #define TEMPERATURE_LSB 1.0	   // Celsius degree
 #define TEMPERATURE_MAX 127.0  // Celsius degree
 #define TEMPERATURE_MIN -128.0 // Celsius degree
+/** @} SystemMonitor_Constants */
 
+/************************* Data Type Definitions ****************************/
+
+/**
+ * @struct SYSINFO
+ * @brief System Infomation log
+ */
 typedef struct __attribute__((packed))
 {
-	// -- unit: ms, 0~604799999
-	uint32_t psBDS;
-	// -- unit: week, 0~0~8191
-	uint16_t pBDS;
-	// -- unit: ms, 0~604799999
-	uint32_t psGPS;
-	// -- unit: week, 0~0~8191
-	uint16_t pGPS;
-	// Time validation indicator
-	// -- [0] GPS
-	// -- [1] reserve.
-	// -- [2] UTC
-	// -- [3] BDS
-	uint8_t tmInd;
-	// Time of flying
-	// uint: s
-	float tmFly;
-	// Status of flying
-	// [7:6] departure status 11 - departed/00 - not departed
-	// [5:4] ready status 11 - ready/00 - not ready
-	// [3:2] attitude status 11 - attitude ok/00 - attitude not ok
+	uint32_t psBDS; ///< -- unit: ms, 0~604799999
+	uint16_t pBDS;	///< -- unit: week, 0~0~8191
+	uint32_t psGPS; ///< -- unit: ms, 0~604799999
+	uint16_t pGPS;	///< -- unit: week, 0~0~8191
+	uint8_t tmInd;	///< Time validation indicator \n
+					// -- [0] GPS\n
+					// -- [1] reserve.\n
+					// -- [2] UTC\n
+					// -- [3] BDS\n
+	float tmFly;	///< Time of flying uint: s
+	uint8_t stFly;	///< Status of flying \n
+					// [7:6] departure status 11 - departed/00 - not departed \n
+					// [5:4] ready status 11 - ready/00 - not ready \n
+					// [3:2] attitude status 11 - attitude ok/00 - attitude not ok \n
 					// [1:0] attitude adjust status 11 - adjusted/00 - not adjusted
-	uint8_t stFly;
-	// Position in launch coordinate system
-	float posX;
-	float posY;
-	float posZ;
-	// Speed in launch coordinate system
-	float vX;
-	float vY;
-	float vZ;
-	// Attitude in launch inertia coordinate system
-	float pitch;
-	float yaw;
-	float roll;
+	float posX;		///< coord X Position in launch coordinate system
+	float posY;		///< coord Y Position in launch coordinate system
+	float posZ;		///< coord Z Position in launch coordinate system
+	float vX;		///< Speed X in launch coordinate system
+	float vY;		///< Speed Y in launch coordinate system
+	float vZ;		///< Speed Z in launch coordinate system
+	float pitch;	///< Pitch Attitude in launch inertia coordinate system
+	float yaw;		///< Yaw Attitude in launch inertia coordinate system
+	float roll;		///< Roll Attitude in launch inertia coordinate system
 } SYSINFO;
 
+/**
+ * @struct SYSBUSLOG
+ * @brief System Info holds the system bus log
+ */
 typedef struct __attribute__((packed))
 {
 	// SystemBus log
-	// -- last valid config
-	//    byte 0: 0x11 FLJ, 0x00 LJ
+
+	uint8_t lastConfig[2]; ///< Last valid config \n
+						   //  byte 0: 0x11 FLJ, 0x00 LJ \n
 						   //   byte 1: 0x66 Full Power, 0x88 Low Power
-	uint8_t lastConfig[2];
-	uint32_t pollCnt;
-	uint32_t svcCnt;
-	uint32_t remoteCnt;
+	uint32_t pollCnt;	   ///< number of poll commands
+	uint32_t svcCnt;	   ///< number of service commands
+	uint32_t remoteCnt;	   ///< number of remote check commands
 } SYSBUSLOG;
 
+/**
+ * @struct LINKLOG
+ * @brief Linklayer Log struct holds the Linklayer log
+ */
 typedef struct __attribute__((packed))
 {
 	// Network log
-	uint32_t tuNum;
-	uint8_t slotNum;
-	uint8_t nodeType;
-	uint8_t cxnStatus;
-	uint8_t linkStage;
-	uint32_t recxnCnt;
-	uint8_t beamNo;
-	uint8_t beamWidth;
-	uint16_t beamAz;
-	uint16_t beamEl;
-	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;
-	int32_t timeDev;
-	uint32_t sendId;
-	uint32_t recvId;
-	uint8_t reserve[4];
+	uint32_t tuNum;			///< current time unite number
+	uint8_t slotNum;		///< current slot number
+	uint8_t nodeType;		///< current node type
+	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 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 cfmRecvCnt;	///< cfm frame received count
+	uint32_t cfmCorrectCnt; ///< adv 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
+	int32_t timeDev;		///< last time deviation result
+	uint32_t sendId;		///< last send data id
+	uint32_t recvId;		///< last received data id
+	uint8_t reserve[4];		///< reserved data
 } LINKLOG;
 
+/**
+ * @struct PHYLOG
+ * @brief Physical Layer Log struct holds the Linklayer log
+ */
 typedef struct __attribute__((packed))
 {
-	uint32_t acqCnt;
-	uint32_t fsyncCnt;
-	uint32_t decodeCnt;
-	uint32_t crcCnt;
-	double doppler;
-	uint64_t recvStamp;
-	double acqPAPR;
-	uint8_t acqPhase;
-	uint8_t acqFreqCh;
-	double fsyncPAPR;
-	uint8_t fsyncFreqCh;
-	uint16_t deintlvAmpEst;
-	uint8_t antMode;
-	uint8_t reserve[3];
+	uint32_t acqCnt;		///< aquisition count
+	uint32_t fsyncCnt;		///< frame sync count
+	uint32_t decodeCnt;		///< decode count
+	uint32_t crcCnt;		///< crc valid count
+	double doppler;			///< last doppler estimation result
+	uint64_t recvStamp;		///< last frame arrival time
+	double acqPAPR;			///< last acquisition peak-average ration
+	uint8_t acqPhase;		///< last acquisition phase estimation
+	uint8_t acqFreqCh;		///< last acquisition frequency deviation estimation
+	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 reserve[3];		///< reserved data
 } PHYLOG;
 
+/**
+ * @struct HWSTATE
+ * @brief Hardware Status Log struct holds all hardware status
+ */
 typedef struct __attribute__((packed))
 {
-	// Hardware status
-	bool isSpOk;
-	bool isAntOk;
+	bool isSpOk;  ///< signal processor state
+	bool isAntOk; ///< antenna state
 	// -- Signal processor status
-	uint8_t spFpgaVolt;
-	uint8_t spClkState;
-	uint8_t spAdLockState;
-	uint8_t spAdTemp_0;
-	uint8_t spAdTemp_1;
-	uint8_t spFpgaTemp;
+	uint8_t spFpgaVolt;	   ///< Signal processor voltage state indicator
+	uint8_t spClkState;	   ///< Signal processor clock state indicator
+	uint8_t spAdLockState; ///< Signal processor adc lock state indicator
+	uint8_t spAdTemp_0;	   ///< Signal processor adc0 temperature
+	uint8_t spAdTemp_1;	   ///< Signal processor adc1 temperature
+	uint8_t spFpgaTemp;	   ///< Signal processor FPGA temperature
 	// -- Antenna status
-	uint8_t antVolt;
-	uint8_t antTemp;
-	uint8_t antPll;
-	uint8_t antMgc0;
-	uint8_t antMgc1;
+	uint8_t antVolt; ///< Antenna voltage state indicator
+	uint8_t antTemp; ///< Antenna rf temperature
+	uint8_t antPll;	 ///< Antenna rf lock state indicator
+	uint8_t antMgc0; ///< Antenna rf mgc0~1 indicator
+	uint8_t antMgc1; ///< Antenna rf mgc2~3 indicator
 	uint8_t reserve[2];
 } HWSTATE;
 
+/**
+ * @struct PAYLOAD
+ * @brief Payload struct holds the service payload
+ */
 typedef struct
 {
 	uint32_t dataId;
 	uint8_t data[PAYLOAD_LEN_MAX];
 } PAYLOAD;
 
+/************************** Function Prototypes ******************************/
 int32_t SysMonitor_Init(void);
 void SysMonitor_Destroy(void);
 
@@ -190,7 +224,7 @@ void SysMonitor_UpdateSysinfo(const SYSINFO *info);
 void SysMonitor_GetSysinfo(SYSINFO *info);
 
 void SysMonitor_UpdateSendPayload(const uint8_t *buff, size_t len);
-void SysMonitor_UpdateRecvPayload(const uint8_t *buff, size_t len);
+void SysMonitor_UpdateRecvPayload(const uint8_t *buff, uint32_t id, size_t len);
 void SysMonitor_GetSendPayload(uint8_t *buff, uint32_t *id, size_t len);
 void SysMonitor_GetRecvPayload(uint8_t *buff, uint32_t *id, size_t len);
 
@@ -202,3 +236,5 @@ void SysMonitor_GetPhysicalLayerLog(PHYLOG *log);
 void SysMonitor_GetHardwareStatus(HWSTATE *state);
 
 #endif //__SYSTEM_MONITOR_H_
+
+/** @} */

df_datalink_sp/src/systembus/systembus.c

@@ -1,22 +1,21 @@
 /*****************************************************************************/
 /**
- * Description: System bus protocol implementation file.
+ * @file systembus.c
+ * @author FanHao (hao_fan_bit_ee@163.com)
+ * @brief System bus protocol implementation file.
+ * @version 0.1
+ * @date 2023-05-06
  *
- * Date: 2023-05-06 10:13
- * Last Edit Time: [2023-05-06 21:45]
- *
- * Revisions: Rev 0.0
- * History:
- * [2023-05-06]: Initial version.
- * [2023-09-13]: Update to 485 protocol-20220816
- *
- * Copyright(c) 2021 Beijing Institute of Technology.
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
  * Lab of Communication and Network
  *
  ******************************************************************************/
 
+/**
+ * @addtogroup SystemBus
+ * @{
+ */
 /***************************** Include Files *********************************/
-
 #include <stdlib.h>
 #include <string.h>
 #include <stdint.h>
@@ -27,10 +26,18 @@
 #include "common.h"
 #include "error.h"
 #include "circ_queue.h"
-
 #include "../system_monitor.h"
 
+/**
+ * @addtogroup SystemBus_Protocol_Routine
+ * @{
+ */
+
 /************************** Constant Definitions *****************************/
+/**
+ * @name SystemBus_MSG_Constants
+ * @{
+ */
 // Common Field
 // -- Command word
 #define WD_CMD 0x00
@@ -190,10 +197,9 @@
 
 #define LJ_RM_TEST_RESP_LEN 158
 
-
 // My Production Type
 #define MY_PRD_ID PRD_DL_K
-
+/** @} SystemBus_MSG_Constants*/
 /************************** Function Prototypes ******************************/
 static int32_t SystemBus_GenSelfTestRsp(SYSBUS *instPtr);
 static int32_t SystemBus_SystemConfig(SYSBUS *instPtr, uint8_t *msg);
@@ -238,7 +244,8 @@ static int32_t SystemBus_GenSelfTestRsp(SYSBUS *instPtr)
 {
 	ASSERT(instPtr != NULL);
 	SYSBUS_UART_FRAME *sysbusRsp = malloc(sizeof(SYSBUS_UART_FRAME));
-	if (sysbusRsp == NULL) {
+	if (sysbusRsp == NULL)
+	{
 		DBG_ERROR("Failed to allocate memory for SELF TEST Response!\n");
 		return ENOMEM;
 	}
@@ -248,13 +255,13 @@ static int32_t SystemBus_GenSelfTestRsp(SYSBUS *instPtr)
 	sysbusRsp->data[WD_CMD] = CMD_SELF_TEST;
 	sysbusRsp->data[WD_PRD] = MY_PRD_ID;
 	SysMonitor_GetHardwareStatus(hwStatsPtr);
-	if (linkInstPtr->isEnable == false)
+	if (L2_isStarted(linkInstPtr))
 	{
-		sysbusRsp->data[WD_ST_RET] = (hwStatsPtr->isSpOk) ? ST_RET_OK : ST_RET_ERROR;
+		sysbusRsp->data[WD_ST_RET] = (hwStatsPtr->isSpOk && hwStatsPtr->isAntOk) ? ST_RET_OK : ST_RET_ERROR;
 	}
 	else
 	{
-		sysbusRsp->data[WD_ST_RET] = (hwStatsPtr->isSpOk && hwStatsPtr->isAntOk) ? ST_RET_OK : ST_RET_ERROR;
+		sysbusRsp->data[WD_ST_RET] = (hwStatsPtr->isSpOk) ? ST_RET_OK : ST_RET_ERROR;
 	}
 	// apply status and omit 2 bytes of overhead.
 	memcpy(sysbusRsp->data + WD_SP_FPGA_VOLT, &(hwStatsPtr->spFpgaVolt), ST_RET_INFO_LEN);
@@ -278,30 +285,21 @@ static int32_t SystemBus_SystemConfig(SYSBUS *instPtr, uint8_t *msg)
 	PHY_INST *phyRef = linkInstPtr->config.phyInstPtr;
 	TMC_INST *tmcRef = linkInstPtr->config.tmcInstPtr;
 	bool reconfig = false;
-	bool start = false;
 
 	if (msg[WD_MODE_CMD] == MODE_CMD_HEAD)
-	{
-		// omit unnecessary reconfiguration
-		if (L2_GetNodeType(linkInstPtr) != L2_NODE_HEAD)
 	{
 		// head node config
+		reconfig = (L2_NODE_HEAD != L2_GetNodeType(linkInstPtr));
 		linkConfig.myType = L2_NODE_HEAD;
 		linkConfig.myId = 1;
-			reconfig = true;
-		}
 	}
 
-	else if (msg[WD_MODE_CMD] == MODE_CMD_MEMBER )
-	{
-		// omit unnecessary reconfiguration
-		if (L2_GetNodeType(linkInstPtr) != L2_NODE_MEMBER)
+	else if (msg[WD_MODE_CMD] == MODE_CMD_MEMBER)
 	{
 		// member node config
+		reconfig = (L2_NODE_MEMBER != L2_GetNodeType(linkInstPtr));
 		linkConfig.myType = L2_NODE_MEMBER;
 		linkConfig.myId = 2;
-			reconfig = true;
-		}
 	}
 	else
 	{
@@ -311,23 +309,30 @@ static int32_t SystemBus_SystemConfig(SYSBUS *instPtr, uint8_t *msg)
 		return EPARAM;
 	}
 
-	if(msg[WD_EN_CMD] == EN_CMD_ON_HIGH_POWER)
+	if (msg[WD_EN_CMD] == EN_CMD_ON_HIGH_POWER)
 	{
-		// high power config
+		// full power config
 		Phy_AntConfigMode(phyRef, PHY_ANT_MODE_POWER_FULL);
-		start = true;
+		if (reconfig || !L2_isStarted(linkInstPtr))
+		{
+			Linklayer_Reconfig(linkInstPtr, &linkConfig);
 		}
-	else if(msg[WD_EN_CMD] == EN_CMD_ON_LOW_POWER)
+		Linklayer_Start(linkInstPtr);
+	}
+	else if (msg[WD_EN_CMD] == EN_CMD_ON_LOW_POWER)
 	{
 		// low power config
 		Phy_AntConfigMode(phyRef, PHY_ANT_MODE_POWER_LOW);
-		start = true;
+		if (reconfig || !L2_isStarted(linkInstPtr))
+		{
+			Linklayer_Reconfig(linkInstPtr, &linkConfig);
 		}
-	else if(msg[WD_EN_CMD] == EN_CMD_SILENT)
+		Linklayer_Start(linkInstPtr);
+	}
+	else if (msg[WD_EN_CMD] == EN_CMD_SILENT)
 	{
 		// silence config
 		// TODO: better approach?
-		start = false;
 		Linklayer_Halt(linkInstPtr);
 		Phy_AntConfigMode(phyRef, PHY_ANT_MODE_STANDBY);
 		TIME_WORD pullTime = {0, 0};
@@ -338,13 +343,12 @@ static int32_t SystemBus_SystemConfig(SYSBUS *instPtr, uint8_t *msg)
 		}
 		Phy_SetupNextSlot(phyRef, PHY_TOR_RX, L1_10KBPS_10MS_FRAME, NULL);
 	}
-	if (reconfig == true)
+	else
 	{
-		Linklayer_Reconfig(linkInstPtr, &linkConfig);
-	}
-	if (start == true)
-	{
-		Linklayer_Start(linkInstPtr);
+		// Ignore current command
+		DBG_ERROR("Unexpected config command 0x%02X:0x%02X",
+				  WD_EN_CMD, msg[WD_EN_CMD]);
+		return EIGNORE;
 	}
 	instPtr->sysbusLog.lastConfig[0] = msg[WD_MODE_CMD];
 	instPtr->sysbusLog.lastConfig[1] = msg[WD_EN_CMD];
@@ -359,7 +363,8 @@ static int32_t SystemBus_Echo(SYSBUS *instPtr, SYSBUS_UART_FRAME *frame)
 	ASSERT(instPtr != NULL);
 	ASSERT(frame != NULL);
 	SYSBUS_UART_FRAME *sysbusRsp = malloc(sizeof(SYSBUS_UART_FRAME));
-	if (sysbusRsp == NULL) {
+	if (sysbusRsp == NULL)
+	{
 		DBG_ERROR("Failed to allocate memory for DATA TEST A Response!\n");
 		return ENOMEM;
 	}
@@ -384,12 +389,13 @@ static int32_t SystemBus_GenPollRsp(SYSBUS *instPtr, uint8_t *msg)
 	size_t dataLen;
 	uint8_t *payload;
 	SYSBUS_UART_FRAME *sysbusRsp = malloc(sizeof(SYSBUS_UART_FRAME));
-	if (sysbusRsp == NULL) {
+	if (sysbusRsp == NULL)
+	{
 		DBG_ERROR("Failed to allocate memory for FLJ POLL Response!\n");
 		return ENOMEM;
 	}
 
-	if(msg[WD_CMD] == CMD_FLJ_POLL)
+	if (msg[WD_CMD] == CMD_FLJ_POLL)
 	{
 		sysbusRsp->len = FLJ_POLL_RESP_LEN;
 		sysbusRsp->data[WD_CMD] = CMD_FLJ_POLL;
@@ -397,7 +403,7 @@ static int32_t SystemBus_GenPollRsp(SYSBUS *instPtr, uint8_t *msg)
 		dataLen = PAYLOAD_LEN_FLJ_RX;
 		payload = sysbusRsp->data + FLJ_DATA_OFFSET;
 	}
-	else if(msg[WD_CMD] == CMD_LJ_POLL)
+	else if (msg[WD_CMD] == CMD_LJ_POLL)
 	{
 		sysbusRsp->len = LJ_POLL_RESP_LEN;
 		sysbusRsp->data[WD_CMD] = CMD_LJ_POLL;
@@ -437,7 +443,8 @@ static int32_t SystemBus_GenRemoteTestRsp(SYSBUS *instPtr, uint8_t *msg)
 	ASSERT(instPtr != NULL);
 	ASSERT(msg != NULL);
 	SYSBUS_UART_FRAME *sysbusRsp = malloc(sizeof(SYSBUS_UART_FRAME));
-	if (sysbusRsp == NULL) {
+	if (sysbusRsp == NULL)
+	{
 		DBG_ERROR("Failed to allocate memory for LJ REMOTE TEST Response!\n");
 		return ENOMEM;
 	}
@@ -447,7 +454,7 @@ static int32_t SystemBus_GenRemoteTestRsp(SYSBUS *instPtr, uint8_t *msg)
 	TimeCtrl_GetCurrentTime(linkInstPtr->config.tmcInstPtr, &tmWord);
 	time = (uint64_t)tmWord.int_part * TIME_FRAC_MAX + tmWord.frac_part;
 
-	if(msg[WD_CMD] == CMD_FLJ_RM_TEST)
+	if (msg[WD_CMD] == CMD_FLJ_RM_TEST)
 	{
 		sysbusRsp->len = FLJ_RM_TEST_RESP_LEN;
 		memset(sysbusRsp->data, 0x00, FLJ_RM_TEST_RESP_LEN);
@@ -485,7 +492,8 @@ static int32_t SystemBus_GenRemoteTestRsp(SYSBUS *instPtr, uint8_t *msg)
 		return EUNEXP;
 	}
 
-	if (CircQueuePush(instPtr->txQueue, (void *)sysbusRsp) == false){
+	if (CircQueuePush(instPtr->txQueue, (void *)sysbusRsp) == false)
+	{
 		free(sysbusRsp);
 		DBG_WARNING("SystemBus::TX Queue overflowed!\n");
 		return EQUEUE;
@@ -494,64 +502,6 @@ static int32_t SystemBus_GenRemoteTestRsp(SYSBUS *instPtr, uint8_t *msg)
 	return SUCCESS;
 }
 
-/*****************************************************************************/
-/**
- * @brief   Initialize System Bus instance.
- *
- * @param   InstPtr A double pointer to System Bus instance.
- * @param   config  A pointer to System Bus configurations.
- *
- * @return  None.
- *
- ******************************************************************************/
-int32_t SystemBus_Init(SYSBUS **instPtr, SYSBUS_CONFIG *config)
-{
-	ASSERT(instPtr != NULL);
-	ASSERT(config != NULL);
-	SYSBUS_UART_CONFIG uartConfig;
-	int32_t Status;
-	(*instPtr) = malloc(sizeof(SYSBUS));
-	if ((*instPtr) == NULL)
-	{
-		return FAILURE;
-	}
-	(*instPtr)->rxQueue = NULL;
-	(*instPtr)->txQueue = NULL;
-	(*instPtr)->uartInst = NULL;
-	memcpy(&((*instPtr)->config), config, sizeof(SYSBUS_CONFIG));
-	memset(&((*instPtr)->sysbusLog), 0x00, sizeof(SYSBUSLOG));
-	memset(&((*instPtr)->linkLog), 0x00, sizeof(LINKLOG));
-	memset(&((*instPtr)->phyLog), 0x00, sizeof(PHYLOG));
-	memset(&((*instPtr)->hwState), 0x00, sizeof(HWSTATE));
-	uartConfig.baseAddr = config->baseAddr;
-	Status = SysbusUart_Init(&((*instPtr)->uartInst), &uartConfig);
-	if (Status != SUCCESS)
-	{
-		Status = ENOMEM;
-		goto sysbus_init_error;
-	}
-	if (CircQueueCreate(&((*instPtr)->txQueue), (*instPtr)->config.txQueueMax) == false)
-	{
-		Status = ENOMEM;
-		goto sysbus_init_error;
-	}
-	if (CircQueueCreate(&((*instPtr)->rxQueue), (*instPtr)->config.rxQueueMax) == false)
-	{
-		Status = ENOMEM;
-		goto sysbus_init_error;
-	}
-	(*instPtr)->isRxDone = false; // nothing received.
-	(*instPtr)->isTxDone = true;  // nothing to be sent.
-	return SUCCESS;
-
-sysbus_init_error:
-	free((*instPtr)->uartInst);
-	free((*instPtr)->txQueue);
-	free((*instPtr)->rxQueue);
-	free(*instPtr);
-	return Status;
-}
-
 /*****************************************************************************/
 /**
  * @brief   A handler function. This handler  evaluate the message from system
@@ -698,6 +648,66 @@ int32_t SystemBus_MakeResp(SYSBUS *instPtr)
 	return Status;
 }
 
+/** @} */
+
+/*****************************************************************************/
+/**
+ * @brief   Initialize System Bus instance.
+ *
+ * @param   InstPtr A double pointer to System Bus instance.
+ * @param   config  A pointer to System Bus configurations.
+ *
+ * @return  None.
+ *
+ ******************************************************************************/
+int32_t SystemBus_Init(SYSBUS **instPtr, SYSBUS_CONFIG *config)
+{
+	ASSERT(instPtr != NULL);
+	ASSERT(config != NULL);
+	SYSBUS_UART_CONFIG uartConfig;
+	int32_t Status;
+	(*instPtr) = malloc(sizeof(SYSBUS));
+	if ((*instPtr) == NULL)
+	{
+		return FAILURE;
+	}
+	(*instPtr)->rxQueue = NULL;
+	(*instPtr)->txQueue = NULL;
+	(*instPtr)->uartInst = NULL;
+	memcpy(&((*instPtr)->config), config, sizeof(SYSBUS_CONFIG));
+	memset(&((*instPtr)->sysbusLog), 0x00, sizeof(SYSBUSLOG));
+	memset(&((*instPtr)->linkLog), 0x00, sizeof(LINKLOG));
+	memset(&((*instPtr)->phyLog), 0x00, sizeof(PHYLOG));
+	memset(&((*instPtr)->hwState), 0x00, sizeof(HWSTATE));
+	uartConfig.baseAddr = config->baseAddr;
+	Status = SysbusUart_Init(&((*instPtr)->uartInst), &uartConfig);
+	if (Status != SUCCESS)
+	{
+		Status = ENOMEM;
+		goto sysbus_init_error;
+	}
+	if (CircQueueCreate(&((*instPtr)->txQueue), (*instPtr)->config.txQueueMax) == false)
+	{
+		Status = ENOMEM;
+		goto sysbus_init_error;
+	}
+	if (CircQueueCreate(&((*instPtr)->rxQueue), (*instPtr)->config.rxQueueMax) == false)
+	{
+		Status = ENOMEM;
+		goto sysbus_init_error;
+	}
+	(*instPtr)->isRxDone = false; // nothing received.
+	(*instPtr)->isTxDone = true;  // nothing to be sent.
+	return SUCCESS;
+
+sysbus_init_error:
+	free((*instPtr)->uartInst);
+	free((*instPtr)->txQueue);
+	free((*instPtr)->rxQueue);
+	free(*instPtr);
+	return Status;
+}
+
 /*****************************************************************************/
 /**
  * @brief   This function handles the systembus tx irq events.
@@ -751,3 +761,5 @@ recv_error:
 	free(sysbusReq);
 	return Status;
 }
+
+/** @} SystemBus*/

df_datalink_sp/src/systembus/systembus.h

@@ -1,18 +1,20 @@
 /*****************************************************************************/
 /**
- * Description: System bus protocol head file.
+ * @file systembus.h
+ * @author FanHao (hao_fan_bit_ee@163.com)
+ * @brief System bus protocol header file.
+ * @version 0.1
+ * @date 2023-05-06
  *
- * Date: 2023-05-06 10:12
- * Last Edit Time: [2023-05-06 10:13]
- *
- * Revisions: Rev 0.0
- * History:
- * [2023-05-06]: Initial version.
- *
- * Copyright(c) 2021 Beijing Institute of Technology.
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
  *
  ******************************************************************************/
 
+/**
+ * @defgroup SystemBus
+ * @{
+ */
 #ifndef __SYSTEMBUS_H_
 #define __SYSTEMBUS_H_
 
@@ -25,34 +27,47 @@
 
 /************************** Constant Definitions *****************************/
 /************************** Data Type Definitions ****************************/
-// Definition of SystemBus instance.
+
+/**
+ * @struct SYSBUS_CONFIG
+ * @brief SystemBus Config struct holds SystemBus initialization parameters
+ */
 typedef struct
 {
-    uintptr_t baseAddr;
-    uint32_t txQueueMax;
-    uint32_t rxQueueMax;
+	uintptr_t baseAddr;	 ///< base address in memory
+	uint32_t txQueueMax; ///< maximum tx queue length
+	uint32_t rxQueueMax; ///< maximum rx queue length
 } SYSBUS_CONFIG;
 
+/**
+ * @struct SYSBUS
+ * @brief SystemBus Instance struct
+ */
 typedef struct
 {
-    SYSBUS_CONFIG config;
-    SYSBUSLOG sysbusLog; // systembus log
-	LINKLOG linkLog; // Link layer log
-	PHYLOG phyLog; // Physical layer log
-	HWSTATE hwState; // Hardware status
-    SYSBUS_UART *uartInst;
-    CIRC_QUEUE *txQueue;
-    CIRC_QUEUE *rxQueue;
-    bool isRxDone;
-    bool isTxDone;
+	SYSBUS_CONFIG config;  ///< SystemBus initialization parameters
+	SYSBUSLOG sysbusLog;   ///< SystemBus log
+	LINKLOG linkLog;	   ///< Link layer log
+	PHYLOG phyLog;		   ///< Physical layer log
+	HWSTATE hwState;	   ///< Hardware status
+	SYSBUS_UART *uartInst; ///< physical uart controller instance
+	CIRC_QUEUE *txQueue;   ///< tx queue
+	CIRC_QUEUE *rxQueue;   ///< rx queue
+	bool isRxDone;		   ///< tx done indicator
+	bool isTxDone;		   ///< rx done indicator
 } SYSBUS;
 
 /************************** Function Prototypes ******************************/
 
 int32_t SystemBus_Init(SYSBUS **instPtr, SYSBUS_CONFIG *config);
 
+/**
+ * @defgroup SystemBus_Protocol_Routine
+ * @{
+ */
 int32_t SystemBus_HandleCmd(SYSBUS *instPtr);
 int32_t SystemBus_MakeResp(SYSBUS *instPtr);
+/** @} */
 
 int32_t SystemBus_TxIntrHandler(SYSBUS *instPtr);
 int32_t SystemBus_RxIntrHandler(SYSBUS *instPtr);
@@ -64,3 +79,5 @@ bool SystemBus_IsTxBusy(SYSBUS *instPtr);
 bool SystemBus_IsRxBusy(SYSBUS *instPtr);
 
 #endif //__SYSTEMBUS_H_
+
+/** @} SystemBus*/

df_datalink_sp/src/systembus/systembus_uart.c

@@ -1,18 +1,26 @@
 /*****************************************************************************/
 /**
- * Description: System bus uart driver implementation file.
+ * @file systembus_uart.h
+ * @author FanHao (hao_fan_bit_ee@163.com)
+ * @brief System bus uart driver implementation file.
+ * @version 0.1
+ * @date 2023-05-06
  *
- * Date: 2023-05-06 10:59
- * LastEditTime: 2023-05-06 21:56
- * Revisions: Rev 0.0
- * History:
- * [2023-05-06]: Initial version.
- *
- * Copyright(c) 2022 Beijing Institute of Technology.
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
  *
  ******************************************************************************/
+/**
+ * @addtogroup SystemBus
+ * @{
+ */
+
+/**
+ * @addtogroup SystemBus_UART
+ * @{
+ */
+
 
-/***************************** Include Files *******************************/
 #include <stdlib.h>
 #include <string.h>
 #include <stdint.h>
@@ -20,6 +28,10 @@
 #include "systembus_uart.h"
 #include "common.h"
 
+/**
+ * @name SystemBus_UART_Driver_Constants
+ * @{
+ */
 // Control and status register
 #define MODULE_VERSION 0
 #define UART_STATUS 4
@@ -47,7 +59,7 @@
 #define FRAME_CHECK_LEN 1	 // CheckSum
 #define FRAME_INFO_LEN 3	 // CheckSum, Dummy and DataLen
 #define FRAME_OVERHEAD_LEN 7 // CheckSum, Dummy and DataLen
-/*************************** Function Definitions ****************************/
+/** @} SystemBus_UART_Driver_Constants*/
 
 /*****************************************************************************/
 /**
@@ -246,3 +258,7 @@ bool SysbusUart_IsTxBusy(SYSBUS_UART *instPtr)
 		return false;
 	}
 }
+
+/** @} SystemBus_UART*/
+
+/** @} SystemBus*/

df_datalink_sp/src/systembus/systembus_uart.h

@@ -1,17 +1,25 @@
 /*****************************************************************************/
 /**
- * Description: System bus uart driver implementation file.
+ * @file systembus_uart.h
+ * @author FanHao (hao_fan_bit_ee@163.com)
+ * @brief System bus uart driver header file.
+ * @version 0.1
+ * @date 2023-05-06
  *
- * Date: 2023-05-06 10:59
- * LastEditTime: 2023-05-06 21:48
- * Revisions: Rev 0.0
- * History:
- * [2023-05-06]: Initial version.
- *
- * Copyright(c) 2022 Beijing Institute of Technology.
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
  *
  ******************************************************************************/
 
+/**
+ * @addtogroup SystemBus
+ * @{
+ */
+
+/**
+ * @defgroup SystemBus_UART
+ * @{
+ */
 #ifndef SYSTEMBUS_UART_H
 #define SYSTEMBUS_UART_H
 
@@ -61,16 +69,28 @@
 	IO_In32((baseAddr) + (offset))
 
 /************************** Data Type Definitions ****************************/
+/**
+ * @struct SYSBUS_UART_CONFIG
+ * @brief SystemBus UART driver initialization parameters
+ */
 typedef struct
 {
 	uintptr_t baseAddr;
 } SYSBUS_UART_CONFIG;
 
+/**
+ * @struct  SYSBUS_UART
+ * @brief SystemBus UART driver instance
+ */
 typedef struct
 {
 	SYSBUS_UART_CONFIG config;
 } SYSBUS_UART;
 
+/**
+ * @struct  SYSBUS_UART_FRAME
+ * @brief SystemBus UART frame definition
+ */
 typedef struct
 {
 	uint16_t len;
@@ -96,3 +116,7 @@ bool SysbusUart_IsRxBusy(SYSBUS_UART *instPtr);
 bool SysbusUart_IsTxBusy(SYSBUS_UART *instPtr);
 
 #endif // SYSTEMBUS_UART_H
+
+/** @} SystemBus_UART*/
+
+/** @} SystemBus*/

df_datalink_sp/src/time_ctrl/time_ctrl.c

@@ -1,20 +1,21 @@
 /*****************************************************************************/
 /**
- * Description: Time sync implementation file.
- *
- * Author: Author's name
- * Date: 2023-12-20 16:32
- * LastEditors: FanHao
- * LastEditTime: 2023-12-22 20:43
- * Revisions: Rev 0.0
- * History:
- * [2023-12-20]: Initial version.
- *
- * Copyright(c) 2021 Beijing Institute of Technology.
- * Lab of Communication and Networking
+ * @file time_ctrl.c
+ * @author FanHao (hao_fan_bit_ee@163.com)
+ * @brief Time sync controller driver implementation file.
+ * @version 0.0
+ * @date 2023-12-20
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
  *
  ******************************************************************************/
 
+/**
+ * @addtogroup TimeController_Driver
+ * @{
+ */
+
+
 /***************************** Include Files *********************************/
 #include <string.h>
 #include "time_ctrl.h"
@@ -23,6 +24,10 @@
 #include "util.h"
 
 /************************** Constant Definitions *****************************/
+/**
+ * @name TimeController_REG_Constants
+ * @{
+ */
 #define VERSION_REG 0x00000004
 #define TIME_INT_REG 0x00000008
 #define TIME_FRAC_REG 0x0000000C
@@ -36,6 +41,9 @@
 #define CNTSTEP_OPT 0x0000002c
 
 #define TM_RESET_CODE 0x5253542E
+
+/** @} TimeController_REG_Constants*/
+
 /***************** Macros (Inline Functions) Definitions *********************/
 #define TMC_Read(instPtr, addr) IO_In32(instPtr->config.baseAddr + addr)
 #define TMC_Write(instPtr, addr, value) IO_Out32(instPtr->config.baseAddr + addr, value)
@@ -296,3 +304,5 @@ void TimeCtrl_CalculateTimeGap(const TIME_WORD *a, const TIME_WORD *b, TIME_WORD
 	gap->frac_part = (TIME_FRAC)(timeDiff % TIME_FRAC_MAX);
 	gap->frac_part = (TIME_INT)(timeDiff / TIME_FRAC_MAX);
 }
+
+/** @} TimeController_Driver*/

df_datalink_sp/src/time_ctrl/time_ctrl.h

@@ -1,19 +1,20 @@
 /*****************************************************************************/
 /**
- * Description: A simplified version of timesync for datalink 814 (Dijian)
- *
- * Date: 2023-12-20-04 16:32
- * LastEditors: Fan Hao
- * LastEditTime: 2023-12-20 16:32
- * Revisions: Rev 0.0
- * History:
- * [2023-12-20]: Initial version.
- *
- * Copyright(c) 2021 Beijing Institute of Technology.
- * Lab of Communication and Networking
+ * @file time_ctrl.h
+ * @author FanHao (hao_fan_bit_ee@163.com)
+ * @brief Time sync controller driver header file.
+ * @version 0.0
+ * @date 2023-12-20
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
  *
  ******************************************************************************/
 
+/**
+ * @defgroup TimeController_Driver
+ * @{
+ */
+
 #ifndef TIME_CTRL_H_
 #define TIME_CTRL_H_
 
@@ -23,30 +24,44 @@
 #define TIME_FRAC_MAX 500000 // how many 10ns in a 5ms
 /***************** Macros (Inline Functions) Definitions *********************/
 /**************************** Type Definitions *******************************/
+/**
+ * @enum TIMECTRL_ADJ_TYPE
+ * @brief defines the time adjustment methods
+ */
 typedef enum
 {
-	TM_ADJ_NONE = 0,
-	TM_ADJ_ADD = 1,
-	TM_ADJ_SET = 2
+	TM_ADJ_NONE = 0, ///< none
+	TM_ADJ_ADD = 1, ///< adjust time by add
+	TM_ADJ_SET = 2  ///< adjust time by set
 } TIMECTRL_ADJ_TYPE;
 
 typedef uint32_t TIME_FRAC;
 typedef uint32_t TIME_INT;
 
+/**
+ * @struct TIME_WORD
+ * @brief Time controller time word
+ */
 typedef struct
 {
-	/* 5ms each LSB */
-	TIME_INT int_part;
-	/* 10ns each LSB */
-	TIME_FRAC frac_part;
+	TIME_INT int_part; ///< 5ms each LSB
+	TIME_FRAC frac_part; ///< 10ns each LSB
 } TIME_WORD;
 
+/**
+ * @struct TMC_CONFIG
+ * @brief TmcConfig holds the initialization parameters of time controller
+ */
 typedef struct
 {
 	uintptr_t baseAddr;
 	uint32_t reset; // time for reset (unit: us)
 } TMC_CONFIG;
 
+/**
+ * @struct TMC_INST
+ * @brief An instance struct of time controller
+ */
 typedef struct
 {
 	TMC_CONFIG config;
@@ -72,3 +87,5 @@ void TimeCtrl_TimeAdjust(TMC_INST *instPtr, const TIME_WORD *tmWord, TIMECTRL_AD
 void TimeCtrl_CalculateTimeGap(const TIME_WORD *a, const TIME_WORD *b, TIME_WORD *gap);
 
 #endif /* TIME_SYNC_H_ */
+
+/** @} */

df_datalink_sp/src/util/circ_queue.c

@@ -1,34 +1,25 @@
 /*****************************************************************************/
 /**
- * Description: A simple circular FIFO bounded queue
+ * @file circ_queue.c
+ * @author FanHao (hao_fan_bit_ee@163.com)
+ * @brief A simple circular FIFO bounded queue
+ * @version 0.1
+ * @date 2023-02-23
+ * @note Forked from https://github.com/chrismerck/rpa_queue.git
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
  *
- * Author: Fan Hao
- * Date: 2023-02-23 10:29
- * LastEditors: Fan Hao
- * LastEditTime: 2023-02-23 13:18
- * Revisions: Rev 0.0
- * History:
- * [2023-02-23]: Initial Version.
- *
- * Copyright(c) 2023 Beijing Institute of Technology.
- * Lab of Communication and Networking
- * NOTE: Forked from https://github.com/chrismerck/rpa_queue.git
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
  ******************************************************************************/
 
+/**
+ * @addtogroup Utility
+ * @{
+ */
+
+/**
+ * @addtogroup CircularQueue
+ * @{
+ */
 #include "circ_queue.h"
 #include "common.h"
 #include <stdio.h>
@@ -56,7 +47,7 @@ void CircQueueFree(CIRC_QUEUE *queue)
 }
 
 /**
- * Initialize the CIRC_QUEUE.
+ * @brief Initialize the CIRC_QUEUE.
  */
 bool CircQueueCreate(CIRC_QUEUE **q, uint32_t queueCapacity)
 {
@@ -87,7 +78,7 @@ error:
 }
 
 /**
- * Push new data onto the queue.
+ * @brief Push new data onto the queue.
  */
 bool CircQueuePush(CIRC_QUEUE *queue, void *data)
 {
@@ -110,7 +101,7 @@ bool CircQueuePush(CIRC_QUEUE *queue, void *data)
 }
 
 /**
- * Return current number of element in queue.
+ * @brief Return current number of element in queue.
  */
 inline uint32_t CircQueueSize(CIRC_QUEUE *queue)
 {
@@ -118,7 +109,7 @@ inline uint32_t CircQueueSize(CIRC_QUEUE *queue)
 }
 
 /**
- * Retrieves the next item from the queue.
+ * @brief Retrieves the next item from the queue.
  */
 bool CircQueuePop(CIRC_QUEUE *queue, void **data)
 {
@@ -139,3 +130,5 @@ bool CircQueuePop(CIRC_QUEUE *queue, void **data)
 	}
 	return true;
 }
+/** @} CircularQueue*/
+/** @} Utility*/

df_datalink_sp/src/util/clist.c

@@ -1,3 +1,25 @@
+/*****************************************************************************/
+/**
+ * @file clist.c
+ * @author FanHao (hao_fan_bit_ee@163.com)
+ * @brief A basic list data structure
+ * @version 0.1
+ * @date 2023-02-23
+ * @note Forked from https://github.com/clibs/list
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
+ *
+ ******************************************************************************/
+
+/**
+ * @addtogroup Utility
+ * @{
+ */
+
+/**
+ * @addtogroup cList
+ * @{
+ */
 #ifndef LIST_MALLOC
 #define LIST_MALLOC malloc
 #endif
@@ -6,19 +28,12 @@
 #define LIST_FREE free
 #endif
 
-//
-// list.c
-//
-// Copyright (c) 2010 TJ Holowaychuk <[email protected]>
-//
-
 #include <stdint.h>
 #include "clist.h"
 
-/*
- * Allocates a new clist_node_t. NULL on failure.
+/**
+ * @brief a new clist_node_t. NULL on failure.
  */
-
 clist_node_t *
 clist_node_new(void *val)
 {
@@ -31,10 +46,9 @@ clist_node_new(void *val)
 	return self;
 }
 
-/*
- * Allocate a new clist_t. NULL on failure.
+/**
+ * @brief Allocate a new clist_t. NULL on failure.
  */
-
 clist_t *
 clist_new(void)
 {
@@ -49,11 +63,10 @@ clist_new(void)
 	return self;
 }
 
-/*
- * Remove all the node in list.
- * @self: Pointer to the list
+/**
+ * @brief Remove all the node in list.
+ * @param self: Pointer to the list
  */
-
 void clist_clear(clist_t *self)
 {
 	clist_node_t *next;
@@ -71,24 +84,21 @@ void clist_clear(clist_t *self)
 	self->head = NULL;
 }
 
-/*
- * Free the list.
- * @self: Pointer to the list
+/**
+ * @brief Free the list.
+ * @param self: Pointer to the list
  */
-
 void clist_destroy(clist_t *self)
 {
 	clist_clear(self);
 	LIST_FREE(self);
 }
 
-/*
- * Append the given node to the list
- * and return the node, NULL on failure.
- * @self: Pointer to the list for popping node
- * @node: the node to push
+/**
+ * @brief Append the given node to the list and return the node, NULL on failure.
+ * @param self: Pointer to the list for popping node
+ * @param node: the node to push
  */
-
 clist_node_t *
 clist_rpush(clist_t *self, clist_node_t *node)
 {
@@ -112,9 +122,9 @@ clist_rpush(clist_t *self, clist_node_t *node)
 	return node;
 }
 
-/*
- * Return / detach the last node in the list, or NULL.
- * @self: Pointer to the list for popping node
+/**
+ * @brief Return / detach the last node in the list, or NULL.
+ * @param self: Pointer to the list for popping node
  */
 
 clist_node_t *
@@ -138,9 +148,9 @@ clist_rpop(clist_t *self)
 	return node;
 }
 
-/*
- * Return / detach the first node in the list, or NULL.
- * @self: Pointer to the list for popping node
+/**
+ * @brief Return / detach the first node in the list, or NULL.
+ * @param self: Pointer to the list for popping node
  */
 
 clist_node_t *
@@ -164,11 +174,10 @@ clist_lpop(clist_t *self)
 	return node;
 }
 
-/*
- * Prepend the given node to the list
- * and return the node, NULL on failure.
- * @self: Pointer to the list for pushing node
- * @node: the node to push
+/**
+ * @brief Prepend the given node to the list and return the node, NULL on failure.
+ * @param self: Pointer to the list for pushing node
+ * @param node: the node to push
  */
 
 clist_node_t *
@@ -194,10 +203,10 @@ clist_lpush(clist_t *self, clist_node_t *node)
 	return node;
 }
 
-/*
- * Return the node associated to val or NULL.
- * @self: Pointer to the list for finding given value
- * @val: Value to find
+/**
+ * @brief Return the node associated to val or NULL.
+ * @param self: Pointer to the list for finding given value
+ * @param val: Value to find
  */
 
 clist_node_t *
@@ -230,10 +239,10 @@ clist_find(clist_t *self, void *val)
 	return NULL;
 }
 
-/*
- * Return the node at the given index or NULL.
- * @self: Pointer to the list for finding given index
- * @index: the index of node in the list
+/**
+ * @brief Return the node at the given index or NULL.
+ * @param self: Pointer to the list for finding given index
+ * @param index: the index of node in the list
  */
 
 clist_node_t *
@@ -260,10 +269,10 @@ clist_at(clist_t *self, int index)
 	return NULL;
 }
 
-/*
- * Remove the given node from the list, freeing it and it's value.
- * @self: Pointer to the list to delete a node
- * @node: Pointer the node to be deleted
+/**
+ * @brief Remove the given node from the list, freeing it and it's value.
+ * @param self: Pointer to the list to delete a node
+ * @param node: Pointer the node to be deleted
  */
 
 void clist_remove(clist_t *self, clist_node_t *node)
@@ -283,8 +292,8 @@ void clist_remove(clist_t *self, clist_node_t *node)
 	--self->len;
 }
 
-/*
- * Allocate a new clist_iterator_t. NULL on failure.
+/**
+ * @brief Allocate a new clist_iterator_t. NULL on failure.\n
  * Accepts a direction, which may be LIST_HEAD or LIST_TAIL.
  */
 
@@ -297,8 +306,8 @@ clist_iterator_new(clist_t *list, clist_direction_t direction)
 	return clist_iterator_new_from_node(node, direction);
 }
 
-/*
- * Allocate a new clist_iterator_t with the given start
+/**
+ * @brief Allocate a new clist_iterator_t with the given start
  * node. NULL on failure.
  */
 
@@ -313,8 +322,8 @@ clist_iterator_new_from_node(clist_node_t *node, clist_direction_t direction)
 	return self;
 }
 
-/*
- * Return the next clist_node_t or NULL when no more
+/**
+ * @brief Return the next clist_node_t or NULL when no more
  * nodes remain in the list.
  */
 
@@ -331,8 +340,8 @@ clist_iterator_next(clist_iterator_t *self)
 	return curr;
 }
 
-/*
- * Free the list iterator.
+/**
+ * @brief Free the list iterator.
  */
 
 void clist_iterator_destroy(clist_iterator_t *self)
@@ -340,3 +349,5 @@ void clist_iterator_destroy(clist_iterator_t *self)
 	LIST_FREE(self);
 	self = NULL;
 }
+/** @} cList*/
+/** @} Utility*/

df_datalink_sp/src/util/common.c

@@ -10,11 +10,14 @@
  * [2022-07-16]: New branch for Dijian.
  * [2021-11-16]: Initial version.
  *
- * Copyright(c) 2021 Beijing Institute of Technology.
+ * Copyright(c) 2024 Beijing Institute of Technology.
  * Lab of Communication and Networking
  *
  ******************************************************************************/
-
+/**
+ * @addtogroup COMMON_MACRO
+ * @{
+ */
 /***************************** Include Files *********************************/
 #include "common.h"
 #include "error.h"
@@ -44,3 +47,5 @@ void AppAssert(const char *file, int line)
 	while (1)
 		;
 }
+
+/** @} */

df_datalink_sp/src/util/crc.c

@@ -11,11 +11,14 @@
  * [2022-07-17]: Add CRC16_0x8005 CRC8_0x31.
  * [2022-01-06]: Initial verion (Basic CRC-16).
  *
- * Copyright(c) 2021 Beijing Institute of Technology.
+ * Copyright(c) 2024 Beijing Institute of Technology.
  * Lab of Communication and Networking
  *
  ******************************************************************************/
-
+/**
+ * @addtogroup Utility
+ * @{
+ */
 #include "util.h"
 #include "error.h"
 
@@ -437,3 +440,5 @@ bool crc16_check(uint8_t *buffPtr, uint32_t dataLen, uint32_t crcOffset, uint16_
 		return false;
 	}
 }
+
+/** @}*/

df_datalink_sp/src/util/list.c

@@ -1,5 +1,5 @@
 /*******************************************************************************
-*   @file   list.c
+ *   @file   list.c
  *   @brief  List library implementation
  *   @author Mihail Chindris (mihail.chindris@analog.com)
 ********************************************************************************

df_datalink_sp/src/util/util.c

@@ -1,15 +1,30 @@
-/******************************************************************************/
+/*****************************************************************************/
+/**
+ * @file util.c
+ * @author FanHao (hao_fan_bit_ee@163.com)
+ * @brief Utility functions implementation file
+ * @version 0.0
+ * @date 2023-05-06
+ *
+ * @copyright Copyright(c) 2024 Beijing Institute of Technology.\n
+ * Lab of Communication and Network
+ *
+ ******************************************************************************/
+
 /***************************** Include Files **********************************/
-/******************************************************************************/
+
+/**
+ * @addtogroup Utility
+ * @{
+ */
+
 #include <string.h>
 #include <stdlib.h>
 // #include <arm_acle.h>
 #include "util.h"
 #include "error.h"
 
-/******************************************************************************/
 /************************** Functions Implementation **************************/
-/******************************************************************************/
 #ifdef __BITSWAP_TABLE
 static uint8_t byte_flipLR[256] =
 {
@@ -48,17 +63,26 @@ static uint8_t byte_flipLR[256] =
 };
 #endif
 
+/**
+ * @brief Write a 32bit word to specific memory address
+ */
 inline void IO_Out32(uintptr_t addr, uint32_t value)
 {
 	volatile uint32_t *localAddr = (volatile uint32_t *)addr;
 	*localAddr = value;
 }
 
+/**
+ * @brief Read a 32bit word from specific memory address
+ */
 inline uint32_t IO_In32(uintptr_t addr)
 {
 	return *(volatile uint32_t *)addr;
 }
 
+/**
+ * @brief Swap a byte word bit-wise
+ */
 uint8_t byte_bit_swap(uint8_t byte)
 {
 #ifdef __BITSWAP_TABLE
@@ -68,6 +92,9 @@ uint8_t byte_bit_swap(uint8_t byte)
 #endif
 }
 
+/**
+ * @brief Swap 32bit word bit-wise
+ */
 uint32_t word_bit_swap(uint32_t word)
 {
 #ifdef __BITSWAP_TABLE
@@ -85,6 +112,9 @@ uint32_t word_bit_swap(uint32_t word)
 #endif
 }
 
+/**
+ * @brief Count ones in an 32bit word
+ */
 uint32_t count_ones(uint32_t word)
 {
 #ifdef __GNUC__
@@ -101,13 +131,16 @@ uint32_t count_ones(uint32_t word)
 #endif
 }
 
+/**
+ * @brief Convert fix ;oint number to float number
+ */
 double fix2double(int32_t val, uint8_t frac_bits)
 {
 	return (((double)val) / (BIT(frac_bits)));
 }
 
 /**
- * Find first set bit in word.
+ * @brief Find first set bit in word.
  */
 uint32_t find_first_set_bit(uint32_t word)
 {
@@ -136,7 +169,7 @@ uint32_t find_first_set_bit(uint32_t word)
 }
 
 /**
- * Find last set bit in word.
+ * @brief Find last set bit in word.
  */
 uint32_t find_last_set_bit(uint32_t word)
 {
@@ -166,7 +199,7 @@ uint32_t find_last_set_bit(uint32_t word)
 }
 
 /**
- * Locate the closest element in an array.
+ * @brief Locate the closest element in an array.
  */
 uint32_t find_closest(int32_t val,
 					  const int32_t *array,
@@ -189,7 +222,7 @@ uint32_t find_closest(int32_t val,
 }
 
 /**
- * Shift the value and apply the specified mask.
+ * @brief Shift the value and apply the specified mask.
  */
 uint32_t field_prep(uint32_t mask, uint32_t val)
 {
@@ -197,7 +230,7 @@ uint32_t field_prep(uint32_t mask, uint32_t val)
 }
 
 /**
- * Get a field specified by a mask from a word.
+ * @brief Get a field specified by a mask from a word.
  */
 uint32_t field_get(uint32_t mask, uint32_t word)
 {
@@ -205,7 +238,7 @@ uint32_t field_get(uint32_t mask, uint32_t word)
 }
 
 /**
- * Log base 2 of the given number.
+ * @brief Log base 2 of the given number.
  */
 int32_t log_base_2(uint32_t x)
 {
@@ -213,7 +246,7 @@ int32_t log_base_2(uint32_t x)
 }
 
 /**
- * Find greatest common divisor of the given two numbers.
+ * @brief Find greatest common divisor of the given two numbers.
  */
 uint32_t greatest_common_divisor(uint32_t a,
 								 uint32_t b)
@@ -232,7 +265,7 @@ uint32_t greatest_common_divisor(uint32_t a,
 }
 
 /**
- * Calculate best rational approximation for a given fraction.
+ * @brief Calculate best rational approximation for a given fraction.
  */
 void rational_best_approximation(uint32_t given_numerator,
 								 uint32_t given_denominator,
@@ -257,7 +290,7 @@ void rational_best_approximation(uint32_t given_numerator,
 }
 
 /**
- * Calculate the number of set bits.
+ * @brief Calculate the number of set bits.
  */
 uint32_t hweight8(uint32_t word)
 {
@@ -274,7 +307,7 @@ uint32_t hweight8(uint32_t word)
 }
 
 /**
- * Calculate the quotient and the remainder of an integer division.
+ * @brief Calculate the quotient and the remainder of an integer division.
  */
 uint64_t do_div(uint64_t *n,
 				uint64_t base)
@@ -288,7 +321,7 @@ uint64_t do_div(uint64_t *n,
 }
 
 /**
- * Unsigned 64bit divide with 64bit divisor and remainder
+ * @brief Unsigned 64bit divide with 64bit divisor and remainder
  */
 uint64_t div64_u64_rem(uint64_t dividend, uint64_t divisor, uint64_t *remainder)
 {
@@ -298,7 +331,7 @@ uint64_t div64_u64_rem(uint64_t dividend, uint64_t divisor, uint64_t *remainder)
 }
 
 /**
- * Unsigned 64bit divide with 32bit divisor with remainder
+ * @brief Unsigned 64bit divide with 32bit divisor with remainder
  */
 uint64_t div_u64_rem(uint64_t dividend, uint32_t divisor, uint32_t *remainder)
 {
@@ -308,7 +341,7 @@ uint64_t div_u64_rem(uint64_t dividend, uint32_t divisor, uint32_t *remainder)
 }
 
 /**
- * Signed 64bit divide with 32bit divisor with remainder
+ * @brief Signed 64bit divide with 32bit divisor with remainder
  */
 int64_t div_s64_rem(int64_t dividend, int32_t divisor, int32_t *remainder)
 {
@@ -317,7 +350,7 @@ int64_t div_s64_rem(int64_t dividend, int32_t divisor, int32_t *remainder)
 }
 
 /**
- * Unsigned 64bit divide with 32bit divisor
+ * @brief Unsigned 64bit divide with 32bit divisor
  */
 uint64_t div_u64(uint64_t dividend, uint32_t divisor)
 {
@@ -327,7 +360,7 @@ uint64_t div_u64(uint64_t dividend, uint32_t divisor)
 }
 
 /**
- * Signed 64bit divide with 32bit divisor
+ * @brief Signed 64bit divide with 32bit divisor
  */
 int64_t div_s64(int64_t dividend, int32_t divisor)
 {
@@ -336,7 +369,7 @@ int64_t div_s64(int64_t dividend, int32_t divisor)
 }
 
 /**
- * Converts from string to int32_t
+ * @brief Converts from string to int32_t
  * @param *str
  * @return int32_t
  */
@@ -352,7 +385,7 @@ int32_t str_to_int32(const char *str)
 }
 
 /**
- * Converts from string to uint32_t
+ * @brief Converts from string to uint32_t
  * @param *str
  * @return uint32_t
  */
@@ -366,3 +399,5 @@ uint32_t srt_to_uint32(const char *str)
 	else
 		return value;
 }
+
+/** @} */

df_datalink_sp/unit_test/linklayer_emulate_unit_test.c

@@ -68,7 +68,7 @@ void linklayer_setup(void)
 	ASSERT_EQUAL(SUCCESS, Status);
 	Status = TimeCtrl_Init(&tmcInstPtr, &tmcConfig);
 	ASSERT_EQUAL(SUCCESS, Status);
-	Status = Phy_InstInit(&phyInstPtr, &l1Config);
+	Status = Phy_Init(&phyInstPtr, &l1Config);
 	ASSERT_EQUAL(SUCCESS, Status);
 
 	// Update l2 config