feat: 移除sysmon文件, 合并至sysbus

2025-06-24 16:53:40 +08:00
parent 044345f597
commit 9c24f66aae
12 changed files with 685 additions and 722 deletions
@@ -27,7 +27,6 @@
 #include "common.h"
 #include "error.h"
 #include "circ_queue.h"
-#include "../system_monitor.h"

 /**
 * @addtogroup SystemBus_Protocol_Routine
@@ -148,7 +147,48 @@
 // My Production Type
 #define MY_PRD_ID PRD_DL_C
 /** @} SystemBus_MSG_Constants*/
+#define BUFF_A 0x00
+#define BUFF_B 0x01
+#define BUFF_NONE 0xFF
+
+#define SYSINFO_PACK_LEN 54	 // bytes
+#define PAYLOAD_PACK_LEN 46	 // bytes
+#define SLOTLOG_PACK_LEN 88	 // bytes
+#define PRTCLLOG_PACK_ELN 24 // bytes
+#define HWSTATE_PACK_ELN 12	 // bytes
+/************************** Data Type Definitions ****************************/
+/**
+ * @struct PINGPONG
+ * @brief PingPing Control
+ */
+typedef struct
+{
+	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
+{
+	SYSMON_CONFIG config; ///< system monitor initialization parameters
+	CIRC_QUEUE *sendQueue;    ///< send queue
+	CIRC_QUEUE *recvQueue;    ///< receive queue
+	PINGPONG sysInfoCtrl;
+	SYSINFO sysInfo[2];
+	PINGPONG linkLogCtrl;
+	LINKLOG linkLog[2];
+	PINGPONG phyLogCtrl;
+	PHYLOG phyLog[2];
+	PINGPONG hwStateCtrl;
+	HWSTATE hwState[2];
+} SYSMONITOR;
 /************************** Function Prototypes ******************************/
+static uint8_t GetWritable(PINGPONG ctrllor);
+static uint8_t GetReadable(PINGPONG ctrllor);
 static int32_t SystemBus_GenSelfTestRsp(SYSBUS *instPtr);
 static int32_t SystemBus_SystemConfig(SYSBUS *instPtr, uint8_t *msg);
 static int32_t SystemBus_Echo(SYSBUS *instPtr, SYSBUS_UART_FRAME *frame);
@@ -160,6 +200,26 @@ static int32_t SystemBus_GenRemoteTestRsp(SYSBUS *instPtr, uint8_t *msg);
 #include "../networking/phy_layer/phy_layer.h"
 extern L2_INST *linkInstPtr;
 extern L2_CONFIG linkConfig;
+extern SYSBUS *sysbusDescPtr;
+static SYSMONITOR *sysMonitorInst;
+
+inline static uint8_t GetWritable(PINGPONG ctrllor)
+{
+	// Allow only one write.
+	ASSERT(ctrllor.wBusy == BUFF_NONE);
+	if (ctrllor.rBusy == BUFF_NONE)
+		return ((ctrllor.latest == BUFF_B) ? BUFF_A : BUFF_B);
+	else
+		return ((ctrllor.rBusy == BUFF_B) ? BUFF_A : BUFF_B);
+}
+
+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);
+	else
+		return ((ctrllor.wBusy == BUFF_B) ? BUFF_A : BUFF_B);
+}

 inline bool SystemBus_IsReqPending(SYSBUS *instPtr)
 {
@@ -178,6 +238,7 @@ inline bool SystemBus_IsTxBusy(SYSBUS *instPtr)
 	ASSERT(instPtr != NULL);
 	return (!instPtr->isTxDone);
 }
+
 inline bool SystemBus_IsRxBusy(SYSBUS *instPtr)
 {
 	ASSERT(instPtr != NULL);
@@ -394,12 +455,12 @@ static int32_t SystemBus_Echo(SYSBUS *instPtr, SYSBUS_UART_FRAME *frame)
 /**
 * @brief   Generate System Bus receive call command response
 */
-int32_t SystemBus_GenRecvRsp(SYSBUS *instPtr, SYSMON_SVC_PAYLOAD *payload)
+int32_t SystemBus_GenRecvRsp(SYSBUS *instPtr, SYSBUS_SVC_PLD *payload)
 {
 	ASSERT(instPtr != NULL);
 	ASSERT(payload != NULL);

-	SYSBUS_UART_FRAME *sysbusRsp = malloc(NORMALIZE_SIZE(sizeof(SYSBUS_UART_FRAME)));
+	SYSBUS_UART_FRAME *sysbusRsp = malloc(sizeof(SYSBUS_UART_FRAME));
 	if (sysbusRsp == NULL)
 	{
 		DBG_ERROR("Failed to allocate memory for Receive Response!\n");
@@ -410,7 +471,7 @@ int32_t SystemBus_GenRecvRsp(SYSBUS *instPtr, SYSMON_SVC_PAYLOAD *payload)

 	sysbusRsp->data[WD_CMD] = CMD_RECV_DATA;
 	sysbusRsp->data[WD_PRD] = MY_PRD_ID;
-	memcpy(sysbusRsp->data + RECV_DATA_ID_OFFSET, payload, sizeof(SYSMON_SVC_PAYLOAD));
+	memcpy(sysbusRsp->data + RECV_DATA_ID_OFFSET, payload, sizeof(SYSBUS_SVC_PLD));

 	if (CircQueuePush(instPtr->txQueue, (void *)sysbusRsp) == false)
 	{
@@ -527,7 +588,7 @@ int32_t SystemBus_HandleCmd(SYSBUS *instPtr)
 	}
 	case CMD_SEND_DATA:
 	{
-		Status = SysMonitor_UpdateSendPayload((SYSMON_SVC_PAYLOAD *)(msg + SEND_DATA_ID_OFFSET));
+		Status = SysMonitor_UpdateSendPayload((SYSBUS_SVC_PLD *)(msg + SEND_DATA_ID_OFFSET));
 		if (Status == SUCCESS)
 		{
 			instPtr->sysbusLog.sendCnt++;
@@ -703,4 +764,302 @@ int32_t SystemBus_RxIntrHandler(SYSBUS *instPtr)
 	return SUCCESS;
 }

+/**
+ * @brief Initialize System monitor
+ *
+ * @return SUCCESS
+ */
+int32_t SysMonitor_Init(SYSMON_CONFIG *config)
+{
+	ASSERT(config != NULL);
+
+	sysMonitorInst = calloc(1, sizeof(SYSMONITOR));
+	if (sysMonitorInst == NULL)
+	{
+		return ENOMEM;
+	}
+
+	memcpy(&(sysMonitorInst->config), config, sizeof(SYSMON_CONFIG));
+	sysMonitorInst->sendQueue = NULL;
+	sysMonitorInst->recvQueue = NULL;
+	memset(&(sysMonitorInst->sysInfoCtrl), BUFF_NONE, sizeof(PINGPONG));
+	memset(&(sysMonitorInst->linkLogCtrl), BUFF_NONE, sizeof(PINGPONG));
+	memset(&(sysMonitorInst->phyLogCtrl), BUFF_NONE, sizeof(PINGPONG));
+	memset(&(sysMonitorInst->hwStateCtrl), BUFF_NONE, sizeof(PINGPONG));
+
+	if (CircQueueCreate(&(sysMonitorInst->sendQueue),
+			sysMonitorInst->config.sendQueueMax) == false)
+	{
+		SysMonitor_Destroy();
+		return ENOMEM;
+	}
+	if (CircQueueCreate(&(sysMonitorInst->recvQueue),
+			sysMonitorInst->config.recvQueueMax) == false)
+	{
+		SysMonitor_Destroy();
+		return ENOMEM;
+	}
+
+	return SUCCESS;
+}
+
+/**
+ * @brief Destroy system monitor release all allocated memory
+ */
+void SysMonitor_Destroy(void)
+{
+	free(sysMonitorInst);
+}
+
+/**
+ * @name SystemInfo_API
+ * @{
+ */
+
+/**
+ * @brief Update system info.
+ *
+ * @param info
+ */
+void SysMonitor_UpdateSysinfo(const SYSINFO *info)
+{
+	ASSERT(info != NULL);
+	uint8_t buffIndx;
+	buffIndx = GetWritable(sysMonitorInst->sysInfoCtrl);
+	sysMonitorInst->sysInfoCtrl.wBusy = buffIndx;
+	memcpy(&(sysMonitorInst->sysInfo[buffIndx]), info, sizeof(SYSINFO));
+	sysMonitorInst->sysInfoCtrl.latest = buffIndx;
+	sysMonitorInst->sysInfoCtrl.wBusy = BUFF_NONE;
+}
+
+/**
+ * @brief Get system info.
+ *
+ * @param info
+ */
+void SysMonitor_GetSysinfo(SYSINFO *info)
+{
+	ASSERT(sysMonitorInst != NULL);
+	ASSERT(info != NULL);
+	uint8_t buffIndx, buffIndex_old;
+	buffIndex_old = sysMonitorInst->sysInfoCtrl.rBusy;
+	if (buffIndex_old != BUFF_NONE)
+		buffIndx = buffIndex_old; // Keep it busy
+	else
+		buffIndx = GetReadable(sysMonitorInst->sysInfoCtrl);
+	sysMonitorInst->sysInfoCtrl.rBusy = buffIndx;
+	memcpy(info, &(sysMonitorInst->sysInfo[buffIndx]), sizeof(SYSINFO));
+	sysMonitorInst->sysInfoCtrl.rBusy = buffIndex_old;
+}
+/** @} SystemInfo_API*/
+
+/**
+ * @name ServicePayload_API
+ * @{
+ */
+
+/**
+ * @brief Update send payload by
+ *
+ * @param payload
+ */
+int32_t SysMonitor_UpdateSendPayload(SYSBUS_SVC_PLD *payload)
+{
+	ASSERT(sysMonitorInst != NULL);
+	ASSERT(payload != NULL);
+
+	// validity check
+	if (payload->dataLen > SYSBUS_PLD_MAX)
+	{
+		DBG_ERROR("Payload length %d exceeds valid range.", payload->dataLen);
+		return EPARAM;
+	}
+
+	// push message into send queue
+	SYSBUS_SVC_PLD *payloadCopy = malloc(sizeof(SYSBUS_SVC_PLD));
+	if (payloadCopy == NULL)
+	{
+		DBG_ERROR("Allocate memory for send payload failed.\n");
+		return ENOMEM;
+	}
+	memcpy(payloadCopy, payload, sizeof(SYSBUS_SVC_PLD));
+	if (CircQueuePush(sysMonitorInst->sendQueue, (void *)payloadCopy) == false)
+	{
+		DBG_WARNING("SystemMonitor::SEND Queue overflowed!\n");
+		free(payloadCopy);
+		return EQUEUE;
+	}
+
+	return SUCCESS;
+}
+
+/**
+ * @brief Get the latest send payload.
+ *
+ * @param payload
+ */
+void SysMonitor_GetSendPayload(SYSBUS_SVC_PLD **payload)
+{
+	ASSERT(sysMonitorInst != NULL);
+	ASSERT(payload != NULL);
+
+	if (CircQueuePop(sysMonitorInst->sendQueue, (void **)payload) == false)
+	{
+		*payload = NULL;
+		DBG_INFO("SystemMonitor::Empty sendQueue, nothing need sent.\n");
+	}
+}
+
+/**
+ * @brief Update receive payload.
+ *
+ * @param payload
+ */
+int32_t SysMonitor_GenRecvRsp(SYSBUS_SVC_PLD *payload)
+{
+	ASSERT(sysMonitorInst != NULL);
+	ASSERT(sysbusDescPtr != NULL);
+	int32_t Status;
+
+	if (payload->dataId == DATA_ID_NONE || payload->dataLen > SYSBUS_PLD_MAX)
+	{
+		DBG_INFO("SystemMonitor::Drop invalid message.\n");
+		return EIGNORE;
+	}
+
+	Status = SystemBus_GenRecvRsp(sysbusDescPtr, payload);
+
+	return Status;
+}
+/** @} ServicePayload_API*/
+
+/**
+ * @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;
+	memcpy(&(sysMonitorInst->linkLog[buffIndx]), log, sizeof(LINKLOG));
+	sysMonitorInst->linkLogCtrl.latest = buffIndx;
+	sysMonitorInst->linkLogCtrl.wBusy = BUFF_NONE;
+}
+
+/**
+ * @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)
+		buffIndx = buffIndex_old; // Keep it busy
+	else
+		buffIndx = GetReadable(sysMonitorInst->linkLogCtrl);
+	sysMonitorInst->linkLogCtrl.rBusy = buffIndx;
+	memcpy(log, &(sysMonitorInst->linkLog[buffIndx]), sizeof(LINKLOG));
+	sysMonitorInst->linkLogCtrl.rBusy = buffIndex_old;
+}
+/** @} Linklayer_Log_API*/
+
+/**
+ * @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;
+	memcpy(&(sysMonitorInst->phyLog[buffIndx]), log, sizeof(PHYLOG));
+	sysMonitorInst->phyLogCtrl.latest = buffIndx;
+	sysMonitorInst->phyLogCtrl.wBusy = BUFF_NONE;
+}
+
+/**
+ * @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)
+		buffIndx = buffIndex_old; // Keep it busy
+	else
+		buffIndx = GetReadable(sysMonitorInst->phyLogCtrl);
+	sysMonitorInst->phyLogCtrl.rBusy = buffIndx;
+	memcpy(log, &(sysMonitorInst->phyLog[buffIndx]), sizeof(PHYLOG));
+	sysMonitorInst->phyLogCtrl.rBusy = buffIndex_old;
+}
+/** @} */
+
+/**
+ * @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;
+	memcpy(&(sysMonitorInst->hwState[buffIndx]), state, sizeof(HWSTATE));
+	sysMonitorInst->hwStateCtrl.latest = buffIndx;
+	sysMonitorInst->hwStateCtrl.wBusy = BUFF_NONE;
+}
+
+/**
+ * @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)
+		buffIndx = buffIndex_old; // Keep it busy
+	else
+		buffIndx = GetReadable(sysMonitorInst->hwStateCtrl);
+	sysMonitorInst->hwStateCtrl.rBusy = buffIndx;
+	memcpy(state, &(sysMonitorInst->hwState[buffIndx]), sizeof(HWSTATE));
+	sysMonitorInst->hwStateCtrl.rBusy = buffIndex_old;
+}
+
+
 /** @} SystemBus*/