0xha0/datalink_repo
2
2
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: 0xha0/datalink_repo:c5730a7fd5e4f925ae9140ff2c66dd423a383ed8
Branches Tags
0xha0/datalink_repo:master
...
compare: 0xha0/datalink_repo:5a46a21d4f866bfbfcbf3f4d83eaeb836f44179c
Branches Tags
0xha0/datalink_repo:master
9 Commits
c5730a7fd5 ... 5a46a21d4f
Author SHA1 Message Date
Gatsby Van 5a46a21d4f adapted to new time control api. 2023-12-22 13:20:57 +08:00
Gatsby Van 3b927140bd add rtt test. 2023-12-22 13:20:23 +08:00
Gatsby Van 80562ca54e update comment. 2023-12-22 13:20:07 +08:00
Gatsby Van dc292a8cd3 add time util function. 2023-12-22 13:19:43 +08:00
Gatsby Van 2a17fa9183 bugfix: reveal physical flag directly. 2023-12-22 13:18:38 +08:00
Gatsby Van 633be421b1 better debug print. 2023-12-22 13:14:37 +08:00
Gatsby Van 26a912dcc0 bugfix: correct record shift mechanism. 2023-12-22 13:14:21 +08:00
Gatsby Van 15ed440200 include stdio 2023-12-22 13:13:26 +08:00
Gatsby Van 6aa2f271f5 enhance coherence. 2023-12-22 10:40:55 +08:00
15 changed files with 953 additions and 914 deletions
Expand all files Collapse all files
datalink814_ge/src/common.h
+2 -1
View File
@@ -20,6 +20,7 @@
#define __COMMON_H_
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include "util/util.h"
#include "error.h"
@@ -35,7 +36,7 @@
/* Stringify */
#define STR(x) #x
#define _814_DEBUG_LEVEL 3
// #define _814_DEBUG_LEVEL 3
#if _814_DEBUG_LEVEL > 0
#define DBG_PRINT(...) printf(__VA_ARGS__)
datalink814_ge/src/linklayer/linklayer814.c
+36 -37
View File
@@ -299,10 +299,6 @@ void L2_FrameStateUpdate(L2_INST* instPtr) {
// Update physical layer status.
// Phy_UpdateState(phyRef);
// Frame types shift (last <- curr <- next)
L2_RcdShift(&(instPtr->frame), L2_NONE_FRAME);
L2_RcdShift(&(instPtr->tor), L2_TOR_SUSPEND);
// Update frame state.
if (Phy_IsFrameValid(phyRef) == false) {
L2_DataAvailUpdate(instPtr, false);
@@ -620,25 +616,25 @@ int32_t Linklayer_Init(L2_INST** instPtr, const L2_CONFIG *config) {
}
// Mpc buff Init
(*instPtr)->mgmtMsgRecvBuff0 = calloc(MSG_STROAGE_BUFF_MAX/sizeof(uint64_t), sizeof(uint64_t));
(*instPtr)->mgmtMsgRecvBuff0 = calloc(L2_MSG_STROAGE_BUFF_MAX/sizeof(uint64_t), sizeof(uint64_t));
if((*instPtr)->mgmtMsgRecvBuff0 == NULL) {
DBG_ERROR("Allocate memory for mgmtMsgRecvBuff0 failed.\n");
Status = EALLOC;
goto error;
}
(*instPtr)->svcMsgRecvBuff0 = calloc(MSG_STROAGE_BUFF_MAX/sizeof(uint64_t), sizeof(uint64_t));
(*instPtr)->svcMsgRecvBuff0 = calloc(L2_MSG_STROAGE_BUFF_MAX/sizeof(uint64_t), sizeof(uint64_t));
if((*instPtr)->svcMsgRecvBuff0 == NULL) {
DBG_ERROR("Allocate memory for svcMsgRecvBuff0 failed.\n");
Status = EALLOC;
goto error;
}
(*instPtr)->mgmtMsgRecvBuff1 = calloc(MSG_STROAGE_BUFF_MAX/sizeof(uint64_t), sizeof(uint64_t));
(*instPtr)->mgmtMsgRecvBuff1 = calloc(L2_MSG_STROAGE_BUFF_MAX/sizeof(uint64_t), sizeof(uint64_t));
if((*instPtr)->mgmtMsgRecvBuff1 == NULL) {
DBG_ERROR("Allocate memory for mgmtMsgRecvBuff1 failed.\n");
Status = EALLOC;
goto error;
}
(*instPtr)->svcMsgRecvBuff1 = calloc(MSG_STROAGE_BUFF_MAX/sizeof(uint64_t), sizeof(uint64_t));
(*instPtr)->svcMsgRecvBuff1 = calloc(L2_MSG_STROAGE_BUFF_MAX/sizeof(uint64_t), sizeof(uint64_t));
if((*instPtr)->svcMsgRecvBuff1 == NULL) {
DBG_ERROR("Allocate memory for svcMsgRecvBuff1 failed.\n");
Status = EALLOC;
@@ -667,8 +663,8 @@ int32_t Linklayer_Init(L2_INST** instPtr, const L2_CONFIG *config) {
(*instPtr)->tor.next = L2_TOR_SUSPEND;
(*instPtr)->rtneConfig.rtneTable = initTable;
(*instPtr)->rtneConfig.rtnePrd = ARRAY_SIZE(initTable);
(*instPtr)->mainState = INIT_STATE;
(*instPtr)->nextState = INIT_STATE;
(*instPtr)->mainState = L2_INIT_STATE;
(*instPtr)->nextState = L2_INIT_STATE;
(*instPtr)->myInfo.nodeId = config->myId;
(*instPtr)->myInfo.clustId = config->clustId;
(*instPtr)->myInfo.headId = config->headId;
@@ -761,8 +757,8 @@ int32_t Linklayer_Reconfig(L2_INST* instPtr, const L2_CONFIG *config) {
instPtr->tor.next = L2_TOR_SUSPEND;
instPtr->rtneConfig.rtneTable = initTable;
instPtr->rtneConfig.rtnePrd = ARRAY_SIZE(initTable);
instPtr->mainState = INIT_STATE;
instPtr->nextState = INIT_STATE;
instPtr->mainState = L2_INIT_STATE;
instPtr->nextState = L2_INIT_STATE;
instPtr->myInfo.nodeId = config->myId;
instPtr->myInfo.clustId = config->clustId;
instPtr->myInfo.headId = config->headId;
@@ -863,11 +859,11 @@ int32_t Linklayer_EventHandler(L2_INST* instPtr, const L2_EVENT* l2Event) {
}
case L2_EV_NET_SETUP_DONE: {
DBG_INFO("Event L2_EV_NETSETUP_DONE asserted....\n");
if(L2_GetNodeType(instPtr) != HEAD_NODE){
if(L2_GetNodeType(instPtr) != L2_NODE_HEAD){
instPtr->cxn2Net = true;
}
else{ // Head node
UpdateMainSate(instPtr, NORMAL_STATE);
UpdateMainSate(instPtr, L2_NORMAL_STATE);
}
break;
}
@@ -895,26 +891,26 @@ int32_t Linklayer_EventHandler(L2_INST* instPtr, const L2_EVENT* l2Event) {
}
case L2_ROUTINE_FINISH: {
DBG_INFO("Event L2_ROUTINE_FINISH asserted....\n");
if(instPtr->nextState == INIT_STATE){
if(instPtr->nextState == L2_INIT_STATE){
// Reset scan net FMS for next scan process.
ScanNet_Reset(instPtr->scanNetFSM);
UpdateMainSate(instPtr, NORMAL_STATE);
UpdateMainSate(instPtr, L2_NORMAL_STATE);
instPtr->rtneConfig.rtneTable = normalTable;
instPtr->rtneConfig.rtnePrd = ARRAY_SIZE(normalTable);
}
else if(instPtr->nextState == NORMAL_STATE){
else if(instPtr->nextState == L2_NORMAL_STATE){
instPtr->rtneConfig.rtneTable = normalTable;
instPtr->rtneConfig.rtnePrd = ARRAY_SIZE(normalTable);
}
else if(instPtr->nextState == SEEK_STATE){
else if(instPtr->nextState == L2_SEEK_STATE){
instPtr->rtneConfig.rtneTable = seekTable;
instPtr->rtneConfig.rtnePrd = ARRAY_SIZE(seekTable);
}
else if(instPtr->nextState == INTRA_SEEK_STATE){
else if(instPtr->nextState == L2_INTRA_SEEK_STATE){
instPtr->rtneConfig.rtneTable = intraSeekTable;
instPtr->rtneConfig.rtnePrd = ARRAY_SIZE(intraSeekTable);
}
else if(instPtr->nextState == INTER_SEEK_STATE){
else if(instPtr->nextState == L2_INTER_SEEK_STATE){
instPtr->rtneConfig.rtneTable = interSeekTable;
instPtr->rtneConfig.rtnePrd = ARRAY_SIZE(interSeekTable);
}
@@ -949,7 +945,6 @@ int mgmtFrameRecv = 0;
int svcFrameRecv = 0;
int32_t Linklayer_PktHandler(L2_INST* instPtr, L2_FRAME_TYPE frameType) {
ASSERT(instPtr != NULL);
DBG_INFO("Link layer handling packet...\n");
int32_t Status = SUCCESS;
if (instPtr->dataAvail == false) {
@@ -1047,27 +1042,27 @@ static int32_t Linklayer_Routine (L2_INST* instPtr) {
DBG_INFO("## Routine: %u-%u, Routine period: %u.\n", tableIndx, entryIndx, instPtr->rtneConfig.rtnePrd);
switch (rtneEntry.slotType) {
case SLOT_IDLE:
case L2_SLOT_IDLE:
// Skip a 5ms slot.
Status = SUCCESS;
DBG_INFO("Skipping idle slot (5ms)...\n");
break;
case SLOT_INTER_SCAN_ACQ:
case SLOT_INTRA_SCAN_ACQ:
case SLOT_INTER_SCAN_BM:
case SLOT_INTRA_SCAN_BM:
case SLOT_INTER_SCAN_2W:
case SLOT_INTRA_SCAN_2W:
case L2_SLOT_INTER_SCAN_ACQ:
case L2_SLOT_INTRA_SCAN_ACQ:
case L2_SLOT_INTER_SCAN_BM:
case L2_SLOT_INTRA_SCAN_BM:
case L2_SLOT_INTER_SCAN_2W:
case L2_SLOT_INTRA_SCAN_2W:
Status = ScanNet_Routine(instPtr, &rtneEntry);
break;
case SLOT_INTER_SVC:
case SLOT_INTRA_SVC:
case L2_SLOT_INTER_SVC:
case L2_SLOT_INTRA_SVC:
Status = ServiceNet_Routine(instPtr, &rtneEntry);
break;
case SLOT_INTER_MGMT:
case SLOT_INTRA_MGMT:
case SLOT_INTER_TSYNC:
case SLOT_INTRA_TSYNC:
case L2_SLOT_INTER_MGMT:
case L2_SLOT_INTRA_MGMT:
case L2_SLOT_INTER_TSYNC:
case L2_SLOT_INTRA_TSYNC:
Status = MgmtNet_Routine(instPtr, &rtneEntry);
break;
default:
@@ -1082,7 +1077,7 @@ static int32_t Linklayer_Routine (L2_INST* instPtr) {
}
// FIXME: Increase TTL counter
if (instPtr->mainState != INIT_STATE)
if (instPtr->mainState != L2_INIT_STATE)
{
// if ( L2_isNodeInList (instPtr->nodeList, rtneEntry.src0) )
// {
@@ -1123,11 +1118,11 @@ int32_t Linklayer_Proc(L2_INST* instPtr) {
}
// Run Link layer routine, setup next slot procedure.
if (L2_GetNodeType(instPtr) == HEAD_NODE) {
if (L2_GetNodeType(instPtr) == L2_NODE_HEAD) {
Phy_SetMode(instPtr->config.phyInstPtr, PHY_MODE_PULL);
Status = Linklayer_Routine(instPtr);
}
else { //MEMBER_NODE
else { //L2_NODE_MEMBER
if (L2_isCxn2Net(instPtr)) {
Phy_SetMode(instPtr->config.phyInstPtr, PHY_MODE_PULL);
Status = Linklayer_Routine(instPtr);
@@ -1147,6 +1142,10 @@ int32_t Linklayer_Proc(L2_INST* instPtr) {
// Update slot number.
L2_UpdateSlotNum(instPtr);
// Frame types shift (last <- curr <- next)
L2_RcdShift(&(instPtr->frame), L2_NONE_FRAME);
L2_RcdShift(&(instPtr->tor), L2_TOR_SUSPEND);
// Update link layer state.
instPtr->mainState = instPtr->nextState;
datalink814_ge/src/linklayer/linklayer814_types.h
+46 -46
View File
@@ -24,11 +24,11 @@
#include "../phy_ctrl/phy_ctrl.h"
/************************** Constant Definitions *****************************/
// Common node ID definition
#define BROADCAST_ID 0x1F
#define NONE_ID 0
#define L2_BROADCAST_ID 0x1F
#define L2_NONE_ID 0
// for MPC Configure
#define MSG_STROAGE_BUFF_MAX 16384 // 16K Bytes
#define L2_MSG_STROAGE_BUFF_MAX 16384 // 16K Bytes
// Routine configure
#define L2_INIT_RTNE_PERIOD 24
@@ -45,11 +45,11 @@
#define L2_SLOTS_PER_FRAME 200
#define L2_SLOTS_PER_SUBFRAME 20
#define NUM_SLOTS_NONE UINT32_MAX
#define NUM_SLOTS_20MS 4
#define NUM_SLOTS_10MS 2
#define NUM_SLOTS_5MS 1
#define NUM_SLOTS_SKIP 0
#define L2_NUM_SLOTS_NONE UINT32_MAX
#define L2_NUM_SLOTS_20MS 4
#define L2_NUM_SLOTS_10MS 2
#define L2_NUM_SLOTS_5MS 1
#define L2_NUM_SLOTS_SKIP 0
/**************************** Type Definitions *******************************/
@@ -70,21 +70,21 @@ typedef enum {
/** @name Prior information type definition
*/
typedef enum {
NONE_TYPE = 0,
HEAD_NODE = 1,
MEMBER_NODE = 2,
BACKUP_HEAD = 3
L2_NODE_NONE = 0,
L2_NODE_HEAD = 1,
L2_NODE_MEMBER = 2,
L2_NODE_BACKUP = 3
} L2_NODE_TYPE;
/** @name Node state type definition
*/
typedef enum {
NONE_STATE = 0,
INIT_STATE = 1,
NORMAL_STATE = 2,
INTRA_SEEK_STATE = 3,
INTER_SEEK_STATE = 4,
SEEK_STATE = 5
L2_NONE_STATE = 0,
L2_INIT_STATE = 1,
L2_NORMAL_STATE = 2,
L2_INTRA_SEEK_STATE = 3,
L2_INTER_SEEK_STATE = 4,
L2_SEEK_STATE = 5
} L2_NODE_STATE;
typedef struct {
@@ -129,20 +129,20 @@ typedef struct {
* A definition of different slots.
*/
typedef enum {
SLOT_NONE = 0,
SLOT_IDLE = 1,
SLOT_INTER_SCAN_ACQ = 2,
SLOT_INTRA_SCAN_ACQ = 3,
SLOT_INTER_SCAN_BM = 4,
SLOT_INTRA_SCAN_BM = 5,
SLOT_INTER_SCAN_2W = 6,
SLOT_INTRA_SCAN_2W = 7,
SLOT_INTER_SVC = 8,
SLOT_INTRA_SVC = 9,
SLOT_INTER_MGMT = 10,
SLOT_INTRA_MGMT = 11,
SLOT_INTER_TSYNC = 12,
SLOT_INTRA_TSYNC = 13,
L2_SLOT_NONE = 0,
L2_SLOT_IDLE = 1,
L2_SLOT_INTER_SCAN_ACQ = 2,
L2_SLOT_INTRA_SCAN_ACQ = 3,
L2_SLOT_INTER_SCAN_BM = 4,
L2_SLOT_INTRA_SCAN_BM = 5,
L2_SLOT_INTER_SCAN_2W = 6,
L2_SLOT_INTRA_SCAN_2W = 7,
L2_SLOT_INTER_SVC = 8,
L2_SLOT_INTRA_SVC = 9,
L2_SLOT_INTER_MGMT = 10,
L2_SLOT_INTRA_MGMT = 11,
L2_SLOT_INTER_TSYNC = 12,
L2_SLOT_INTRA_TSYNC = 13,
} L2_SLOT_TYPE;
/** @name Frame types
@@ -214,17 +214,17 @@ typedef struct {
} L2_W2ACQ_LOG;
typedef enum {
NONE_STAGE = 0,
INIT_SCAN_STAGE = 1,
BM_ADVT_STAGE = 2, // Benchmark advertisement
WAY2_ACQ_STAGE = 3
L2_SCAN_NONE_STAGE = 0,
L2_SCAN_INIT_STAGE = 1,
L2_SCAN_BMADVT_STAGE = 2, // Benchmark advertisement
L2_SCANT_2WAYACQ_STAGE = 3
} SCAN_STAGE;
typedef enum {
NONE_MODE = 0,
INTRA_CLUSTER_MODE = 1,
INTER_CLUSTER_MODE = 2
} SCAN_MODE;
L2_SCAN_NONE_MODE = 0,
L2_SCAN_INTRA_MODE = 1,
L2_SCAN_INTER_MODE = 2
} L2_SCAN_MODE;
typedef struct {
bool isLocked; // init acq done.
@@ -234,7 +234,7 @@ typedef struct {
uint32_t bmTimeout;
uint32_t w2acqTimeout;
SCAN_STAGE scanStage; // only for member node
SCAN_MODE scanMode; // inter sanc or intra scan
L2_SCAN_MODE scanMode; // inter sanc or intra scan
L2_BM_LOG BMrcvLog;
L2_W2ACQ_LOG W2ACQrcvLog;
} L2_SCAN_FSM;
@@ -264,7 +264,7 @@ typedef struct {
uint32_t Longitude ;
uint32_t Latitude ;
bool isValid;
} MGMT_MSG_RECORD;
} L2_MGMT_MSG_RECORD;
typedef struct {
uint16_t wordTag;
@@ -276,15 +276,15 @@ typedef struct {
uint32_t timeWordL;
uint32_t timeWordH;
int32_t doppler;
} RTT_MSG_RECORD;
} L2_RTT_MSG_RECORD;
typedef struct {
bool isBisarProc;
bool isPendTimeAlloc;
bool isPendSlotAlloc;
MGMT_MSG_RECORD mgmtMsgLog;
RTT_MSG_RECORD rttMsgRspLog;
RTT_MSG_RECORD rttMsgReqLog;
L2_MGMT_MSG_RECORD mgmtMsgLog;
L2_RTT_MSG_RECORD rttMsgRspLog;
L2_RTT_MSG_RECORD rttMsgReqLog;
} L2_MGMT_FSM;
typedef struct{
datalink814_ge/src/linklayer/linklayer_routine.c
+600 -602
View File
File diff suppressed because it is too large Load Diff
datalink814_ge/src/linklayer/net_mgmt.c
+44 -41
View File
@@ -106,21 +106,21 @@ static int32_t MgmtMsg_Packing(L2_INST* instPtr, BIT_ARRAY* bitarr, L2_MSG_TYPE
FrameInsertChunk(bitarr, TK_MSG_INI_OFFSET, TK_MSG_INI_LEN, dataChunk);
// Next net stage
if (L2_GetNodeType(instPtr) == HEAD_NODE) {
if (L2_GetNodeType(instPtr) == L2_NODE_HEAD) {
switch (instPtr->nextState) {
case INIT_STATE:
case L2_INIT_STATE:
dataChunk = NET_INI_STAGE;
break;
case NORMAL_STATE:
case L2_NORMAL_STATE:
dataChunk = NET_NORMAL_STAGE;
break;
case INTRA_SEEK_STATE:
case L2_INTRA_SEEK_STATE:
dataChunk = NET_INTRA_SEEK_STAGE;
break;
case INTER_SEEK_STATE:
case L2_INTER_SEEK_STATE:
dataChunk = NET_INTER_SEEK_STAGE;
break;
case SEEK_STATE:
case L2_SEEK_STATE:
dataChunk = NET_SEEK_STAGE;
break;
default:
@@ -296,11 +296,11 @@ static int32_t MgmtMsg_Packing(L2_INST* instPtr, BIT_ARRAY* bitarr, L2_MSG_TYPE
dataChunk = 2;
FrameInsertChunk(bitarr, RTT_REQ_MSG_OFFSET, RTT_REQ_MSG_LEN, dataChunk);
// source node address length.
// source node address.
dataChunk = (L2_GetNodeId(instPtr) & 0x1F) | (((uint16_t)(L2_GetClusterId(instPtr) & 0x1F)) << 5);
FrameInsertChunk(bitarr, RTT_REQ_SRC_ADDR_OFFSET, RTT_REQ_SRC_ADDR_LEN, dataChunk);
// destination node address length.
// destination node address.
dataChunk = (0x02) | (((uint16_t) (L2_GetClusterId(instPtr) & 0x1F)) << 5);
FrameInsertChunk(bitarr, RTT_REQ_DST_ADDR_OFFSET, RTT_REQ_DST_ADDR_LEN, dataChunk);
break;
@@ -347,11 +347,11 @@ static int32_t MgmtMsg_Packing(L2_INST* instPtr, BIT_ARRAY* bitarr, L2_MSG_TYPE
dataChunk = 2;
FrameInsertChunk(bitarr, RTT_RSP_MSG_OFFSET, RTT_RSP_MSG_LEN, dataChunk);
// source node address length.
// source node address.
dataChunk = (L2_GetNodeId(instPtr) & 0x1F) | (((uint16_t)(L2_GetClusterId(instPtr) & 0x1F)) << 5);
FrameInsertChunk(bitarr, RTT_RSP_SRC_ADDR_OFFSET, RTT_RSP_SRC_ADDR_LEN, dataChunk);
// destination node address length.
// destination node address.
dataChunk = (0x01) | (((uint16_t) (L2_GetClusterId(instPtr) & 0x1F)) << 5);
FrameInsertChunk(bitarr, RTT_RSP_DST_ADDR_OFFSET, RTT_RSP_DST_ADDR_LEN, dataChunk);
break;
@@ -405,7 +405,7 @@ static int32_t MgmtMsg_Packing(L2_INST* instPtr, BIT_ARRAY* bitarr, L2_MSG_TYPE
// // Quit object
// dataChunk = (L2_GetNodeId(instPtr) & 0x1F) | (((uint16_t)(L2_GetClusterId(instPtr) & 0x1F)) << 5);
// FrameInsertChunk(bitarr, NQT_MSG_OBJ_OFFSET, NQT_MSG_OBJ_LEN, dataChunk);
// L2_NODE_STATE newState = INIT_STATE;
// L2_NODE_STATE newState = L2_INIT_STATE;
// L2_EVENT stateEvent = {
// .event = L2_EV_MAIN_STATE_UPDATE,
// .msg = &newState
@@ -451,7 +451,7 @@ static int32_t MgmtPkt_Packing(L2_INST* instPtr, MGMTPKT_TYPE pktType) {
BIT_ARRAY* mgmtPkt = bit_array_create(L2_MSG_MAX);
if (mgmtPkt == NULL) {
DBG_ERROR("Failed to allocate memory for scanMsg.\n");
return NUM_SLOTS_NONE;
return FAILURE;
}
switch (pktType) {
case MGMTPKT_INTRA_MGMT:
@@ -551,7 +551,7 @@ void MgmtNet_Reset(L2_MGMT_FSM* mgmtFSM) {
mgmtFSM->isPendSlotAlloc = false;
mgmtFSM->isPendTimeAlloc = false;
mgmtFSM->mgmtMsgLog.nextNetState = NONE_STATE;
mgmtFSM->mgmtMsgLog.nextNetState = L2_NONE_STATE;
mgmtFSM->mgmtMsgLog.isValid = false;
mgmtFSM->mgmtMsgLog.quitCtrlWord = 0;
mgmtFSM->mgmtMsgLog.quitNodeId = 0;
@@ -569,8 +569,8 @@ void MgmtNet_Reset(L2_MGMT_FSM* mgmtFSM) {
mgmtFSM->mgmtMsgLog.Latitude = 0 ;
// clear buffer.
memset(&(mgmtFSM->rttMsgRspLog), 0x00, sizeof(RTT_MSG_RECORD));
memset(&(mgmtFSM->rttMsgReqLog), 0x00, sizeof(RTT_MSG_RECORD));
memset(&(mgmtFSM->rttMsgRspLog), 0x00, sizeof(L2_RTT_MSG_RECORD));
memset(&(mgmtFSM->rttMsgReqLog), 0x00, sizeof(L2_RTT_MSG_RECORD));
}
@@ -603,13 +603,15 @@ int32_t MgmtNet_PktHandler(L2_INST* instPtr) {
int32_t Status;
uint32_t filedSize = 0;
uint64_t dataChunk = 0;
MGMT_MSG_RECORD *mgmtMsgLog = &(instPtr->mgmtNetFSM->mgmtMsgLog);
RTT_MSG_RECORD *rttMsgRspLog = &(instPtr->mgmtNetFSM->rttMsgRspLog);
RTT_MSG_RECORD *rttMsgReqLog = &(instPtr->mgmtNetFSM->rttMsgReqLog);
L2_MGMT_MSG_RECORD *mgmtMsgLog = &(instPtr->mgmtNetFSM->mgmtMsgLog);
L2_RTT_MSG_RECORD *rttMsgRspLog = &(instPtr->mgmtNetFSM->rttMsgRspLog);
L2_RTT_MSG_RECORD *rttMsgReqLog = &(instPtr->mgmtNetFSM->rttMsgReqLog);
DBG_INFO("Management net handling packet...\n");
BIT_ARRAY* mgmtMsg = bit_array_create(L2_MSG_MAX);
if (mgmtMsg == NULL) {
free(mgmtMsg);
DBG_INFO("Failed to start handling process...\n");
return EALLOC;
}
switch (L2_GetLastFrameType(instPtr)) {
@@ -702,24 +704,24 @@ int32_t MgmtNet_PktHandler(L2_INST* instPtr) {
}
}
// Member Node update state with received message
if(L2_GetNodeId(instPtr) != HEAD_NODE && mgmtMsgLog->isValid == true ){
L2_NODE_STATE newState = NONE_STATE;
if(L2_GetNodeId(instPtr) != L2_NODE_HEAD && mgmtMsgLog->isValid == true ){
L2_NODE_STATE newState = L2_NONE_STATE;
// FIXME :
switch (mgmtMsgLog->nextNetState) {
case NET_INI_STAGE:
newState = INIT_STATE;
newState = L2_INIT_STATE;
break;
case NET_NORMAL_STAGE:
newState = NORMAL_STATE;
newState = L2_NORMAL_STATE;
break;
case NET_INTRA_SEEK_STAGE:
newState = INTRA_SEEK_STATE;
newState = L2_INTRA_SEEK_STATE;
break;
case NET_INTER_SEEK_STAGE:
newState = INTER_SEEK_STATE;
newState = L2_INTER_SEEK_STATE;
break;
case NET_SEEK_STAGE:
newState = SEEK_STATE;
newState = L2_SEEK_STATE;
break;
default:
DBG_WARNING("Unknown Head node state [%d].\n", mgmtMsgLog->nextNetState);
@@ -742,7 +744,7 @@ int32_t MgmtNet_PktHandler(L2_INST* instPtr) {
}
case L2_INTER_TSYNC_FRAME:
case L2_INTRA_TSYNC_FRAME: {
if(L2_GetNodeType(instPtr) == HEAD_NODE){
if(L2_GetNodeType(instPtr) == L2_NODE_HEAD){
for (int i = 0; i < ARRAY_SIZE(rttReqFrameMsgs); i++) {
memcpy(mgmtMsg->words,
instPtr->recvPktData + (size_t) (i * (RTT_MSG_LEN / 8)),
@@ -919,7 +921,7 @@ int32_t MgmtNet_Routine(L2_INST* instPtr, const L2_RTNE_TABLE_ENTRY* rtneEntry){
if (L2_GetLastFrameType(instPtr) == L2_INTRA_TSYNC_FRAME && L2_GetLastTor(instPtr) == L2_TOR_RX) {
RTT_FsmUpdate(instPtr, L2_TOR_RX);
}
if (rtneEntry->slotType == SLOT_INTRA_TSYNC) {
if (rtneEntry->slotType == L2_SLOT_INTRA_TSYNC) {
if(torState == L2_TOR_TX) {
RTT_FsmUpdate(instPtr, L2_TOR_TX);
}
@@ -929,16 +931,17 @@ int32_t MgmtNet_Routine(L2_INST* instPtr, const L2_RTNE_TABLE_ENTRY* rtneEntry){
if(rttRxEvent == NULL) {
DBG_ERROR("Failed to initialize rtt event.\n");
}
// Schedule rtt update after receive process end.
Status = L2_ScheduleEventAfter(instPtr, rttRxEvent, INTRA_TSYNC_SLOTS + 1);
}
}
switch (rtneEntry->slotType) {
case SLOT_INTER_MGMT:
case L2_SLOT_INTER_MGMT:
// TODO:
L2_SetupNextSlot(instPtr, torState, L2_INTER_MGMT_FRAME);
break;
case SLOT_INTRA_MGMT:
case L2_SLOT_INTRA_MGMT:
memset(instPtr->sendPktData, 0xAA, INTRA_MGMT_FRAME_LENGTH_MAX);
if (torState == L2_TOR_TX) {
if(MgmtPkt_Packing(instPtr, MGMTPKT_INTRA_MGMT) != SUCCESS) {
@@ -948,14 +951,14 @@ int32_t MgmtNet_Routine(L2_INST* instPtr, const L2_RTNE_TABLE_ENTRY* rtneEntry){
}
L2_SetupNextSlot(instPtr, torState, L2_INTRA_MGMT_FRAME);
break;
case SLOT_INTER_TSYNC:
case L2_SLOT_INTER_TSYNC:
// TODO:
L2_SetupNextSlot(instPtr, torState, L2_INTER_TSYNC_FRAME);
break;
case SLOT_INTRA_TSYNC:
case L2_SLOT_INTRA_TSYNC:
if (torState == L2_TOR_TX) {
memset(instPtr->sendPktData, 0xAA, INTRA_RTT_FRAME_LENGTH_MAX);
if(L2_GetNodeType(instPtr) == HEAD_NODE){
if(L2_GetNodeType(instPtr) == L2_NODE_HEAD){
if(MgmtPkt_Packing(instPtr, MGMTPKT_INTRA_RTTREQ) != SUCCESS) {
Status = FAILURE;
goto routine_err;
@@ -978,26 +981,26 @@ int32_t MgmtNet_Routine(L2_INST* instPtr, const L2_RTNE_TABLE_ENTRY* rtneEntry){
/*************************************************/
// Update link layer state...
if (L2_GetNodeType(instPtr) == HEAD_NODE) {
L2_NODE_STATE newState = NONE_STATE;
if (L2_GetNodeType(instPtr) == L2_NODE_HEAD) {
L2_NODE_STATE newState = L2_NONE_STATE;
L2_EVENT stateEvent = {
.event = L2_EV_MAIN_STATE_UPDATE,
.msg = &newState
};
if (L2_GetNodeListLen(instPtr->nodeList) < instPtr->config.netScale
&& L2_GetMainState(instPtr) != INTRA_SEEK_STATE) {
newState = INTRA_SEEK_STATE;
&& L2_GetMainState(instPtr) != L2_INTRA_SEEK_STATE) {
newState = L2_INTRA_SEEK_STATE;
AssertL2Event(instPtr, &stateEvent);
}
else if(L2_GetNodeListLen(instPtr->nodeList) >= instPtr->config.netScale &&
L2_GetMainState(instPtr) != NORMAL_STATE){
newState = NORMAL_STATE;
L2_GetMainState(instPtr) != L2_NORMAL_STATE){
newState = L2_NORMAL_STATE;
AssertL2Event(instPtr, &stateEvent);
}
}
else{ // MEMBER_NODE or BACKUP_HEAD
else{ // L2_NODE_MEMBER or BACKUP_HEAD
if(L2_isNodeInList(instPtr->nodeList, L2_GetHeadId(instPtr)) == false){
L2_NODE_STATE newState = INIT_STATE;
L2_NODE_STATE newState = L2_INIT_STATE;
L2_EVENT stateEvent = {
.event = L2_EV_MAIN_STATE_UPDATE,
.msg = &newState
datalink814_ge/src/linklayer/net_scan.c
+70 -67
View File
@@ -225,7 +225,7 @@ static int32_t ScanMsg_Packing(L2_INST* instPtr, BIT_ARRAY* bitarr, L2_MSG_TYPE
FrameInsertChunk(bitarr, NS_MSG_INI_LEN_OFFSET, NS_MSG_INI_LEN_LEN, dataChunk);
/* message type */
dataChunk = (L2_GetNodeId(instPtr) == HEAD_NODE) ? 0 : 1;
dataChunk = (L2_GetNodeId(instPtr) == L2_NODE_HEAD) ? 0 : 1;
FrameInsertChunk(bitarr, NS_MSG_INI_TYPE_OFFSET, NS_MSG_INI_TYPE_LEN, dataChunk);
/* source node id */
@@ -234,20 +234,20 @@ static int32_t ScanMsg_Packing(L2_INST* instPtr, BIT_ARRAY* bitarr, L2_MSG_TYPE
FrameInsertChunk(bitarr, NS_MSG_INI_SRC_ADDR_OFFSET, NS_MSG_INI_SRC_ADDR_LEN, dataChunk);
/* destination node id */
dataChunk = (L2_GetNodeId(instPtr) == HEAD_NODE) ?
(BROADCAST_ID | (BROADCAST_ID << 5))
dataChunk = (L2_GetNodeId(instPtr) == L2_NODE_HEAD) ?
(L2_BROADCAST_ID | (L2_BROADCAST_ID << 5))
: (L2_GetHeadId(instPtr) & 0x1F) | (((uint16_t)(L2_GetClusterId(instPtr) & 0x1F)) << 5);
FrameInsertChunk(bitarr, NS_MSG_INI_LEN_OFFSET, NS_MSG_INI_LEN_LEN, dataChunk);
if (L2_GetNodeType(instPtr) == HEAD_NODE) {
if (L2_GetNodeType(instPtr) == L2_NODE_HEAD) {
/* current net stage */
switch (instPtr->mainState) {
case INIT_STATE:
case L2_INIT_STATE:
dataChunk = NET_INI_STAGE;
break;
case SEEK_STATE:
case L2_SEEK_STATE:
dataChunk = NET_INTER_SEEK_STAGE;
break;
case NORMAL_STATE:
case L2_NORMAL_STATE:
dataChunk = NET_NORMAL_STAGE;
break;
default:
@@ -373,7 +373,7 @@ static int32_t ScanPkt_Packing(L2_INST* instPtr, SCANPKT_TYPE pktType){
BIT_ARRAY* scanPkt = bit_array_create(L2_MSG_MAX);
if (scanPkt == NULL) {
DBG_ERROR("Failed to allocate memory for scanMsg.\n");
return NUM_SLOTS_NONE;
return FAILURE;
}
switch (pktType) {
case SCANPKT_INTRA_BM:
@@ -426,24 +426,24 @@ static int32_t Scan_InitScanHandler(L2_INST* instPtr) {
L2_SCAN_FSM* scanFsmPtr = instPtr->scanNetFSM;
DBG_INFO("** Netsetup - InitScan Procedure (Attempts: %u)**\n", scanFsmPtr->scanCnt);
if(scanFsmPtr->scanMode == INTRA_CLUSTER_MODE){
if(scanFsmPtr->scanMode == L2_SCAN_INTRA_MODE){
if (scanFsmPtr->isLocked == true) {
StageUpdate(scanFsmPtr, BM_ADVT_STAGE);
StageUpdate(scanFsmPtr, L2_SCAN_BMADVT_STAGE);
/* Antenna setting (reserved.) */
L2_SetupNextSlot(instPtr, L2_TOR_RX, L2_INTRA_BM_FRAME);
} /* Otherwise remain INIT_SCAN_STAGE */
} /* Otherwise remain L2_SCAN_INIT_STAGE */
else {
/* Antenna setting (reserved.) */
L2_SetupNextSlot(instPtr, L2_TOR_RX, L2_INTRA_SCAN_FRAME);
scanFsmPtr->scanCnt++;
}
}
else if(scanFsmPtr->scanMode == INTER_CLUSTER_MODE){
else if(scanFsmPtr->scanMode == L2_SCAN_INTER_MODE){
if (scanFsmPtr->isLocked == true) {
StageUpdate(scanFsmPtr, BM_ADVT_STAGE);
StageUpdate(scanFsmPtr, L2_SCAN_BMADVT_STAGE);
/* Antenna setting (reserved.) */
L2_SetupNextSlot(instPtr, L2_TOR_RX, L2_INTER_BM_FRAME);
} /* Otherwise remain INIT_SCAN_STAGE */
} /* Otherwise remain L2_SCAN_INIT_STAGE */
else {
/* Antenna setting (reserved.) */
L2_SetupNextSlot(instPtr, L2_TOR_RX, L2_INTER_SCAN_FRAME);
@@ -452,9 +452,9 @@ static int32_t Scan_InitScanHandler(L2_INST* instPtr) {
}
else{
DBG_ERROR("UNKNOWN Scan Mode: %d.\n", scanFsmPtr->scanMode);
return NUM_SLOTS_NONE;
return FAILURE;
}
return (NUM_SLOTS_SKIP);
return SUCCESS;
}
/*****************************************************************************/
@@ -477,45 +477,45 @@ static int32_t Scan_BmAdvtHandler(L2_INST* instPtr) {
scanFsmPtr->bmTimeout = 0; /* reset listen counter. */
DBG_INFO("Received Bm frame, skipping 10ms for turn around...\n");
// TODO: check functionality.
StageUpdate(scanFsmPtr, WAY2_ACQ_STAGE);
return NUM_SLOTS_10MS;
StageUpdate(scanFsmPtr, L2_SCANT_2WAYACQ_STAGE);
return SUCCESS;
}
// no valid bm frame was received.
else {
/* if time out reached, go back to init scan stage. */
if (scanFsmPtr->bmTimeout > BM_LSTEN_TIMEOUT) {
if(scanFsmPtr->scanMode == INTRA_CLUSTER_MODE){
if(scanFsmPtr->scanMode == L2_SCAN_INTRA_MODE){
/* Antenna setting (reserved.) */
L2_SetupNextSlot(instPtr, L2_TOR_RX, L2_INTRA_SCAN_FRAME);
}
else if(scanFsmPtr->scanMode == INTER_CLUSTER_MODE){
else if(scanFsmPtr->scanMode == L2_SCAN_INTER_MODE){
/* Antenna setting (reserved.) */
L2_SetupNextSlot(instPtr, L2_TOR_RX, L2_INTER_SCAN_FRAME);
}
else{
DBG_ERROR("UNKNOWN Scan Mode: %d.\n", scanFsmPtr->scanMode);
return NUM_SLOTS_NONE;
return FAILURE;
}
DBG_WARNING("BM timeout, restart net scan from INIT_SCAN_STAGE.\n");
DBG_WARNING("BM timeout, restart net scan from L2_SCAN_INIT_STAGE.\n");
scanFsmPtr->bmTimeout = 0; /* reset listen counter. */
StageUpdate(scanFsmPtr, INIT_SCAN_STAGE);
StageUpdate(scanFsmPtr, L2_SCAN_INIT_STAGE);
}
else {
if(scanFsmPtr->scanMode == INTRA_CLUSTER_MODE){
if(scanFsmPtr->scanMode == L2_SCAN_INTRA_MODE){
/* Antenna setting (reserved.) */
L2_SetupNextSlot(instPtr, L2_TOR_RX, L2_INTRA_BM_FRAME);
}
else if(scanFsmPtr->scanMode == INTER_CLUSTER_MODE){
else if(scanFsmPtr->scanMode == L2_SCAN_INTER_MODE){
/* Antenna setting (reserved.) */
L2_SetupNextSlot(instPtr, L2_TOR_RX, L2_INTER_BM_FRAME);
}
else{
DBG_ERROR("UNKNOWN Scan Mode: %d.\n", scanFsmPtr->scanMode);
return NUM_SLOTS_NONE;
return FAILURE;
}
scanFsmPtr->bmTimeout++;
}
return NUM_SLOTS_SKIP;
return SUCCESS;
}
}
@@ -533,10 +533,10 @@ static int32_t Scan_2WAcqHandler (L2_INST* instPtr){
DBG_INFO("** Netsetup - 2WAcq Procedure (Timeout: %u) **\n", scanFsmPtr->w2acqTimeout);
L2_FRAME_TYPE frameType = L2_NONE_FRAME;
if(scanFsmPtr->scanMode == INTRA_CLUSTER_MODE){
if(scanFsmPtr->scanMode == L2_SCAN_INTRA_MODE){
frameType = L2_INTRA_W2_ACQ_FRAME;
}
else if(scanFsmPtr->scanMode == INTER_CLUSTER_MODE){
else if(scanFsmPtr->scanMode == L2_SCAN_INTER_MODE){
frameType = L2_INTER_W2_ACQ_FRAME;
}
else{
@@ -546,9 +546,9 @@ static int32_t Scan_2WAcqHandler (L2_INST* instPtr){
// 2 way acq failed, back to init stage.
if (scanFsmPtr->w2acqTimeout >= WAY2_ACQ_SLOT_MAX) {
DBG_WARNING("2WAcq timeout, restart net scan from INIT_SCAN_STAGE.\n");
DBG_WARNING("2WAcq timeout, restart net scan from L2_SCAN_INIT_STAGE.\n");
scanFsmPtr->w2acqTimeout = 0; // reset counter for next scan.
StageUpdate(scanFsmPtr, INIT_SCAN_STAGE);
StageUpdate(scanFsmPtr, L2_SCAN_INIT_STAGE);
}
else {
scanFsmPtr->w2acqTimeout++; // increase counter.
@@ -573,9 +573,12 @@ int32_t ScanNet_PktHandler(L2_INST* instPtr) {
uint32_t Status;
L2_SCAN_FSM* scanFsmPtr = instPtr->scanNetFSM;
uint64_t dataChunk;
DBG_INFO("Scan net handling packet...\n");
BIT_ARRAY* scanMsg = bit_array_create(L2_MSG_MAX);
if (scanMsg == NULL) {
free(scanMsg);
DBG_INFO("Failed to start handling process...\n");
return EALLOC;
}
switch (L2_GetLastFrameType(instPtr)) {
@@ -631,11 +634,11 @@ int32_t ScanNet_PktHandler(L2_INST* instPtr) {
goto failed;
}
}
if(L2_GetNodeType(instPtr) != HEAD_NODE){
if(L2_GetNodeType(instPtr) != L2_NODE_HEAD){
NODE_ENTRY* nodeEntry = L2_GetNodeById(instPtr->nodeList, scanFsmPtr->BMrcvLog.NodeId);
if(nodeEntry == NULL) {
nodeEntry = L2_AppendNode(instPtr->nodeList, scanFsmPtr->BMrcvLog.NodeId, HEAD_NODE);
nodeEntry = L2_AppendNode(instPtr->nodeList, scanFsmPtr->BMrcvLog.NodeId, L2_NODE_HEAD);
// TODO: Insert other node information.
}
else {
@@ -671,22 +674,22 @@ int32_t ScanNet_PktHandler(L2_INST* instPtr) {
FrameGetChunk(scanMsg, NS_MSG_INI_NET_STAGE_OFFSET, NS_MSG_INI_NET_STAGE_LEN, &dataChunk);
switch (dataChunk) {
case NET_INI_STAGE:
scanFsmPtr->W2ACQrcvLog.NetStage = INIT_STATE;
scanFsmPtr->W2ACQrcvLog.NetStage = L2_INIT_STATE;
break;
case NET_NORMAL_STAGE:
scanFsmPtr->W2ACQrcvLog.NetStage = NORMAL_STATE;
scanFsmPtr->W2ACQrcvLog.NetStage = L2_NORMAL_STATE;
break;
case NET_INTRA_SEEK_STAGE:
scanFsmPtr->W2ACQrcvLog.NetStage = INTRA_SEEK_STATE;
scanFsmPtr->W2ACQrcvLog.NetStage = L2_INTRA_SEEK_STATE;
break;
case NET_INTER_SEEK_STAGE:
scanFsmPtr->W2ACQrcvLog.NetStage = INTER_SEEK_STATE;
scanFsmPtr->W2ACQrcvLog.NetStage = L2_INTER_SEEK_STATE;
break;
case NET_SEEK_STAGE:
scanFsmPtr->W2ACQrcvLog.NetStage = SEEK_STATE;
scanFsmPtr->W2ACQrcvLog.NetStage = L2_SEEK_STATE;
break;
default:
scanFsmPtr->W2ACQrcvLog.NetStage = NONE_STATE;
scanFsmPtr->W2ACQrcvLog.NetStage = L2_NONE_STATE;
DBG_WARNING("UNEXPECTED head node state.");
break;
}
@@ -728,14 +731,14 @@ int32_t ScanNet_PktHandler(L2_INST* instPtr) {
NODE_ENTRY* nodeEntry = L2_GetNodeById(instPtr->nodeList, scanFsmPtr->W2ACQrcvLog.NodeId);
if(nodeEntry == NULL) {
nodeEntry = L2_AppendNode(instPtr->nodeList, scanFsmPtr->W2ACQrcvLog.NodeId, MEMBER_NODE);
nodeEntry = L2_AppendNode(instPtr->nodeList, scanFsmPtr->W2ACQrcvLog.NodeId, L2_NODE_MEMBER);
// TODO: Insert other node information.
}
else {
// TODO: Update node information.
}
if(L2_GetNodeType(instPtr) != HEAD_NODE && scanFsmPtr->W2ACQrcvLog.NetStage != NONE_STATE){
if(L2_GetNodeType(instPtr) != L2_NODE_HEAD && scanFsmPtr->W2ACQrcvLog.NetStage != L2_NONE_STATE){
// Update net start time
instPtr->netStartTime = scanFsmPtr->W2ACQrcvLog.NetScanTime;
// sync state with head node
@@ -747,18 +750,18 @@ int32_t ScanNet_PktHandler(L2_INST* instPtr) {
AssertL2Event(instPtr, &stateUpEvent);
// check if net setup finished.
if(L2_GetMainState(instPtr) == INIT_STATE && L2_isCxn2Net(instPtr) == false){
if(L2_GetMainState(instPtr) == L2_INIT_STATE && L2_isCxn2Net(instPtr) == false){
L2_RTNE_CONFIG newRtneConfig = {0};
L2_EVENT rtneUpEvent = {
.event = L2_ROUTINE_UPDATE,
.msg = &newRtneConfig
};
if(scanFsmPtr->W2ACQrcvLog.NetStage == INIT_STATE){
if(scanFsmPtr->W2ACQrcvLog.NetStage == L2_INIT_STATE){
newRtneConfig.rtneTable = initTable;
newRtneConfig.rtnePrd = ARRAY_SIZE(initTable);
AssertL2Event(instPtr, &rtneUpEvent);
}
else if(scanFsmPtr->W2ACQrcvLog.NetStage == INTRA_SEEK_STATE){
else if(scanFsmPtr->W2ACQrcvLog.NetStage == L2_INTRA_SEEK_STATE){
newRtneConfig.rtneTable = intraSeekTable;
newRtneConfig.rtnePrd = ARRAY_SIZE(intraSeekTable);
AssertL2Event(instPtr, &rtneUpEvent);
@@ -823,8 +826,8 @@ void ScanNet_Reset(L2_SCAN_FSM* scanFSMPtr) {
scanFSMPtr->scanCnt = 0;
scanFSMPtr->bmTimeout = 0;
scanFSMPtr->w2acqTimeout = 0;
scanFSMPtr->scanStage = NONE_STAGE;
scanFSMPtr->scanMode = INTRA_CLUSTER_MODE;
scanFSMPtr->scanStage = L2_SCAN_NONE_STAGE;
scanFSMPtr->scanMode = L2_SCAN_INTRA_MODE;
// FIXME: Only for test
scanFSMPtr->BMrcvLog.Height = 0;
scanFSMPtr->BMrcvLog.Latitude = 0;
@@ -840,7 +843,7 @@ void ScanNet_Reset(L2_SCAN_FSM* scanFSMPtr) {
scanFSMPtr->W2ACQrcvLog.EastSpeed = 0;
scanFSMPtr->W2ACQrcvLog.NorthSpeed = 0;
scanFSMPtr->W2ACQrcvLog.UpperSpeed = 0;
scanFSMPtr->W2ACQrcvLog.NetStage = NONE_STATE;
scanFSMPtr->W2ACQrcvLog.NetStage = L2_NONE_STATE;
scanFSMPtr->W2ACQrcvLog.NetScanTime = 0;
}
@@ -868,25 +871,25 @@ void ScanNet_Destroy(L2_SCAN_FSM* scanFSMPtr) {
******************************************************************************/
int32_t ScanNet_Proc(L2_INST* instPtr) {
L2_SCAN_FSM* scanFsmPtr = instPtr->scanNetFSM;
if (L2_GetNodeType(instPtr) == HEAD_NODE) {
if (L2_GetNodeType(instPtr) == L2_NODE_HEAD) {
DBG_ERROR("Only member node needs to execute ScanNet_Proc. \n");
return NUM_SLOTS_NONE;
return FAILURE;
}
int32_t Status;
DBG_INFO("-------- ScanNet Process --------\n");
switch (scanFsmPtr->scanStage) {
case NONE_STAGE:
case L2_SCAN_NONE_STAGE:
/* Start Scan. */
StageUpdate(scanFsmPtr, INIT_SCAN_STAGE);
StageUpdate(scanFsmPtr, L2_SCAN_INIT_STAGE);
Status = Scan_InitScanHandler(instPtr);
break;
case INIT_SCAN_STAGE:
case L2_SCAN_INIT_STAGE:
Status = Scan_InitScanHandler(instPtr);
break;
case BM_ADVT_STAGE:
case L2_SCAN_BMADVT_STAGE:
Status = Scan_BmAdvtHandler(instPtr);
break;
case WAY2_ACQ_STAGE:
case L2_SCANT_2WAYACQ_STAGE:
Status = Scan_2WAcqHandler(instPtr);
break;
default:
@@ -918,11 +921,11 @@ int32_t ScanNet_Routine(L2_INST* instPtr, const L2_RTNE_TABLE_ENTRY* rtneEntry)
return SQUENCE_SCAN_SLOTS;
}
if(L2_GetNodeType(instPtr) != HEAD_NODE){
if (rtneEntry->dst0 == L2_GetNodeId(instPtr) || rtneEntry->dst0 == BROADCAST_ID){
if(L2_GetNodeType(instPtr) != L2_NODE_HEAD){
if (rtneEntry->dst0 == L2_GetNodeId(instPtr) || rtneEntry->dst0 == L2_BROADCAST_ID){
torState = L2_TOR_RX;
}
else if (rtneEntry->src0 == L2_GetNodeId(instPtr) || rtneEntry->src0 == BROADCAST_ID){
else if (rtneEntry->src0 == L2_GetNodeId(instPtr) || rtneEntry->src0 == L2_BROADCAST_ID){
torState = L2_TOR_TX;
}
else {
@@ -942,13 +945,13 @@ int32_t ScanNet_Routine(L2_INST* instPtr, const L2_RTNE_TABLE_ENTRY* rtneEntry)
}
switch (rtneEntry->slotType) {
case SLOT_INTER_SCAN_ACQ:
case L2_SLOT_INTER_SCAN_ACQ:
// TODO:
L2_SetupNextSlot(instPtr, L2_TOR_SUSPEND, L2_INTER_SCAN_FRAME);
break;
case SLOT_INTRA_SCAN_ACQ:
if (L2_GetNodeType(instPtr) != HEAD_NODE && torState == L2_TOR_TX) {
case L2_SLOT_INTRA_SCAN_ACQ:
if (L2_GetNodeType(instPtr) != L2_NODE_HEAD && torState == L2_TOR_TX) {
DBG_ERROR("Only head node can send init-scan Frame.\n");
Status = FAILURE;
goto routine_err;
@@ -956,14 +959,14 @@ int32_t ScanNet_Routine(L2_INST* instPtr, const L2_RTNE_TABLE_ENTRY* rtneEntry)
L2_SetupNextSlot(instPtr, torState, L2_INTRA_SCAN_FRAME);
break;
case SLOT_INTER_SCAN_BM:
case L2_SLOT_INTER_SCAN_BM:
// TODO:
L2_SetupNextSlot(instPtr, L2_TOR_SUSPEND, L2_INTER_BM_FRAME);
break;
case SLOT_INTRA_SCAN_BM:
case L2_SLOT_INTRA_SCAN_BM:
if (torState == L2_TOR_TX) {
if (L2_GetNodeType(instPtr) != HEAD_NODE) {
if (L2_GetNodeType(instPtr) != L2_NODE_HEAD) {
DBG_ERROR("Only head node can send BM Frame.\n");
Status = FAILURE;
goto routine_err;
@@ -977,13 +980,13 @@ int32_t ScanNet_Routine(L2_INST* instPtr, const L2_RTNE_TABLE_ENTRY* rtneEntry)
/* Antenna setting (reserved.) */
L2_SetupNextSlot(instPtr, L2_TOR_TX, L2_INTRA_BM_FRAME);
break;
case SLOT_INTER_SCAN_2W:
case L2_SLOT_INTER_SCAN_2W:
// TODO:
L2_SetupNextSlot(instPtr, L2_TOR_SUSPEND, L2_INTER_W2_ACQ_FRAME);
break;
case SLOT_INTRA_SCAN_2W:
case L2_SLOT_INTRA_SCAN_2W:
if (torState == L2_TOR_TX) {
if(L2_GetNodeType(instPtr) != HEAD_NODE && L2_isDataAvail(instPtr) == false) {
if(L2_GetNodeType(instPtr) != L2_NODE_HEAD && L2_isDataAvail(instPtr) == false) {
/* Antenna setting (reserved.) */
L2_SetupNextSlot(instPtr, L2_TOR_SUSPEND, L2_INTRA_W2_ACQ_FRAME);
break;
datalink814_ge/src/linklayer/net_service.c
+7 -5
View File
@@ -187,7 +187,7 @@ int32_t ServiceNet_Init(L2_SVC_FSM** serviceFSM) {
void ServiceNet_Reset(L2_SVC_FSM* serviceFSM) {
serviceFSM->isBisar = false;
serviceFSM->isBisarEven = false;
serviceFSM->bisarDst = NONE_ID;
serviceFSM->bisarDst = L2_NONE_ID;
}
void ServiceNet_Destroy(L2_SVC_FSM* serviceFSM){
@@ -205,6 +205,8 @@ void ServiceNet_Destroy(L2_SVC_FSM* serviceFSM){
******************************************************************************/
int32_t ServiceNet_PktHandler(L2_INST* instPtr) {
// TODO:
DBG_INFO("Scan net handling packet...\n");
return SUCCESS;
}
@@ -242,17 +244,17 @@ int32_t ServiceNet_Routine(L2_INST* instPtr, const L2_RTNE_TABLE_ENTRY* rtneEntr
BIT_ARRAY* svcMsg = bit_array_create(L2_MSG_MAX);
if(svcMsg == NULL){
DBG_ERROR("Failed to allocate memory for svcMsg.\n");
return NUM_SLOTS_NONE;
return FAILURE;
}
memset(instPtr->sendPktData, 0xCC, (size_t)(INTRA_SVC_FRAME_LENGTH_MAX));
switch(rtneEntry->slotType){
case SLOT_INTER_SVC:
case L2_SLOT_INTER_SVC:
L2_SetupNextSlot(instPtr, torState, L2_INTER_SVC_FRAME);
break;
case SLOT_INTRA_SVC:
case L2_SLOT_INTRA_SVC:
if(torState == L2_TOR_TX){
//TODO:
memset(instPtr->sendPktData, 0xAA, INTRA_SVC_FRAME_LENGTH_MAX);
memset(instPtr->sendPktData, 0x00, INTRA_SVC_FRAME_LENGTH_MAX);
// Pack PDU header
if(PduHeader_Packing(instPtr, svcMsg, L2_PDU_HEADER_0, rtneEntry->dst0) != SUCCESS){
DBG_ERROR("Failed to packing PduHeader.\n");
datalink814_ge/src/linklayer/time_sync.c
+7 -33
View File
@@ -41,7 +41,6 @@ const TIME_WORD RTT_TIME_NONE = {
static void RTT_StageUpdate(L2_RTT_FSM* rttFsmPtr, L2_RTT_STGE newStage);
static void RTT_GetFrameStart(L2_INST* instPtr, TIME_WORD *tmStamp, L2_TOR_TYPE torType);
void RTT_CalculateTimeGap(const TIME_WORD *tmA, const TIME_WORD *tmB, TIME_WORD *tRound);
/*****************************************************************************/
@@ -183,31 +182,6 @@ void RTT_GetFrameStart(L2_INST* instPtr, TIME_WORD *tmStamp, L2_TOR_TYPE torType
}
}
/*****************************************************************************/
/**
* @brief Calculate tmA - tmA.
*
* @param tmA time stamp A
* @param tmA time stamp B
* @param tRound t round
*
* @return NONE
*
******************************************************************************/
void RTT_CalculateTimeGap(const TIME_WORD *tmA, const TIME_WORD *tmB, TIME_WORD *tRound){
ASSERT(tmA != NULL);
ASSERT(tmB != NULL);
ASSERT(tRound != NULL);
uint64_t timeDiff;
timeDiff = (uint64_t) tmB->frac_part;
timeDiff += ((uint64_t)tmB->int_part) * COUNTE_FRAC_MAX;
timeDiff -= ((uint64_t)tmA->int_part) * COUNTE_FRAC_MAX;
timeDiff -= (uint64_t) tmA->frac_part;
tRound->frac_part = (TIME_FRAC)(timeDiff % COUNTE_FRAC_MAX);
tRound->frac_part = (TIME_INT)(timeDiff / COUNTE_FRAC_MAX);
}
/*****************************************************************************/
/**
* @brief Initialize RTT FSM, allocate memory for FSM instance.
@@ -248,7 +222,7 @@ int32_t RTT_FsmUpdate(L2_INST* instPtr, L2_TOR_TYPE torType) {
DBG_INFO("-------- RTT FSM Update --------\n");
// Stage trans
// For Head Node: Tx->Rx->Tx->Rx
if(L2_GetNodeType(instPtr) == HEAD_NODE){
if(L2_GetNodeType(instPtr) == L2_NODE_HEAD){
switch(rttFsmPtr->rttStage) {
case RTT_REQ1 :
if(torType == L2_TOR_TX){
@@ -278,7 +252,7 @@ int32_t RTT_FsmUpdate(L2_INST* instPtr, L2_TOR_TYPE torType) {
// Update Tr2
RTT_GetFrameStart(instPtr, &(rttRecord->Tr2), torType);
// Calculate TroundA
RTT_CalculateTimeGap(&(rttRecord->Tt1), &(rttRecord->Tr2), &(rttRecord->TroundA));
TimeCtrl_CalculateTimeGap(&(rttRecord->Tt1), &(rttRecord->Tr2), &(rttRecord->TroundA));
}
else{
DBG_WARNING("RTT RSP-1 had not been received [Stage: %d].\n", rttFsmPtr->rttStage);
@@ -307,7 +281,7 @@ int32_t RTT_FsmUpdate(L2_INST* instPtr, L2_TOR_TYPE torType) {
if ( rttFsmPtr->isR2Valid ) {
// Calculate reply A
RTT_CalculateTimeGap(&(rttRecord->Tt3), &(rttRecord->Tr2), &(rttRecord->TreplyA));
TimeCtrl_CalculateTimeGap(&(rttRecord->Tt3), &(rttRecord->Tr2), &(rttRecord->TreplyA));
}
else {
DBG_WARNING("RTT RSP-1 have not been received [Stage: %d].\n", rttFsmPtr->rttStage);
@@ -339,7 +313,7 @@ int32_t RTT_FsmUpdate(L2_INST* instPtr, L2_TOR_TYPE torType) {
// Update Tr4
RTT_GetFrameStart(instPtr, &(rttRecord->Tr4), torType);
// Calculate TroundA
RTT_CalculateTimeGap(&(rttRecord->Tt3), &(rttRecord->Tr4), &(rttRecord->TroundA));
TimeCtrl_CalculateTimeGap(&(rttRecord->Tt3), &(rttRecord->Tr4), &(rttRecord->TroundA));
}
else{
DBG_WARNING("RTT RSP-1 have not been received [Stage: %d].\n", rttFsmPtr->rttStage);
@@ -403,7 +377,7 @@ int32_t RTT_FsmUpdate(L2_INST* instPtr, L2_TOR_TYPE torType) {
RTT_GetFrameStart(instPtr, &(rttRecord->Tt2), torType);
if ( rttFsmPtr->isR1Valid ) {
// Calculate reply B
RTT_CalculateTimeGap(&(rttRecord->Tr1), &(rttRecord->Tt2), &(rttRecord->TreplyB));
TimeCtrl_CalculateTimeGap(&(rttRecord->Tr1), &(rttRecord->Tt2), &(rttRecord->TreplyB));
}
else {
rttRecord->TreplyB = RTT_TIME_NONE;
@@ -435,7 +409,7 @@ int32_t RTT_FsmUpdate(L2_INST* instPtr, L2_TOR_TYPE torType) {
// Update Tr3
RTT_GetFrameStart(instPtr, &(rttRecord->Tr3), torType);
// Calculate TroundB
RTT_CalculateTimeGap(&(rttRecord->Tt2), &(rttRecord->Tr3), &(rttRecord->TroundB));
TimeCtrl_CalculateTimeGap(&(rttRecord->Tt2), &(rttRecord->Tr3), &(rttRecord->TroundB));
}
else{
DBG_WARNING("RTT REQ-2 have not been received [Stage: %d].\n", rttFsmPtr->rttStage);
@@ -462,7 +436,7 @@ int32_t RTT_FsmUpdate(L2_INST* instPtr, L2_TOR_TYPE torType) {
RTT_GetFrameStart(instPtr, &(rttRecord->Tt4), torType);
if ( rttFsmPtr->isR3Valid ) {
// Calculate reply B
RTT_CalculateTimeGap(&(rttRecord->Tr3), &(rttRecord->Tt4), &(rttRecord->TreplyB));
TimeCtrl_CalculateTimeGap(&(rttRecord->Tr3), &(rttRecord->Tt4), &(rttRecord->TreplyB));
// TODO: implement a time adjustment.
}
else {
datalink814_ge/src/main.c
+1 -1
View File
@@ -39,7 +39,7 @@
/************************** Constant Definitions *****************************/
L2_CONFIG l2Config = {
.myType = MEMBER_NODE,
.myType = L2_NODE_MEMBER,
.isInterHead = false,
.myId = 2,
.clustId = 1,
datalink814_ge/src/mpc/mpc_ctrl.c
+6 -6
View File
@@ -206,11 +206,11 @@ int MPC_MsgHandler(MPC_INST* instPtr){
MPC_GetChunk(mpcRxMsgBuff, TEST_MODE_SET_OFFSET, TEST_MODE_SET_LEN, &dataChunk);
// FIXME
if((uint8_t)dataChunk == TEST_MODE_HEAD){
l2Config.myType = HEAD_NODE;
l2Config.myType = L2_NODE_HEAD;
l2Config.myId = 1;
}
else{
l2Config.myType = MEMBER_NODE;
l2Config.myType = L2_NODE_MEMBER;
l2Config.myId = 2;
}
MPC_InsertChunk(mpcTxMsgBuff, TEST_REQ_FPGA_ST_OFFSET, TEST_REQ_FPGA_ST_LEN, 0x01);
@@ -313,7 +313,7 @@ int MPC_SendMsg(MPC_INST* instPtr, MPC_MSG_TYPE type, uint8_t* buffer, uint32_t
*
******************************************************************************/
int MPC_StateUpload(MPC_INST* instPtr , uint8_t* mgmtBuffer , uint32_t mgmtMsgCnt ,
uint8_t* svcBuffer , uint32_t svcMsgCnt , MGMT_MSG_RECORD* mgmtMsg){
uint8_t* svcBuffer , uint32_t svcMsgCnt , L2_MGMT_MSG_RECORD* mgmtMsg){
ASSERT(instPtr != NULL);
int32_t Status = SUCCESS;
uint64_t dataChunk = 0;
@@ -323,13 +323,13 @@ int MPC_StateUpload(MPC_INST* instPtr , uint8_t* mgmtBuffer , uint32_t mgmtMsgC
// Stage
switch (linkInstPtr->mainState) {
case INIT_STATE :
case L2_INIT_STATE :
dataChunk = STATE_STAGE_SETUP;
break;
case INTRA_SEEK_STATE:
case L2_INTRA_SEEK_STATE:
dataChunk = STATE_STAGE_RTNE;
break;
case NORMAL_STATE :
case L2_NORMAL_STATE :
dataChunk = STATE_STAGE_SVC;
break;
default:
datalink814_ge/src/mpc/mpc_ctrl.h
+1 -1
View File
@@ -98,7 +98,7 @@ extern MPC_INST* mpcInstPtr;
int MPC_Init(MPC_INST** instPtr, MPC_CONFIG* configPtr);
int MPC_MsgHandler(MPC_INST* instPtr);
int MPC_StateUpload(MPC_INST* instPtr , uint8_t* mgmtBuffer , uint32_t mgmtMsgCnt
, uint8_t* svcBuffer , uint32_t svcMsgCnt , MGMT_MSG_RECORD* mgmtmsg);
, uint8_t* svcBuffer , uint32_t svcMsgCnt , L2_MGMT_MSG_RECORD* mgmtmsg);
int MPC_SendMsg(MPC_INST* instPtr, MPC_MSG_TYPE type, uint8_t* buffer, uint32_t dlen);
#endif //_MPC_PCIE
datalink814_ge/src/phy_ctrl/phy_ctrl.c
+9 -16
View File
@@ -86,7 +86,7 @@ static int32_t Phy_SetSendData(PHY_INST* instPtr, L1_FRAME_TYPE frameType, uint8
******************************************************************************/
inline bool Phy_IsFrameDetected(PHY_INST* instPtr) {
ASSERT(instPtr != NULL);
if(instPtr->TOR.last == PHY_TOR_RX && instPtr->isAcq && instPtr->isFrameSync) {
if(instPtr->isAcq && instPtr->isFrameSync) {
return true;
}
else {
@@ -107,8 +107,7 @@ inline bool Phy_IsFrameDetected(PHY_INST* instPtr) {
******************************************************************************/
inline bool Phy_IsFrameReceived(PHY_INST* instPtr) {
ASSERT(instPtr != NULL);
if(instPtr->TOR.last == PHY_TOR_RX && instPtr->isAcq
&& instPtr->isFrameSync && instPtr->isDecode) {
if(instPtr->isAcq && instPtr->isFrameSync && instPtr->isDecode) {
return true;
}
else {
@@ -129,13 +128,7 @@ inline bool Phy_IsFrameReceived(PHY_INST* instPtr) {
******************************************************************************/
inline bool Phy_IsFrameValid(PHY_INST* instPtr) {
ASSERT(instPtr != NULL);
if (instPtr->TOR.last == PHY_TOR_RX && instPtr->isAcq && instPtr->isFrameSync
&& instPtr->isDecode && instPtr->isValid) {
return true;
}
else {
return false;
}
return instPtr->isValid;
}
/*****************************************************************************/
@@ -238,11 +231,6 @@ uint32_t Phy_GetFrameLen(L1_FRAME_TYPE frameType) {
void Phy_UpdateState(PHY_INST* instPtr) {
ASSERT(instPtr != NULL);
Phy_RcdShift(&(instPtr->TOR),PHY_TOR_SUSPEND);
Phy_RcdShift(&(instPtr->frameType),L1_NONE_FRAME);
Phy_RcdShift(&(instPtr->antNo), INIT_ANT_NO);
Phy_RcdShift(&(instPtr->beamNo), INIT_BEAM_NO);
Phy_RcdShift(&(instPtr->beamWd), INIT_ANT_WD);
/* Update Frame Sate. */
uint32_t txrxSate = PhyRead(instPtr, TXRX_STATE);
instPtr->isAcq = ((txrxSate & TXRX_STATE_ACQ_MASK) == TXRX_STATE_ACQ_SUCCESS) ? true : false;
@@ -254,7 +242,12 @@ void Phy_UpdateState(PHY_INST* instPtr) {
else {
instPtr->isValid = false;
}
return;
Phy_RcdShift(&(instPtr->TOR),PHY_TOR_SUSPEND);
Phy_RcdShift(&(instPtr->frameType),L1_NONE_FRAME);
Phy_RcdShift(&(instPtr->antNo), INIT_ANT_NO);
Phy_RcdShift(&(instPtr->beamNo), INIT_BEAM_NO);
Phy_RcdShift(&(instPtr->beamWd), INIT_ANT_WD);
}
datalink814_ge/src/time_ctrl/time_ctrl.c
+25
View File
@@ -219,3 +219,28 @@ void TimeCtrl_SetOptimizeStep(TIMECTRL_INST* instPtr, TIME_FRAC* tmFrac) {
ASSERT(tmFrac != NULL);
TMC_Write(instPtr, CNTSTEP_OPT, *tmFrac);
}
/*****************************************************************************/
/**
* @brief Calculate b - a.
*
* @param a time stamp A
* @param b time stamp B
* @param gap t round
*
* @return NONE
*
******************************************************************************/
void TimeCtrl_CalculateTimeGap(const TIME_WORD *a, const TIME_WORD *b, TIME_WORD *gap){
ASSERT(a != NULL);
ASSERT(b != NULL);
ASSERT(gap != NULL);
uint64_t timeDiff;
timeDiff = (uint64_t) b->frac_part;
timeDiff += ((uint64_t)b->int_part) * COUNTE_FRAC_MAX;
timeDiff -= ((uint64_t)a->int_part) * COUNTE_FRAC_MAX;
timeDiff -= (uint64_t) a->frac_part;
gap->frac_part = (TIME_FRAC)(timeDiff % COUNTE_FRAC_MAX);
gap->frac_part = (TIME_INT)(timeDiff / COUNTE_FRAC_MAX);
}
datalink814_ge/src/time_ctrl/time_ctrl.h
+1
View File
@@ -66,6 +66,7 @@ void TimeCtrl_GetCurrentStep(TIMECTRL_INST *instPtr, TIME_FRAC* tmFrac);
void TimeCtrl_SetOptimizeStep(TIMECTRL_INST *instPtr, TIME_FRAC* tmFrac);
void TimeCtrl_TimeAdjust(TIMECTRL_INST *instPtr, const TIME_WORD* tmWord, TIMECTRL_ADJ_TYPE type);
void TimeCtrl_CalculateTimeGap(const TIME_WORD *a, const TIME_WORD *b, TIME_WORD *gap);
#endif /* TIME_SYNC_H_ */
datalink814_ge/unit_test/linklayer_emulate_unit_test.c
+98 -58
View File
@@ -96,7 +96,7 @@ uint8_t mgmtTemplate[INTRA_MGMT_FRAME_LENGTH_MAX] __attribute__ ((aligned (8)))
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
uint8_t rttReqTemplate[INTRA_RTT_FRAME_LENGTH_MAX] __attribute__ ((aligned (8))) = {
uint8_t rttTemplate[INTRA_RTT_FRAME_LENGTH_MAX] __attribute__ ((aligned (8))) = {
0xDC, 0xA3, 0x10, 0x44, 0x98, 0x99, 0x99, 0x99,
0x99, 0x05, 0x00, 0x00, 0x00, 0x50, 0x32, 0x01,
0x00, 0x90, 0x99, 0xFF, 0xFF, 0xFF, 0x99, 0x99,
@@ -130,47 +130,44 @@ uint8_t rttReqTemplate[INTRA_RTT_FRAME_LENGTH_MAX] __attribute__ ((aligned (8)))
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
uint8_t rttRspTemplate[INTRA_RTT_FRAME_LENGTH_MAX] __attribute__ ((aligned (8))) = {
0
};
uint8_t svcTemplate[INTRA_SVC_FRAME_LENGTH_MAX] __attribute__ ((aligned (8))) = {
0xF0, 0xFF, 0x00, 0x21, 0x88, 0x00, 0x00, 0xF0,
0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0x56, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x21, 0xE6, 0x00, 0x21, 0x88, 0x00, 0x00,
0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
0xF0, 0xFF, 0x00, 0x21, 0x88, 0x00, 0x00, 0xF0,
0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0x56, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x21, 0xE6, 0x00, 0x21, 0x88, 0x00, 0x00,
0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0xB5,
};
L2_CONFIG l2Config = {
.myType = HEAD_NODE,
.myType = L2_NODE_HEAD,
.isInterHead = false,
.myId = 1,
.clustId = 1,
@@ -264,7 +261,7 @@ void forge_w2acq_frame(uint8_t* buff, L2_NODE_TYPE nodeType, uint16_t srcId, uin
uint64_t dataChunk;
/* message type */
dataChunk = (nodeType == HEAD_NODE) ? 0 : 1;
dataChunk = (nodeType == L2_NODE_HEAD) ? 0 : 1;
FrameInsertChunk(&bitarr, NS_MSG_INI_TYPE_OFFSET, NS_MSG_INI_TYPE_LEN, dataChunk);
/* source node id */
@@ -276,13 +273,13 @@ void forge_w2acq_frame(uint8_t* buff, L2_NODE_TYPE nodeType, uint16_t srcId, uin
FrameInsertChunk(&bitarr, NS_MSG_INI_LEN_OFFSET, NS_MSG_INI_LEN_LEN, dataChunk);
/* current net stage */
switch (state) {
case INIT_STATE:
case L2_INIT_STATE:
dataChunk = NET_INI_STAGE;
break;
case SEEK_STATE:
case L2_SEEK_STATE:
dataChunk = NET_INTER_SEEK_STAGE;
break;
case NORMAL_STATE:
case L2_NORMAL_STATE:
dataChunk = NET_NORMAL_STAGE;
break;
default:
@@ -310,19 +307,19 @@ void forge_mgmt_frame(uint8_t* buff, L2_NODE_STATE state) {
uint64_t dataChunk;
switch (state) {
case INIT_STATE:
case L2_INIT_STATE:
dataChunk = NET_INI_STAGE;
break;
case NORMAL_STATE:
case L2_NORMAL_STATE:
dataChunk = NET_NORMAL_STAGE;
break;
case INTRA_SEEK_STATE:
case L2_INTRA_SEEK_STATE:
dataChunk = NET_INTRA_SEEK_STAGE;
break;
case INTER_SEEK_STATE:
case L2_INTER_SEEK_STATE:
dataChunk = NET_INTER_SEEK_STAGE;
break;
case SEEK_STATE:
case L2_SEEK_STATE:
dataChunk = NET_SEEK_STAGE;
break;
default:
@@ -332,42 +329,85 @@ void forge_mgmt_frame(uint8_t* buff, L2_NODE_STATE state) {
}
}
void forge_rtt_frame(uint8_t* buff) {
// BIT_ARRAY bitarr = {
// .words = (uint64_t*)buff,
// .num_of_bits = INTRA_BM_FRAME_LENGTH_MAX*8,
// .num_of_words = roundup_bits2words64(INTRA_BM_FRAME_LENGTH_MAX*8),
// .capacity_in_words = roundup_bits2words64(INTRA_BM_FRAME_LENGTH_MAX*8),
// };
memcpy(buff, rttReqTemplate, INTRA_BM_FRAME_LENGTH_MAX);
void forge_rtt_frame(uint8_t* buff, uint16_t srcId, uint16_t destId,
uint16_t clustId, const TIME_WORD* timeStamp, uint32_t doppler) {
BIT_ARRAY bitarr = {
.words = (uint64_t*)buff,
.num_of_bits = INTRA_BM_FRAME_LENGTH_MAX*8,
.num_of_words = roundup_bits2words64(INTRA_BM_FRAME_LENGTH_MAX*8),
.capacity_in_words = roundup_bits2words64(INTRA_BM_FRAME_LENGTH_MAX*8),
};
memcpy(buff, rttTemplate, INTRA_BM_FRAME_LENGTH_MAX);
uint64_t dataChunk;
// INIT MSG
// --source node address.
dataChunk = (srcId & 0x001F) | ((clustId & 0x001F) << 5);
FrameInsertChunk(&bitarr, RTT_REQ_SRC_ADDR_OFFSET, RTT_REQ_SRC_ADDR_LEN, dataChunk);
// --destination node address.
dataChunk = (destId & 0x001F) | ((clustId & 0x001F) << 5);
FrameInsertChunk(&bitarr, RTT_REQ_DST_ADDR_OFFSET, RTT_REQ_DST_ADDR_LEN, dataChunk);
// EXTD MSG
// --Time tag Low
dataChunk = timeStamp->frac_part;
FrameInsertChunk(&bitarr, RTT_RSP_EX_TTAGL_OFFSET + RTT_MSG_LEN, RTT_RSP_EX_TTAGL_LEN, dataChunk);
// --Time tag High.
dataChunk = timeStamp->int_part;
FrameInsertChunk(&bitarr, RTT_RSP_EX_TTAGH_OFFSET + RTT_MSG_LEN, RTT_RSP_EX_TTAGH_LEN, dataChunk);
// CONT MSG
// -- Doppler
dataChunk = doppler;
FrameInsertChunk(&bitarr, RTT_RSP_CONT_DOP_OFFSET + RTT_MSG_LEN * 2, RTT_RSP_CONT_DOP_LEN, dataChunk);
return;
}
TEST(linklayer_master_routine) {
int32_t Status;
Linklayer_Start(linkInstPtr);
TIME_WORD timeStampA, timeStampB, timeGap;
uint32_t timeDiff;
// 30 seconds
for(int i = 0; i < 200*30; i++) {
tmcReg[TIME_INT_REG]++;
if (L2_GetLastTor(linkInstPtr) == L2_TOR_RX && rand() < (RAND_MAX*0.8))
if (L2_GetLastTor(linkInstPtr) == L2_TOR_TX)
{
if (L2_GetLastFrameType(linkInstPtr) == L2_INTRA_TSYNC_FRAME)
{
TimeCtrl_GetCurrentTime(tmcInstPtr, &timeStampA);
timeStampA.int_part--;
timeStampA.frac_part = rand()%1000; // 10us deviation.
}
}
if (L2_GetLastTor(linkInstPtr) == L2_TOR_RX)
{
if(L2_GetLastFrameType(linkInstPtr) == L2_INTRA_W2_ACQ_FRAME) {
forge_w2acq_frame((uint8_t*)phyInstPtr->recvDataAddr, MEMBER_NODE, 2, 1, 1, -1, INIT_STATE);
forge_w2acq_frame((uint8_t*)phyInstPtr->recvDataAddr, L2_NODE_MEMBER, 2, 1, 1, -1, L2_INIT_STATE);
PhyWrite(phyInstPtr, TXRX_STATE, 0x01010101);
PhyWrite(phyInstPtr, RECVDATA_STATE, INTRA_W2ACQ_FRAME_LENGTH_MAX);
}
if (L2_GetLastFrameType(linkInstPtr) == L2_INTRA_MGMT_FRAME)
{
forge_mgmt_frame((uint8_t*)phyInstPtr->recvDataAddr, NORMAL_STATE);
forge_mgmt_frame((uint8_t*)phyInstPtr->recvDataAddr, L2_NORMAL_STATE);
PhyWrite(phyInstPtr, TXRX_STATE, 0x01010101);
PhyWrite(phyInstPtr, RECVDATA_STATE, INTRA_MGMT_FRAME_LENGTH_MAX);
}
if (L2_GetLastFrameType(linkInstPtr) == L2_INTRA_TSYNC_FRAME)
{
timeDiff = Phy_GetTimeComp(L2_L2frame2L1frame(L2_INTRA_TSYNC_FRAME)) + (rand()-RAND_MAX)%1000;
TimeCtrl_CalculateTimeGap(&timeStampA, &timeStampB, &timeGap);
forge_rtt_frame((uint8_t*)phyInstPtr->recvDataAddr, 2, 1, 1, &timeGap , rand()%200000);
PhyWrite(phyInstPtr, TXRX_STATE, 0x01010101);
PhyWrite(phyInstPtr, FSTIME_H, L2_GetLastFrameNum(linkInstPtr));
PhyWrite(phyInstPtr, FSTIME_L, timeDiff);
PhyWrite(phyInstPtr, RECVDATA_STATE, INTRA_MGMT_FRAME_LENGTH_MAX);
}
if (L2_GetLastFrameType(linkInstPtr) == L2_INTRA_SVC_FRAME)
{
forge_mgmt_frame((uint8_t*)phyInstPtr->recvDataAddr, NORMAL_STATE);
forge_mgmt_frame((uint8_t*)phyInstPtr->recvDataAddr, L2_NORMAL_STATE);
PhyWrite(phyInstPtr, TXRX_STATE, 0x01010101);
PhyWrite(phyInstPtr, RECVDATA_STATE, INTRA_MGMT_FRAME_LENGTH_MAX);
}