forked from 0xha0/df_datalink
500 lines
15 KiB
C
500 lines
15 KiB
C
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <stdint.h>
|
|
#include "common.h"
|
|
#include "system_monitor.h"
|
|
|
|
#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
|
|
|
|
typedef struct
|
|
{
|
|
uint8_t latest;
|
|
uint8_t rBusy;
|
|
uint8_t wBusy;
|
|
} PINGPONG;
|
|
|
|
typedef struct
|
|
{
|
|
PINGPONG recvCtrl;
|
|
PAYLOAD recv[2];
|
|
PINGPONG sendCtrl;
|
|
PAYLOAD send[2];
|
|
PINGPONG sysInfoCtrl;
|
|
SYSINFO sysInfo[2];
|
|
PINGPONG linkLogCtrl;
|
|
LINKLOG linkLog[2];
|
|
PINGPONG phyLogCtrl;
|
|
PHYLOG phyLog[2];
|
|
PINGPONG hwStateCtrl;
|
|
HWSTATE hwState[2];
|
|
} SYSMONITOR;
|
|
|
|
static SYSMONITOR *sysMonitorInst;
|
|
|
|
uint8_t GetWritable(PINGPONG ctrllor);
|
|
uint8_t GetReadable(PINGPONG ctrllor);
|
|
|
|
inline 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 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);
|
|
}
|
|
|
|
// System monitor initialise
|
|
int32_t SysMonitor_Init(void)
|
|
{
|
|
sysMonitorInst = calloc(1, sizeof(SYSMONITOR));
|
|
if (sysMonitorInst == NULL)
|
|
{
|
|
return ENOMEM;
|
|
}
|
|
memset(&(sysMonitorInst->recvCtrl), BUFF_NONE, sizeof(PINGPONG));
|
|
memset(&(sysMonitorInst->sendCtrl), BUFF_NONE, sizeof(PINGPONG));
|
|
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));
|
|
|
|
sysMonitorInst->recv[0].dataId = DATA_ID_NONE;
|
|
sysMonitorInst->recv[1].dataId = DATA_ID_NONE;
|
|
sysMonitorInst->send[0].dataId = DATA_ID_NONE;
|
|
sysMonitorInst->send[1].dataId = DATA_ID_NONE;
|
|
return SUCCESS;
|
|
}
|
|
|
|
// System monitor initialise
|
|
void SysMonitor_Destroy(void)
|
|
{
|
|
free(sysMonitorInst);
|
|
}
|
|
|
|
// @System Info
|
|
/**
|
|
* Update system info.
|
|
*/
|
|
void SysMonitor_UpdateSysinfo(const SYSINFO *info)
|
|
{
|
|
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;
|
|
}
|
|
|
|
/**
|
|
* Update system info by raw data.
|
|
*/
|
|
void SysMonitor_UpdateSysinfoRaw(const uint8_t *buff)
|
|
{
|
|
ASSERT(sysMonitorInst != NULL);
|
|
uint8_t buffIndx;
|
|
buffIndx = GetWritable(sysMonitorInst->sysInfoCtrl);
|
|
sysMonitorInst->sysInfoCtrl.wBusy = buffIndx;
|
|
// Decapsulate Systeminfo
|
|
SYSINFO *infoEntry = &(sysMonitorInst->sysInfo[buffIndx]);
|
|
memcpy(&(infoEntry->psBDS), buff, sizeof(infoEntry->psBDS));
|
|
buff += sizeof(infoEntry->psBDS);
|
|
memcpy(&(infoEntry->pBDS), buff, sizeof(infoEntry->pBDS));
|
|
buff += sizeof(infoEntry->pBDS);
|
|
memcpy(&(infoEntry->psGPS), buff, sizeof(infoEntry->psGPS));
|
|
buff += sizeof(infoEntry->psGPS);
|
|
memcpy(&(infoEntry->pGPS), buff, sizeof(infoEntry->pGPS));
|
|
buff += sizeof(infoEntry->pGPS);
|
|
memcpy(&(infoEntry->tmInd), buff, sizeof(infoEntry->tmInd));
|
|
buff += sizeof(infoEntry->tmInd);
|
|
memcpy(&(infoEntry->tmFly), buff, sizeof(infoEntry->tmFly));
|
|
buff += sizeof(infoEntry->tmFly);
|
|
memcpy(&(infoEntry->stFly), buff, sizeof(infoEntry->stFly));
|
|
buff += sizeof(infoEntry->stFly);
|
|
memcpy(&(infoEntry->posX), buff, sizeof(infoEntry->posX));
|
|
buff += sizeof(infoEntry->posX);
|
|
memcpy(&(infoEntry->posY), buff, sizeof(infoEntry->posY));
|
|
buff += sizeof(infoEntry->posY);
|
|
memcpy(&(infoEntry->posZ), buff, sizeof(infoEntry->posZ));
|
|
buff += sizeof(infoEntry->posZ);
|
|
memcpy(&(infoEntry->vX), buff, sizeof(infoEntry->vX));
|
|
buff += sizeof(infoEntry->vX);
|
|
memcpy(&(infoEntry->vY), buff, sizeof(infoEntry->vY));
|
|
buff += sizeof(infoEntry->vY);
|
|
memcpy(&(infoEntry->vZ), buff, sizeof(infoEntry->vZ));
|
|
buff += sizeof(infoEntry->vZ);
|
|
memcpy(&(infoEntry->pitch), buff, sizeof(infoEntry->pitch));
|
|
buff += sizeof(infoEntry->pitch);
|
|
memcpy(&(infoEntry->yaw), buff, sizeof(infoEntry->yaw));
|
|
buff += sizeof(infoEntry->yaw);
|
|
memcpy(&(infoEntry->roll), buff, sizeof(infoEntry->roll));
|
|
sysMonitorInst->sysInfoCtrl.latest = buffIndx;
|
|
sysMonitorInst->sysInfoCtrl.wBusy = BUFF_NONE;
|
|
}
|
|
|
|
/**
|
|
* Get system info.
|
|
*/
|
|
void SysMonitor_GetSysinfo(SYSINFO *info)
|
|
{
|
|
ASSERT(sysMonitorInst != 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;
|
|
}
|
|
|
|
/**
|
|
* Get system info as raw data.
|
|
*/
|
|
void SysMonitor_GetSysinfoRaw(uint8_t *buff)
|
|
{
|
|
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;
|
|
|
|
// Encapsulate Systeminfo
|
|
SYSINFO *infoEntry = &(sysMonitorInst->sysInfo[buffIndx]);
|
|
memcpy(buff, &(infoEntry->psBDS), sizeof(infoEntry->psBDS));
|
|
buff += sizeof(infoEntry->psBDS);
|
|
memcpy(buff, &(infoEntry->pBDS), sizeof(infoEntry->pBDS));
|
|
buff += sizeof(infoEntry->pBDS);
|
|
memcpy(buff, &(infoEntry->psGPS), sizeof(infoEntry->psGPS));
|
|
buff += sizeof(infoEntry->psGPS);
|
|
memcpy(buff, &(infoEntry->pGPS), sizeof(infoEntry->pGPS));
|
|
buff += sizeof(infoEntry->pGPS);
|
|
memcpy(buff, &(infoEntry->tmInd), sizeof(infoEntry->tmInd));
|
|
buff += sizeof(infoEntry->tmInd);
|
|
memcpy(buff, &(infoEntry->tmFly), sizeof(infoEntry->tmFly));
|
|
buff += sizeof(infoEntry->tmFly);
|
|
memcpy(buff, &(infoEntry->stFly), sizeof(infoEntry->stFly));
|
|
buff += sizeof(infoEntry->stFly);
|
|
memcpy(buff, &(infoEntry->posX), sizeof(infoEntry->posX));
|
|
buff += sizeof(infoEntry->posX);
|
|
memcpy(buff, &(infoEntry->posY), sizeof(infoEntry->posY));
|
|
buff += sizeof(infoEntry->posY);
|
|
memcpy(buff, &(infoEntry->posZ), sizeof(infoEntry->posZ));
|
|
buff += sizeof(infoEntry->posZ);
|
|
memcpy(buff, &(infoEntry->vX), sizeof(infoEntry->vX));
|
|
buff += sizeof(infoEntry->vX);
|
|
memcpy(buff, &(infoEntry->vY), sizeof(infoEntry->vY));
|
|
buff += sizeof(infoEntry->vY);
|
|
memcpy(buff, &(infoEntry->vZ), sizeof(infoEntry->vZ));
|
|
buff += sizeof(infoEntry->vZ);
|
|
memcpy(buff, &(infoEntry->pitch), sizeof(infoEntry->pitch));
|
|
buff += sizeof(infoEntry->pitch);
|
|
memcpy(buff, &(infoEntry->yaw), sizeof(infoEntry->yaw));
|
|
buff += sizeof(infoEntry->yaw);
|
|
memcpy(buff, &(infoEntry->roll), sizeof(infoEntry->roll));
|
|
sysMonitorInst->sysInfoCtrl.rBusy = buffIndex_old;
|
|
}
|
|
|
|
// @Send Payload
|
|
/**
|
|
* Update send payload by raw data.
|
|
*/
|
|
void SysMonitor_UpdateSendPayloadRaw(const uint8_t *buff, size_t len)
|
|
{
|
|
ASSERT(sysMonitorInst != NULL);
|
|
uint8_t buffIndx;
|
|
buffIndx = GetWritable(sysMonitorInst->sendCtrl);
|
|
sysMonitorInst->sendCtrl.wBusy = buffIndx;
|
|
memcpy(sysMonitorInst->send[buffIndx].data, buff, len);
|
|
sysMonitorInst->send[buffIndx].dataId++;
|
|
sysMonitorInst->sendCtrl.latest = buffIndx;
|
|
sysMonitorInst->sendCtrl.wBusy = BUFF_NONE;
|
|
}
|
|
|
|
/**
|
|
* Get the latest send payload as raw data.
|
|
*/
|
|
void SysMonitor_GetSendPayloadRaw(uint8_t *buff, uint32_t *id, size_t len)
|
|
{
|
|
ASSERT(sysMonitorInst != NULL);
|
|
uint8_t buffIndx, buffIndex_old;
|
|
buffIndex_old = sysMonitorInst->sendCtrl.rBusy;
|
|
if (buffIndex_old != BUFF_NONE)
|
|
buffIndx = buffIndex_old; // Keep it busy
|
|
else
|
|
buffIndx = GetReadable(sysMonitorInst->sendCtrl);
|
|
sysMonitorInst->sendCtrl.rBusy = buffIndx;
|
|
if (sysMonitorInst->send[buffIndx].dataId != DATA_ID_NONE)
|
|
{
|
|
memcpy(buff, sysMonitorInst->send[buffIndx].data, len);
|
|
}
|
|
*id = sysMonitorInst->send[buffIndx].dataId;
|
|
sysMonitorInst->sendCtrl.rBusy = buffIndex_old;
|
|
}
|
|
|
|
// @Receive Payload
|
|
/**
|
|
* Update receive payload by raw data.
|
|
*/
|
|
void SysMonitor_UpdateRecvPayloadRaw(const uint8_t *buff, size_t len)
|
|
{
|
|
ASSERT(sysMonitorInst != NULL);
|
|
uint8_t buffIndx;
|
|
buffIndx = GetWritable(sysMonitorInst->recvCtrl);
|
|
sysMonitorInst->recvCtrl.wBusy = buffIndx;
|
|
memcpy(sysMonitorInst->recv[buffIndx].data, buff, len);
|
|
sysMonitorInst->recv[buffIndx].dataId++;
|
|
sysMonitorInst->recvCtrl.latest = buffIndx;
|
|
sysMonitorInst->recvCtrl.wBusy = BUFF_NONE;
|
|
}
|
|
|
|
/**
|
|
* Get the latest receive payload as raw data.
|
|
*/
|
|
void SysMonitor_GetRecvPayloadRaw(uint8_t *buff, uint32_t *id, size_t len)
|
|
{
|
|
ASSERT(sysMonitorInst != NULL);
|
|
uint8_t buffIndx, buffIndex_old;
|
|
buffIndex_old = sysMonitorInst->recvCtrl.rBusy;
|
|
if (buffIndex_old != BUFF_NONE)
|
|
buffIndx = buffIndex_old; // Keep it busy
|
|
else
|
|
buffIndx = GetReadable(sysMonitorInst->recvCtrl);
|
|
sysMonitorInst->recvCtrl.rBusy = buffIndx;
|
|
if (sysMonitorInst->recv[buffIndx].dataId != DATA_ID_NONE)
|
|
{
|
|
memcpy(buff, sysMonitorInst->recv[buffIndx].data, len);
|
|
}
|
|
*id = sysMonitorInst->recv[buffIndx].dataId;
|
|
sysMonitorInst->recvCtrl.rBusy = buffIndex_old;
|
|
}
|
|
|
|
// @Link layer log
|
|
/**
|
|
* Update link layer log
|
|
*/
|
|
void SysMonitor_UpdateLinklayerLog(const LINKLOG *log)
|
|
{
|
|
ASSERT(sysMonitorInst != 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;
|
|
}
|
|
|
|
/**
|
|
* Get the latest link layer log
|
|
*/
|
|
void SysMonitor_GetLinklayerLog(LINKLOG *log)
|
|
{
|
|
ASSERT(sysMonitorInst != 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;
|
|
}
|
|
|
|
/**
|
|
* Get the latest link layer log as raw data
|
|
*/
|
|
void SysMonitor_GetLinklayerLogRaw(uint8_t *buff)
|
|
{
|
|
ASSERT(sysMonitorInst != 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;
|
|
|
|
// Encapsulate log
|
|
LINKLOG *logEntry = &(sysMonitorInst->linkLog[buffIndx]);
|
|
|
|
// TODO:
|
|
|
|
sysMonitorInst->linkLogCtrl.rBusy = buffIndex_old;
|
|
}
|
|
|
|
// @Physical layer log
|
|
/**
|
|
* Update physical layer log
|
|
*/
|
|
void SysMonitor_UpdatePhysicalLayerLog(const PHYLOG *log)
|
|
{
|
|
ASSERT(sysMonitorInst != 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;
|
|
}
|
|
|
|
/**
|
|
* Get the latest physical layer log
|
|
*/
|
|
void SysMonitor_GetPhysicalLayerLog(PHYLOG *log)
|
|
{
|
|
ASSERT(sysMonitorInst != 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;
|
|
}
|
|
|
|
/**
|
|
* Get the latest physical layer log as raw data
|
|
*/
|
|
void SysMonitor_GetPhysicalLayerLogRaw(uint8_t *buff)
|
|
{
|
|
ASSERT(sysMonitorInst != 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;
|
|
|
|
// Encapsulate log
|
|
PHYLOG *logEntry = &(sysMonitorInst->phyLog[buffIndx]);
|
|
|
|
// TODO:
|
|
|
|
sysMonitorInst->phyLogCtrl.rBusy = buffIndex_old;
|
|
}
|
|
|
|
// @Hardware state
|
|
/**
|
|
* Log hardware running status.
|
|
*/
|
|
void SysMonitor_UpdateHardwareStatus(const HWSTATE *state)
|
|
{
|
|
ASSERT(sysMonitorInst != 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;
|
|
}
|
|
|
|
/**
|
|
* Get the latest hardware running status.
|
|
*/
|
|
void SysMonitor_GetHardwareStatus(HWSTATE *state)
|
|
{
|
|
ASSERT(sysMonitorInst != NULL);
|
|
uint8_t buffIndx, buffIndex_old;
|
|
buffIndex_old = sysMonitorInst->hwStateCtrl.rBusy;
|
|
if (buffIndex_old != BUFF_NONE)
|
|
buffIndx = buffIndex_old; // Keep it busy
|
|
else
|
|
buffIndx = GetReadable(sysMonitorInst->hwStateCtrl);
|
|
sysMonitorInst->hwStateCtrl.rBusy = buffIndx;
|
|
memcpy(state, &(sysMonitorInst->hwState[buffIndx]), sizeof(HWSTATE));
|
|
sysMonitorInst->hwStateCtrl.rBusy = buffIndex_old;
|
|
}
|
|
|
|
/**
|
|
* Get the latest hardware running status as raw data.
|
|
*/
|
|
void SysMonitor_GetHardwareStatusRaw(uint8_t *buff)
|
|
{
|
|
ASSERT(sysMonitorInst != NULL);
|
|
uint8_t buffIndx, buffIndex_old;
|
|
buffIndex_old = sysMonitorInst->hwStateCtrl.rBusy;
|
|
if (buffIndex_old != BUFF_NONE)
|
|
buffIndx = buffIndex_old; // Keep it busy
|
|
else
|
|
buffIndx = GetReadable(sysMonitorInst->hwStateCtrl);
|
|
sysMonitorInst->hwStateCtrl.rBusy = buffIndx;
|
|
|
|
// Encapsulate log
|
|
HWSTATE *logEntry = &(sysMonitorInst->hwState[buffIndx]);
|
|
|
|
memcpy(buff, &(logEntry->spPsVolt), sizeof(logEntry->spPsVolt));
|
|
buff += sizeof(logEntry->spPsVolt);
|
|
memcpy(buff, &(logEntry->spPsAuxVolt), sizeof(logEntry->spPsAuxVolt));
|
|
buff += sizeof(logEntry->spPsAuxVolt);
|
|
memcpy(buff, &(logEntry->spDdrVolt), sizeof(logEntry->spDdrVolt));
|
|
buff += sizeof(logEntry->spDdrVolt);
|
|
memcpy(buff, &(logEntry->spPlVolt), sizeof(logEntry->spPlVolt));
|
|
buff += sizeof(logEntry->spPlVolt);
|
|
memcpy(buff, &(logEntry->spPlAuxVolt), sizeof(logEntry->spPlAuxVolt));
|
|
buff += sizeof(logEntry->spPlAuxVolt);
|
|
memcpy(buff, &(logEntry->spBramVolt), sizeof(logEntry->spBramVolt));
|
|
buff += sizeof(logEntry->spBramVolt);
|
|
memcpy(buff, &(logEntry->spTemp), sizeof(logEntry->spTemp));
|
|
buff += sizeof(logEntry->spTemp);
|
|
memcpy(buff, &(logEntry->antVolt), sizeof(logEntry->antVolt));
|
|
buff += sizeof(logEntry->antVolt);
|
|
memcpy(buff, &(logEntry->antTemp), sizeof(logEntry->antTemp));
|
|
buff += sizeof(logEntry->antTemp);
|
|
memcpy(buff, &(logEntry->antPll), sizeof(logEntry->antPll));
|
|
buff += sizeof(logEntry->antPll);
|
|
memcpy(buff, &(logEntry->antMgc0), sizeof(logEntry->antMgc0));
|
|
buff += sizeof(logEntry->antMgc0);
|
|
memcpy(buff, &(logEntry->antMgc1), sizeof(logEntry->antMgc1));
|
|
buff += sizeof(logEntry->antMgc1);
|
|
|
|
sysMonitorInst->hwStateCtrl.rBusy = buffIndex_old;
|
|
}
|
|
|
|
// @System log
|
|
/**
|
|
* Get the latest system running log.
|
|
*/
|
|
void SysMonitor_GetSyslog(SYSLOG *log)
|
|
{
|
|
ASSERT(sysMonitorInst != NULL);
|
|
SysMonitor_GetLinklayerLog(&(log->linkLog));
|
|
SysMonitor_GetPhysicalLayerLog(&(log->phyLog));
|
|
SysMonitor_GetHardwareStatus(&(log->hwSate));
|
|
}
|
|
|
|
/**
|
|
* Get the latest system running log as raw data.
|
|
*/
|
|
void SysMonitor_GetSyslogRaw(uint8_t *buff)
|
|
{
|
|
ASSERT(sysMonitorInst != NULL);
|
|
SysMonitor_GetLinklayerLogRaw(buff);
|
|
buff += SLOTLOG_PACK_LEN;
|
|
SysMonitor_GetPhysicalLayerLogRaw(buff);
|
|
buff += SLOTLOG_PACK_LEN;
|
|
SysMonitor_GetHardwareStatusRaw(buff);
|
|
}
|