feat: 按照演示验证修改,完成演示验证

修复错误的checksum, 修复遥测数据偏移量

Makefile

@@ -6,10 +6,10 @@ TARGET_PROJ ?= node
 ifeq ($(TARGET_PROJ), node)
 BUILD_DIR := $(PROJECT)/build/node
 CONFIG_FILE := $(PROJECT)/config/node.json
-else ifeq ($(TARGET_PROJ), ge)
+else ifeq ($(TARGET_PROJ), ground)
 XILINX_VITIS_CLASSIC := y
-BUILD_DIR := $(PROJECT)/build/ge
-CONFIG_FILE := $(PROJECT)/config/ge.json
+BUILD_DIR := $(PROJECT)/build/ground
+CONFIG_FILE := $(PROJECT)/config/ground.json
 else
 $(error Unsupported target PROJECT: $(TARGET_PROJ))
 endif

config/ground.json

@@ -1,7 +1,7 @@
 {
     "project_name": "hsjl_ground",
-    "version": "0.0.0",
-    "hw_design": "hw/hsjl_ground_v0.0.1.xsa",
+    "version": "0.1.0",
+    "hw_design": "hw/hsjl_ground_v0.1.0.xsa",
     "apps": {
         "datalink": {
             "sources": ["src/*"],
@@ -13,11 +13,12 @@
                 "stack_size": "0x20000"
             },
             "build_config": {
-                "debug": {
+
+                "release": {
                     "include-path": ["src/include"],
                     "libraries": ["m"]
                 },
-                "release": {
+                "debug": {
                     "include-path": ["src/include"],
                     "libraries": ["m"]
                 }

config/node.json

@@ -1,7 +1,7 @@
 {
     "project_name": "hsjl_node",
-    "version": "0.0.0",
-    "hw_design": "hw/hsjl_node_v0.0.1.hdf",
+    "version": "0.1.0",
+    "hw_design": "hw/hsjl_node_v0.1.0.hdf",
     "apps": {
         "datalink": {
             "sources": ["src/*"],
@@ -13,11 +13,11 @@
                 "stack_size": "0x20000"
             },
             "build_config": {
-                "debug": {
+                "release": {
                     "include-path": ["src/include"],
                     "libraries": ["m"]
                 },
-                "release": {
+                "debug": {
                     "include-path": ["src/include"],
                     "libraries": ["m"]
                 }

doc/HSJL 上位机串口通信协议.md

@@ -1,18 +1,24 @@
 # HSJL 上位机串口通信协议
 
-> 版本：v1.0
-> 日期：2025 年 6 月 5 日
+> 版本：v1.2
+> 日期：2025 年 6 月 16 日
 
 ---
 
 ## 总览
 
+HSL 上位机服务于 HSJL 演示验证，用于演示 3 节点组网通信功能（1 个主节点，2 个从节点）。
+
 - 物理接口：UART（串口通信）
 - 通信方式：PC 主动下发控制帧，节点响应或上传数据
 - 支持功能：
-  - 指令控制
-  - 图像数据传输
-  - 节点遥测与状态上报
+  - 状态查询：查询板卡的硬件状态
+  - 指令控制：业务速率切换、节点角色切换、时隙表切换等
+  - 图像数据传输：
+    - 业务部分 Payload 为图像数据，数据流向为 PC 下发 → 空口发送 → 空口接收 → 节点上传。
+    - 对于较大的图片，需要 PC 进行数据包切割与重组。
+    - 业务流向为主-从双向，主节点需要向不同从节点发送数据，不同从节点也会给主节点发送数据。
+  - （可选）节点遥测：读取节点工作状态日志，并进行存储。
   
 - UART 串口配置
 
@@ -28,14 +34,20 @@
 
 每帧数据通过串口独立传输，格式如下：
 
+``` mermaid
+block-beta
+  columns 6
+  a["帧头"] b["数据段"] c["Dummy Byte"] d["校验和"] e["数据段长度"] f["帧尾"]
 ```
-[帧头][数据段][Dummy Byte][校验和][数据长度][帧尾]
+
+```
+[帧头][数据段][Dummy Byte][校验和][数据段长度][帧尾]
 ```
 
 | 字段名     | 字节数 (Byte) | 说明 |
 |--|--|--|
 | 帧头       | 2 | 固定值：`0x5A 0x54` |
-| 数据段    | ≤1000 | 业务数据内容 |
+| 数据段    | ≤950 | 业务数据内容 |
 | Dummy Byte | 1 | 固定填充：`0x00` |
 | 校验和     | 1 | 所有**数据段**字节累加和（无符号累加） |
 | 数据段长度 | 2 | 数据段字节数（不含 Dummy/校验/帧尾） |
@@ -57,6 +69,14 @@
 
 数据段格式如下，下发（PC→节点）和上传（节点→PC）均使用一致的格式：
 
+``` mermaid
+block-beta
+  columns 8
+  HEAD["帧头"]:1 DATA["数据段"]:3 DUMMY["Dummy Byte"]:1 CHECKSUM["校验和"]:1 LENGTH["数据段长度"]:1 TAIL["帧尾"]:1
+  
+  NULL11[" "]:1 CMD["指令"]:1 TYPE["节点类型"]:1 PAYLOAD["Payload"]:1 NULL12[" "]:1 NULL13[" "]:1 NULL14[" "]:1 NULL15[" "]:1
+```
+
 ```
 [指令][节点类型][Payload]
 ```
@@ -65,75 +85,120 @@
 | -------- | ------------- | ---------------- |
 | 指令     | 1             | 控制指令         |
 | 节点类型 | 1             | 固定填充：`0xEE` |
-| Payload  | ≤1000         | 由指令类型决定   |
+| Payload  | ≤950          | 由指令类型决定   |
 
 指令类型如下：
 
 | 指令   | 含义                  | 下发 Payload 长度 (Byte) | 上传 Payload 长度 (Byte) |
 | ------ | --------------------- | ------------------------ | ------------------------ |
 | `0xE1` | 自检                  | 0, payload 无数据        | 21                       |
-| `0xE2` | Echo 测试             | ≤1000                    | 与下发长度一致           |
+| `0xE2` | Echo 测试             | ≤950                     | 与下发长度一致           |
 | `0xE3` | 节点配置              | 4                        | None，无上传             |
 | `0x33` | 系统信息 (目前可忽略) | 54                       | None，无上传             |
-| `0xE4` | 发送数据下发          | ≤1000                    | None，无上传             |
-| `0xE5` | 接收数据上传          | None，无下发，自动上传   | ≤1000                    |
+| `0xE4` | 发送数据下发          | ≤950                     | None，无上传             |
+| `0xE5` | 接收数据上传          | None，无下发，自动上传   | ≤950                     |
 | `0xE6` | 遥测                  | 0, payload 无数据        | 188                      |
 
 ### 自检指令
 
-自检指令上传的 Payload 格式如下，顺序存储，共 19 字节：
+自检指令上传的 Payload 格式如下，顺序存储，共 21 字节：
 
-| 字段名                    | 字节数 (Byte) | 说明                                                         |
-| ------------------------- | ------------- | ------------------------------------------------------------ |
-| 节点状态                  | 1             | `0xAA`: 正常<br />`0x55`: 异常                               |
-| FPGA 电压状态             | 1             | `[0]`: VCCPINT 电源轨道状态<br />`[1]`: VCCPAUX 电源轨道状态<br />`[2]`: VCCO_DDR 电源轨道状态<br />`[3]`: VCCINT 电源轨道状态<br />`[4]`: VCCAUX 电源轨道状态<br />`[5]`: VCCBRAM 电源轨道状态<br />以上 `1` 表示正常，`0` 表示异常 |
-| (未使用) 时钟芯片锁定状态 | 1             | `[0]`:  PLL1 锁定状态<br />`[2]`: PLL2 锁定状态<br />以上 `1` 表示锁定，`0` 表示失锁 |
-| (未使用) ADC 锁定状态     | 1             | `[0]`: AD-1 BBPLL 锁定状态<br />`[2]`: AD-2 BBPLL 锁定状态<br />`[4]`: AD-1 RFPLL 锁定状态<br />`[6]`: AD-2 RFPLL 锁定状态<br />以上 `1` 表示锁定，`0` 表示失锁 |
-| (未使用) ADC-1 温度       | 1, int8       | 温度值，有符号数                                             |
-| (未使用) ADC-2 温度       | 1, int8       | 温度值，有符号数                                             |
-| FPGA 温度                 | 1, int8       | 温度值，有符号数                                             |
-| 天线 -1 频率              | 2             | `[15]`: 乒乓环工作指示，`1` 表示 PLL1 工作，`0` 表示 PLL2 工作<br />`[14:0]`: 频率，对应实际频率需要+3700 MHz |
-| 天线 -2 频率              | 2             | `[15]`: 乒乓环工作指示，`1` 表示 PLL1 工作，`0` 表示 PLL2 工作<br />`[14:0]`: 频率，对应实际频率需要+3700 MHz |
-| 天线 -3 频率              | 2             | `[15]`: 乒乓环工作指示，`1` 表示 PLL1 工作，`0` 表示 PLL2 工作<br />`[14:0]`: 频率，对应实际频率需要+3700 MHz |
-| 天线 PLL 锁定状态         | 1             | `[5]`: 天线-1-PLL1 锁定状态<br />`[4]`: 天线-1-PLL2 锁定状态<br />`[3]`: 天线-2-PLL1 锁定状态<br />`[2]`: 天线-2-PLL2 锁定状态<br />`[1]`: 天线-3-PLL1 锁定状态<br />`[0]`: 天线-3-PLL2 锁定状态<br />以上 `1` 表示锁定，`0` 表示失锁 |
-| 天线工作状态              | 1             | `[2]`: 天线-3 工作状态<br />`[1]`: 天线-2 工作状态<br />`[0]`: 天线-1 工作状态<br />以上 `1` 表示抗干扰模式，`0` 表示普通模式 |
-| 天线温度                  | 1, int8       | 温度值，有符号数                                             |
-| 天线状态预留              | 1             | 预留                                                         |
-| 物理层配置 ID             | 1             | 节点 ID，用于区分物理层配置                                  |
-| 额外控制预留              | 3             | 预留                                                         |
+| 字段名                | 字节数 (Byte) | 说明                                                         |
+| --------------------- | ------------- | ------------------------------------------------------------ |
+| 节点状态              | 1             | `0xAA`: 正常<br />`0x55`: 异常                               |
+| FPGA 电压状态         | 1             | `[0]`: VCCPINT 电源轨道状态<br />`[1]`: VCCPAUX 电源轨道状态<br />`[2]`: VCCO_DDR 电源轨道状态<br />`[3]`: VCCINT 电源轨道状态<br />`[4]`: VCCAUX 电源轨道状态<br />`[5]`: VCCBRAM 电源轨道状态<br />以上 `1` 表示正常，`0` 表示异常 |
+| 时钟芯片锁定状态      | 1             | `[0]`:  PLL1 锁定状态<br />`[2]`: PLL2 锁定状态<br />以上 `1` 表示锁定，`0` 表示失锁 |
+| (未使用) ADC 锁定状态 | 1             | `[0]`: AD-1 BBPLL 锁定状态<br />`[2]`: AD-2 BBPLL 锁定状态<br />`[4]`: AD-1 RFPLL 锁定状态<br />`[6]`: AD-2 RFPLL 锁定状态<br />以上 `1` 表示锁定，`0` 表示失锁 |
+| (未使用) ADC-1 温度   | 1, int8       | 温度值，有符号数                                             |
+| (未使用) ADC-2 温度   | 1, int8       | 温度值，有符号数                                             |
+| FPGA 温度             | 1, int8       | 温度值，有符号数                                             |
+| 天线 -1 频率          | 2             | `[15]`: 乒乓环工作指示，`1` 表示 PLL1 工作，`0` 表示 PLL2 工作<br />`[14:0]`: 频率，对应实际频率需要+3700 MHz |
+| 天线 -2 频率          | 2             | `[15]`: 乒乓环工作指示，`1` 表示 PLL1 工作，`0` 表示 PLL2 工作<br />`[14:0]`: 频率，对应实际频率需要+3700 MHz |
+| 天线 -3 频率          | 2             | `[15]`: 乒乓环工作指示，`1` 表示 PLL1 工作，`0` 表示 PLL2 工作<br />`[14:0]`: 频率，对应实际频率需要+3700 MHz |
+| 天线 PLL 锁定状态     | 1             | `[5]`: 天线-1-PLL1 锁定状态<br />`[4]`: 天线-1-PLL2 锁定状态<br />`[3]`: 天线-2-PLL1 锁定状态<br />`[2]`: 天线-2-PLL2 锁定状态<br />`[1]`: 天线-3-PLL1 锁定状态<br />`[0]`: 天线-3-PLL2 锁定状态<br />以上 `1` 表示锁定，`0` 表示失锁 |
+| 天线工作状态          | 1             | `[2]`: 天线-3 工作状态<br />`[1]`: 天线-2 工作状态<br />`[0]`: 天线-1 工作状态<br />以上 `1` 表示抗干扰模式，`0` 表示普通模式 |
+| 天线温度              | 1, int8       | 温度值，有符号数                                             |
+| 天线状态预留          | 1             | 预留                                                         |
+| 物理层配置 ID         | 1             | 节点 ID，用于区分物理层配置                                  |
+| 额外控制预留          | 3             | 预留                                                         |
 
 ### Echo 测试
 
-Echo 测试中节点将 PC 下发的数据直接回传，不做其他处理。
+Echo 测试中节点将 PC 下发的数据直接回传，不做其他处理。Echo 测试数据的 Payload 格式如下，顺序存储，长度可变。
+
+| 字段名   | 字节数 (Byte) | 说明                   |
+| -------- | ------------- | ---------------------- |
+| 数据长度 | 2             | 数据字节数             |
+| 数据     | ≤950          | 长度由数据长度字段决定 |
 
 ### 节点配置指令
 
-节点配置指令下发的 Payload 格式如下，顺序存储，共 19 字节：
+节点配置指令下发的 Payload 格式如下，顺序存储，共 4 字节：
 
-| 字段名     | 字节数 (Byte) | 说明                                                        |
-| ---------- | ------------- | ----------------------------------------------------------- |
-| 节点使能   | 1             | `0xAA`: 启用<br />`0x55`: 停用                              |
-| 节点角色   | 1             | `0x11`: 簇首<br />`0x00`: 成员                              |
-| 业务速率   | 1             | `0x22`:  128 kbps<br />`0x33`: 256 kbps<br />`0x44`: 2 Mbps |
-| 时隙表编号 | 1             | 编号值，0~2                                                 |
+| 字段名               | 字节数 (Byte) | 说明                                                       |
+| -------------------- | ------------- | ---------------------------------------------------------- |
+| 节点使能             | 1             | `0xAA`: 启用<br />`0x55`: 停用                             |
+| 节点 ID              | 1             | `0x01`: 簇首<br />`0x02`~`0x0A`: 成员                      |
+| 业务速率             | 1             | `0x22`: 128 kbps<br />`0x33`: 256 kbps<br />`0x44`: 2 Mbps |
+| 时隙表编号（可扩展） | 1             | 编号值，0~2（可扩展）                                      |
+
+> [!warning]
+>
+> 时隙表单次运行周期为 250 ms，不同时隙表中主从节点数据交互次数、可用从节点 ID 范围不同，**从节点只与主节点进行通信**，目前暂定时隙表如下：
+>
+> - 0 号时隙表，主节点分别给 2 个从节点发送 1 次；每个从节点给主节点发送 1 次。
+> - 1 号时隙表，主节点分别给 2 个从节点发送 4 次；每个从节点给主节点发送 4 次。
+> - 2 号时隙表，待定。
 
 ### 发送数据下发
 
-需注意整个 UART 帧的长度（包括帧头、数据段、Dummy、校验和、数据段长度、帧尾）不超过 1024 Byte。
+发送数据的 Payload 格式如下，顺序存储，长度可变。
+
+```mermaid
+block-beta
+  columns 11
+  HEAD["帧头"]:1 DATA_CHUNK["数据段"]:6 DUMMY["Dummy Byte"]:1 CHECKSUM["校验和"]:1 LENGTH["数据段长度"]:1 TAIL["帧尾"]:1
+  
+  NULL11[" "]:1 CMD["指令"]:1 TYPE["节点类型"]:1 PAYLOAD["Payload"]:4 NULL12[" "]:1 NULL13[" "]:1 NULL14[" "]:1 NULL15[" "]:1
+  
+  NULL21[" "]:1 NULL22[" "]:1 NULL23[" "]:1 DATAID["数据 ID"]:1 DSTID["目的节点 ID"]:1 D_LEN["数据长度"]:1 DATA["数据"]:1 NULL24[" "]:1 NULL25[" "]:1 NULL26[" "]:1 NULL27[" "]:1
+```
+
+| 字段名      | 字节数 (Byte) | 说明                    |
+| ----------- | ------------- | ----------------------- |
+| 数据 ID     | 4             | 数据编号                |
+| 目的节点 ID | 1             | 消息目的节点 ID         |
+| 数据长度    | 2             | 数据长度（不含数据 ID） |
+| 数据        | ≤950          | 长度由数据长度字段决定  |
+
+> [!Warning]
+>
+> 1. 需注意整个 [UART 帧](#UART 帧结构定义)的长度（包括帧头、数据段、Dummy、校验和、数据段长度、帧尾）不超过 1024 Byte。
+> 2. 数据最大长度同时由业务速率档位决定：
+>    - 128 kbps 档位：数据长度最大为 40 Byte。
+>    - 512 kbps 档位：数据长度最大为 265 Byte。
+>    - 2 Mbps 档位：数据长度最大为 1220 Byte，但是受限于 PL buffer 的长度，[UART 帧](#UART 帧结构定义)的长度不超过 1024 Byte。
 
 ### 接收数据上传
 
-接收到的数据将自动打包上传，无需下发指令。
+接收到的数据将自动打包上传，无需下发指令。接收数据的 Payload 格式与发送的格式一致，顺序存储，长度可变。
 
-### 遥测指令
+| 字段名    | 字节数 (Byte) | 说明                    |
+| --------- | ------------- | ----------------------- |
+| 数据 ID   | 4             | 数据编号                |
+| 源节点 ID | 1             | 消息来源节点 ID         |
+| 数据长度  | 2             | 数据长度（不含数据 ID） |
+| 数据      | ≤950          | 长度由数据长度字段决定  |
 
-遥测指令上传的 Payload 由 5 部分组成，顺序存储，共 188 字节：
+### （可选）遥测指令
+
+遥测指令上传的 Payload 由 5 部分组成，顺序存储，共 200 字节：
 
 | 字段名       | 字节数 (Byte) |
 | ------------ | ------------- |
 | 时间戳       | 8             |
 | 总线日志     | 16            |
-| 链路层日志   | 88            |
+| 链路层日志   | 100           |
 | 物理层日志   | 56            |
 | 硬件状态日志 | 20            |
 
@@ -154,7 +219,7 @@ Echo 测试中节点将 PC 下发的数据直接回传，不做其他处理。
 
 #### 链路层日志
 
-链路层日志顺序存储，共 88字节：
+链路层日志顺序存储，共 100 字节：
 
 | 字段名               | 字节数 (Byte) | 说明                                     |
 | -------------------- | ------------- | ---------------------------------------- |
@@ -174,12 +239,15 @@ Echo 测试中节点将 PC 下发的数据直接回传，不做其他处理。
 | 分发帧发送计数器     | 4             | 每发送一次分发帧，计数器+1（仅簇首）     |
 | 分发帧接收计数器     | 4             | 每配置接收一次分发帧，计数器+1（仅成员） |
 | 分发帧接收正确计数器 | 4             | 每正确接收一次分发帧，计数器+1（仅成员） |
-| 网关帧发送计数器     | 4             | 每发送一次网关帧，计数器+1               |
-| 网关帧接收计数器     | 4             | 每配置接收一次网关帧，计数器+1           |
-| 网关帧接收正确计数器 | 4             | 每正确接收一次网关帧，计数器+1           |
-| RTT帧发送计数器      | 4             | 每发送一次RTT帧，计数器+1                |
-| RTT帧接收计数器      | 4             | 每配置接收一次RTT帧，计数器+1            |
-| RTT帧接收正确计数器  | 4             | 每正确接收一次RTT帧，计数器+1            |
+| 网管帧发送计数器     | 4             | 每发送一次网管帧，计数器+1               |
+| 网管帧接收计数器     | 4             | 每配置接收一次网管帧，计数器+1           |
+| 网管帧接收正确计数器 | 4             | 每正确接收一次网管帧，计数器+1           |
+| RTT帧发送计数器      | 4             | 每发送一次 RTT 帧，计数器+1              |
+| RTT帧接收计数器      | 4             | 每配置接收一次 RTT 帧，计数器+1          |
+| RTT帧接收正确计数器  | 4             | 每正确接收一次 RTT 帧，计数器+1          |
+| 业务帧发送计数器     | 4             | 每发送一次业务帧，计数器+1               |
+| 业务帧接收计数器     | 4             | 每配置接收一次业务帧，计数器+1           |
+| 业务帧接收正确计数器 | 4             | 每正确接收一次业务帧，计数器+1           |
 | 时间偏移量记录       | 4, int32      | 记录上一次节点时间和帧同步时间的偏差     |
 | 发送数据ID记录       | 4             | 记录上一次发送数据的ID                   |
 | 接收数据ID记录       | 4             | 记录上一次接收数据的ID                   |

doc/comtool-plugin-hsjl.py

@@ -0,0 +1,455 @@
+'''
+    @brief This is an example plugin, can receive and send data
+    @author
+    @date
+    @license LGPL-3.0
+'''
+from PyQt5.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QTextEdit, QPushButton, QLabel, QScrollArea, QSplitter
+from PyQt5.QtCore import Qt, pyqtSignal
+from PyQt5.QtGui import QFont, QTextCursor
+from struct import Struct
+try:
+    import utils_ui
+    from plugins.base import Plugin_Base
+    from conn import ConnectionStatus
+    from i18n import _
+    from widgets import statusBar
+except ImportError:
+    from COMTool import utils_ui
+    from COMTool.plugins.base import Plugin_Base
+    from COMTool.i18n import _
+    from COMTool.conn import  ConnectionStatus
+    from COMTool.widgets import statusBar
+
+class Plugin(Plugin_Base):
+    id = "HJ DATALINK"
+    name = _("HJ DATALINK")
+    showReceiveDataSignal = pyqtSignal(str)
+
+    def onInit(self, config):
+        '''
+            init params
+        '''
+        default = {
+            "version": 1,
+            "customSendItems": [
+                {
+                    "caption": "自检",
+                    "icon": "fa5.question-circle",
+                    "data": "5A 54 E1 EE 00 CF 02 5A FE"
+                },
+                {
+                    "caption": "数据发送测试 - 40 Byte",
+                    "icon": "fa5.play-circle",
+                    "data": (
+                        "5A 54 E4 EE 00 00 00 00 02 00 28 "
+                        "00 01 02 03 04 05 06 07 "
+                        "08 09 0A 0B 0C 0D 0E 0F "
+                        "10 11 12 13 14 15 16 17 "
+                        "18 19 1A 1B 1C 1D 1E 1F "
+                        "20 21 22 23 24 25 26 27 "
+                        "00 08 31 5A FE"
+                    )
+                },
+                # {
+                #     "caption": "数据发送测试 - 2",
+                #     "icon": "fa5.play-circle",
+                #     "data": ""
+                # },
+                {
+                    "caption": "装订 - 【主 - 0x01】128 kbps，时隙表 0",
+                    "icon": "fa5.play-circle",
+                    "data": "5A 54 E3 EE AA 01 22 00 00 9E 06 5A FE"
+                },
+                {
+                    "caption": "装订 - 【主 - 0x01】512 kbps，时隙表 1",
+                    "icon": "fa5.play-circle",
+                    "data": "5A 54 E3 EE AA 01 33 01 00 B0 06 5A FE"
+                },
+                {
+                    "caption": "装订 - 【主 - 0x01】2 Mbps，时隙表 2",
+                    "icon": "fa5.play-circle",
+                    "data": "5A 54 E3 EE AA 01 44 02 00 C2 06 5A FE"
+                },
+                {
+                    "caption": "装订 - 【主 - 0x01】静默",
+                    "icon": "fa5.play-circle",
+                    "data": "5A 54 E3 EE 55 01 22 00 00 49 06 5A FE"
+                },
+                {
+                    "caption": "装订 - 【从 - 0x02】128 kbps，时隙表 0",
+                    "icon": "fa5.play-circle",
+                    "data": "5A 54 E3 EE AA 02 22 00 00 9F 06 5A FE"
+                },
+                {
+                    "caption": "装订 - 【从 - 0x02】512 kbps，时隙表 1",
+                    "icon": "fa5.play-circle",
+                    "data": "5A 54 E3 EE AA 02 33 01 00 B1 06 5A FE"
+                },
+                {
+                    "caption": "装订 - 【从 - 0x02】2M bps，时隙表 2",
+                    "icon": "fa5.play-circle",
+                    "data": "5A 54 E3 EE AA 02 44 02 00 C3 06 5A FE"
+                },
+                {
+                    "caption": "装订 - 【从 - 0x02】静默",
+                    "icon": "fa5.play-circle",
+                    "data": "5A 54 E3 EE 55 02 22 00 00 4A 06 5A FE"
+                },
+                {
+                    "caption": "装订 - 【从 - 0x03】128 kbps，时隙表 0",
+                    "icon": "fa5.play-circle",
+                    "data": "5A 54 E3 EE AA 03 22 00 00 A0 06 5A FE"
+                },
+                {
+                    "caption": "装订 - 【从 - 0x03】512 kbps，时隙表 1",
+                    "icon": "fa5.play-circle",
+                    "data": "5A 54 E3 EE AA 03 33 01 00 B2 06 5A FE"
+                },
+                {
+                    "caption": "装订 - 【从 - 0x03】2 Mbps，时隙表 2",
+                    "icon": "fa5.play-circle",
+                    "data": "5A 54 E3 EE AA 03 44 02 00 C4 06 5A FE"
+                },
+                {
+                    "caption": "装订 - 【从 - 0x03】静默",
+                    "icon": "fa5.play-circle",
+                    "data": "5A 54 E3 EE 55 03 22 00 00 4B 06 5A FE"
+                },
+                {
+                    "caption": "遥测",
+                    "icon": "fa5.play-circle",
+                    "data": "5A 54 E6 EE 00 D4 02 5A FE"
+                },
+            ]
+        }
+        self.config = config
+        for k in default:
+            if not k in self.config:
+                self.config[k] = default[k]
+
+    def onConnChanged(self, status:ConnectionStatus, msg:str):
+        print("-- connection changed: {}, msg: {}".format(status, msg))
+
+    def onWidgetMain(self, parent):
+        '''
+            main widget, just return a QWidget object
+        '''
+        self.mainWidget = QSplitter(Qt.Vertical)
+        # receive widget
+        self.receiveWidget = QTextEdit("")
+        font = QFont('Consolas, DejaVu Sans Mono, Courier New, monospace, Microsoft YaHei', 10)
+        self.receiveWidget.setFont(font)
+        self.receiveWidget.setLineWrapMode(QTextEdit.NoWrap)
+        # clear button
+        self.clearBtn = QPushButton("")
+        utils_ui.setButtonIcon(self.clearBtn, "mdi6.broom")
+        # send scroll
+        self.customSendScroll = QScrollArea()
+        self.customSendScroll.setMinimumHeight(20)
+        self.customSendScroll.setWidgetResizable(True)
+        self.customSendScroll.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+        self.customSendScroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+        cutomSendItemsWraper = QWidget()
+        self.customSendScroll.setWidget(cutomSendItemsWraper)
+
+        # -- wrapper widget
+        cutomSendItemsWraper0 = QWidget()
+        cutomSendItemsWraper0.setProperty("class", "scrollbar2")
+        layout0 = QVBoxLayout()
+        layout0.setContentsMargins(0,8,0,0)
+        cutomSendItemsWraper0.setLayout(layout0)
+        layout0.addWidget(self.customSendScroll)
+        customSendItemsLayoutWrapper = QVBoxLayout()
+        customSendItemsLayoutWrapper.setContentsMargins(0,0,0,0)
+        cutomSendItemsWraper.setLayout(customSendItemsLayoutWrapper)
+
+        # -- items container
+        self.customItems = QWidget()
+        self.customSendItemsLayout = QVBoxLayout()
+        self.customSendItemsLayout.setContentsMargins(0,0,0,0)
+        self.customItems.setLayout(self.customSendItemsLayout)
+        customSendItemsLayoutWrapper.addWidget(self.customItems)
+        customSendItemsLayoutWrapper.addStretch(0)
+
+        # add widgets
+        self.mainWidget.addWidget(self.receiveWidget)
+        self.mainWidget.addWidget(self.clearBtn)
+        self.mainWidget.addWidget(cutomSendItemsWraper0)
+        self.mainWidget.setStretchFactor(0, 2)
+        self.mainWidget.setStretchFactor(1, 1)
+        self.mainWidget.setStretchFactor(2, 11)
+
+        # event
+        def clearReceived():
+            self.receiveWidget.clear();self.statusBar.clear()
+        self.clearBtn.clicked.connect(clearReceived)
+        return self.mainWidget
+
+    def onWidgetStatusBar(self, parent):
+        self.statusBar = statusBar(rxTxCount=True)
+        return self.statusBar
+
+    def onUiInitDone(self):
+        '''
+            UI init done, you can update your widget here
+            this method runs in UI thread, do not block too long
+        '''
+        newItems = []
+        print(self.config["customSendItems"])
+        for item in self.config["customSendItems"]:
+            print(item)
+            item = self.insertSendItem(item, load=True)
+            newItems.append(item)
+        self.config["customSendItems"] = newItems
+        self.showReceiveDataSignal.connect(self.showReceivedData)
+        # frame struct
+        self.structSelfTestRsp = Struct("<BB B BBBbbb HHHBBbB B 3s")
+        self.structStatusCheckRsp = Struct("<BB Q    IIII    IBBBBIB III III III III III III i II 3s    IIII d Q dBB dB H B 2s    BBBbbb HHHBBbB B 3s")
+        self.structData = Struct("<BB IBH 40s")
+        self.structSysInfo = Struct("<IHI H B I B fff fff fff")
+
+    def insertSendItem(self, item = None, load = False):
+        caption = item["caption"]
+        itemWidget = QWidget()
+        layout = QHBoxLayout()
+        layout.setContentsMargins(0,0,0,0)
+        itemWidget.setLayout(layout)
+        send = QPushButton("")
+        label = QLabel(caption)
+        if (not "icon" in item) or not item["icon"]:
+            item["icon"] = "fa.send"
+        utils_ui.setButtonIcon(send, item["icon"])
+        send.setProperty("class", "smallBtn")
+        def sendCustomData(idx):
+            self.sendCustomItem(self.config["customSendItems"][idx])
+        send.clicked.connect(lambda: sendCustomData(self.customSendItemsLayout.indexOf(itemWidget)))
+        layout.addWidget(label)
+        layout.addWidget(send)
+        self.customSendItemsLayout.addWidget(itemWidget)
+        if not load:
+            self.config["customSendItems"].append(item)
+        return item
+
+    def showReceivedData(self, text: str):
+        curScrollValue = self.receiveWidget.verticalScrollBar().value()
+        self.receiveWidget.moveCursor(QTextCursor.End)
+        endScrollValue = self.receiveWidget.verticalScrollBar().value()
+        self.receiveWidget.insertPlainText(text)
+        if curScrollValue < endScrollValue:
+            self.receiveWidget.verticalScrollBar().setValue(curScrollValue)
+        else:
+            self.receiveWidget.moveCursor(QTextCursor.End)
+
+    def onReceived(self, data : bytes):
+        '''
+            call in receive thread, not UI thread
+        '''
+        self.statusBar.addRx(len(data))
+        ## Apply data validation check
+        if len(data) < 7:
+            self.showReceiveDataSignal.emit("\n### Wrong data format: wrong frame header/tail\n")
+            return
+
+        dataLen = data[-3]
+        if data[0] != 0x5A or data[1] != 0x54 or data[-1] != 0xFE or data[-2] != 0x5A:
+            self.showReceiveDataSignal.emit("\n### Wrong data format: wrong length\n")
+
+        checkSum = 0
+        for i in data[2:-4]:
+            checkSum += i
+        if checkSum & 0xFF != data[-4]:
+            self.showReceiveDataSignal.emit("\n### Wrong data format: wrong check sum\n")
+
+        ## Eval data
+        data = data[2:-5].replace(b'\x00\x54\xFE', b'\x54\xFE')
+        # self.printFrame(data)
+        if data[0] == 0xE1:
+            # eval self test
+            self.showReceiveDataSignal.emit(self.evalSelfTestRsp(data) + "\n")
+        elif data[0] == 0xE6:
+            self.showReceiveDataSignal.emit(self.evalStatusCheckRsp(data) + "\n")
+        elif data[0] == 0xE5:
+            self.showReceiveDataSignal.emit('Retrieved Data Frame:\n' + self.printFrame(data) + "\n")
+        else:
+            self.showReceiveDataSignal.emit(f"\n### Unexpected response code 0x{data[0]:02x}.\n")
+
+    def evalSelfTestRsp(self, data: bytes):
+        try:
+            payload = self.structSelfTestRsp.unpack(data)
+        except :
+            return f"\n### evalSelfTestRsp:: Failed to unpack data (data length {len(data)} byte).\n"
+
+        ret = "----------- 自检回令 -----------\n"
+
+        ret += f"节点编号: 0x{payload[-2]:02X}\n"
+
+        ret += "节点类型: "
+        if payload[1] == 0xEE:
+            ret += f"C频段 (0x{payload[1]:02X})\n"
+        else:
+            ret += f"【未知错误】(0x{payload[1]:02X})\n"
+
+        ret += "自检结果: "
+        if payload[2] == 0xAA:
+            ret += f"正常 (0x{payload[2]:02X})\n"
+        elif payload[2] == 0x55:
+            ret += f"异常 (0x{payload[2]:02X})\n"
+        else:
+            ret += f"【未知错误】(0x{payload[2]:02X})\n"
+
+        hwOffset = 3
+
+        ret += f"FPGA 电压监测: {bin(payload[hwOffset+0])[2:].zfill(8)}\n"
+        ret += f"时钟锁定状态:   {bin(payload[hwOffset+1])[2:].zfill(8)}\n"
+        ret += f"AD 锁定状态:   {bin(payload[hwOffset+2])[2:].zfill(8)}\n"
+        ret += f"AD 温度 1: {payload[hwOffset+3]:>4d}\n"
+        ret += f"AD 温度 2: {payload[hwOffset+4]:>4d}\n"
+        ret += f"FPGA 温度: {payload[hwOffset+5]:>4d}\n"
+        ret += f"天线-1 工作 PLL: {(payload[hwOffset+6] >> 15) & 0x01:>1d}\n"
+        ret += f"天线-1 工作频率: {(payload[hwOffset+6] & 0x7FFF)+3700:>4d}\n"
+        ret += f"天线-2 工作 PLL: {(payload[hwOffset+7] >> 15) & 0x01:>1d}\n"
+        ret += f"天线-2 工作频率: {(payload[hwOffset+7] & 0x7FFF)+3700:>4d}\n"
+        ret += f"天线-3 工作 PLL: {(payload[hwOffset+8] >> 15) & 0x01:>1d}\n"
+        ret += f"天线-3 工作频率: {(payload[hwOffset+8] & 0x7FFF)+3700:>4d}\n"
+        ret += f"天线 PLL 锁定状态: {bin(payload[hwOffset+9])[2:].zfill(8)}\n"
+        ret += f"天线工作模式: {bin(payload[hwOffset+10])[2:].zfill(8)}\n"
+        ret += f"天线温度: {payload[hwOffset+11]:>4d}\n"
+        ret += "--------------------------------\n"
+
+        return ret + '\n' + self.printFrame(data)
+
+    def printFrame(self, data: bytes):
+        ret = ''
+        for i in range(len(data)):
+            ret += f'{data[i]:02X}'
+            ret += '\n' if i%16 == 15 else ' '
+        ret += '\n'
+        return ret
+
+    def evalStatusCheckRsp(self, data: bytes):
+        try:
+            payload = self.structStatusCheckRsp.unpack(data)
+        except :
+            return f"\n### evalStatusCheckRsp:: Failed to unpack data (data length {len(data)} byte).\n"
+
+        ret = "----------- 遥测回令 -----------\n"
+
+        ret += "节点类型: "
+        if payload[1] == 0xEE:
+            ret += f"C频段 (0x{payload[1]:02X})\n"
+        else:
+            ret += f"【未知错误】(0x{payload[1]:02X})\n"
+
+        ret += f"时间戳: {payload[2]/1e5:.2f} ms\n"
+
+        sysbusOffset = 3
+        linkOffset = 7
+        phyOffset = 36
+        hwOffset = 50
+
+        ret += "\n  -- 总线状态\n"
+        ret += f"配置装订:    {payload[sysbusOffset + 0]:08X}\n"
+        ret += f"接收数据计数: {payload[sysbusOffset + 1]:>6d}\n"
+        ret += f"发送数据计数: {payload[sysbusOffset + 2]:>6d}\n"
+        ret += f"遥测请求计数: {payload[sysbusOffset + 3]:>6d}\n"
+
+        ret += "\n  -- 链路层状态\n"
+        ret += f"时元号: {payload[linkOffset + 0]:>6d}\n"
+        ret += f"时隙号: {payload[linkOffset + 1]:>3d}\n"
+
+        ret += "当前角色: "
+        if payload[linkOffset + 2] == 0xAA:
+            ret += f"簇首 (0x{payload[linkOffset + 2]:02X})\n"
+        elif payload[linkOffset + 2] == 0xCC:
+            ret += f"成员 (0x{payload[linkOffset + 2]:02X})\n"
+        else:
+            ret += f"【未知错误】(0x{payload[linkOffset + 2]:02X})\n"
+
+        ret += "网络连接状态: "
+        if payload[linkOffset + 3] == 0x11:
+            ret += f"已连接 (0x{payload[linkOffset + 3]:02X})\n"
+        elif payload[linkOffset + 3] == 0x00:
+            ret += f"未连接 (0x{payload[linkOffset + 3]:02X})\n"
+        else:
+            ret += f"【未知错误】(0x{payload[linkOffset + 3]:02X})\n"
+
+        ret += "网络运行阶段: "
+        if payload[linkOffset + 4] == 0x11:
+            ret += f"建网阶段 (0x{payload[linkOffset + 4]:02X})\n"
+        elif payload[linkOffset + 4] == 0x22:
+            ret += f"业务通信 (0x{payload[linkOffset + 4]:02X})\n"
+        else:
+            ret += f"【未知错误】(0x{payload[linkOffset + 4]:02X})\n"
+
+        ret += f"重建/入网计数: {payload[linkOffset + 5]:>6d}\n"
+        ret += f"通信天线位号:  {payload[linkOffset + 6]:>1d}\n"
+
+        ret += f"建网帧发送计数: {payload[linkOffset + 7]:>6d}\n"
+        ret += f"建网帧接收计数: {payload[linkOffset + 8]:>6d}\n"
+        ret += f"建网帧正确计数: {payload[linkOffset + 9]:>6d}\n"
+        ret += f"应答帧发送计数: {payload[linkOffset + 10]:>6d}\n"
+        ret += f"应答帧接收计数: {payload[linkOffset + 11]:>6d}\n"
+        ret += f"应答帧正确计数: {payload[linkOffset + 12]:>6d}\n"
+        ret += f"分发帧发送计数: {payload[linkOffset + 13]:>6d}\n"
+        ret += f"分发帧接收计数: {payload[linkOffset + 14]:>6d}\n"
+        ret += f"分发帧正确计数: {payload[linkOffset + 15]:>6d}\n"
+        ret += f"网管帧发送计数: {payload[linkOffset + 16]:>6d}\n"
+        ret += f"网管帧接收计数: {payload[linkOffset + 17]:>6d}\n"
+        ret += f"网管帧正确计数: {payload[linkOffset + 18]:>6d}\n"
+        ret += f"RTT 帧发送计数: {payload[linkOffset + 19]:>6d}\n"
+        ret += f"RTT 帧接收计数: {payload[linkOffset + 20]:>6d}\n"
+        ret += f"RTT 帧正确计数: {payload[linkOffset + 21]:>6d}\n"
+        ret += f"业务帧发送计数: {payload[linkOffset + 22]:>6d}\n"
+        ret += f"业务帧接收计数: {payload[linkOffset + 23]:>6d}\n"
+        ret += f"业务帧正确计数: {payload[linkOffset + 24]:>6d}\n"
+        ret += f"时间偏差记录: {payload[linkOffset + 25]/1e2:.2f} us\n"
+        ret += f"发送数据 ID: {payload[linkOffset + 26]:>6d}\n"
+        ret += f"接收数据 ID: {payload[linkOffset + 27]:>6d}\n"
+
+        ret += "\n  -- 物理层状态\n"
+        ret += f"捕获计数:    {payload[phyOffset + 0]:>6d}\n"
+        ret += f"帧同步计数:  {payload[phyOffset + 1]:>6d}\n"
+        ret += f"译码计数:    {payload[phyOffset + 2]:>6d}\n"
+        ret += f"CRC 正确计数:{payload[phyOffset + 3]:>6d}\n"
+        ret += f"多普勒估计:  {payload[phyOffset + 4]:.2f} Hz\n"
+        ret += f"正确接收时刻: {payload[phyOffset + 5]/1e2:.2f} us\n"
+        ret += f"捕获峰均比:  {payload[phyOffset + 6]:.2f}\n"
+        ret += f"捕获相位值:  {payload[phyOffset + 7]:>3d}\n"
+        ret += f"捕获频偏通道: {payload[phyOffset + 8]:>3d}\n"
+        ret += f"帧同步峰均比:   {payload[phyOffset + 9]:.2f}\n"
+        ret += f"帧同步频偏通道: {payload[phyOffset + 10]:>3d}\n"
+        ret += f"交织输入数据幅度统计:\t0x{payload[phyOffset + 11]:04X}\n"
+        ret += f"天线控制模式: {bin(payload[phyOffset + 12])[2:].zfill(8)}\n"
+
+        ret += "\n  -- 硬件状态\n"
+        ret += f"FPGA 电压监测: {bin(payload[hwOffset+0])[2:].zfill(8)}\n"
+        ret += f"时钟锁定状态:   {bin(payload[hwOffset+1])[2:].zfill(8)}\n"
+        ret += f"AD 锁定状态:   {bin(payload[hwOffset+2])[2:].zfill(8)}\n"
+        ret += f"AD 温度 1: {payload[hwOffset+3]:>4d}\n"
+        ret += f"AD 温度 2: {payload[hwOffset+4]:>4d}\n"
+        ret += f"FPGA 温度: {payload[hwOffset+5]:>4d}\n"
+        ret += f"天线-1 工作 PLL: {(payload[hwOffset+6] >> 15) & 0x01:>1d}\n"
+        ret += f"天线-1 工作频率: {(payload[hwOffset+6] & 0x7FFF)+3700:>4d}\n"
+        ret += f"天线-2 工作 PLL: {(payload[hwOffset+7] >> 15) & 0x01:>1d}\n"
+        ret += f"天线-2 工作频率: {(payload[hwOffset+7] & 0x7FFF)+3700:>4d}\n"
+        ret += f"天线-3 工作 PLL: {(payload[hwOffset+8] >> 15) & 0x01:>1d}\n"
+        ret += f"天线-3 工作频率: {(payload[hwOffset+8] & 0x7FFF)+3700:>4d}\n"
+        ret += f"天线 PLL 锁定状态: {bin(payload[hwOffset+9])[2:].zfill(8)}\n"
+        ret += f"天线工作模式: {bin(payload[hwOffset+10])[2:].zfill(8)}\n"
+        ret += f"天线温度: {payload[hwOffset+11]:>4d}\n"
+
+        ret += "--------------------------------\n"
+        return ret + '\n' + self.printFrame(data)
+
+    def onSent(self, ok, msg, length, path):
+        if ok:
+            self.statusBar.addTx(length)
+        else:
+            self.hintSignal.emit("error", _("Error"), _("Send data failed!") + " " + msg)
+
+    def sendCustomItem(self, item):
+        data = item["data"]
+        dateBytes = self.parseSendData(data, encoding = self.configGlobal["encoding"], isHexStr = True)
+        if dateBytes:
+            self.send(dateBytes, callback=self.onSent)

src/dev_profile/ad9528_profile.c

@@ -103,13 +103,13 @@ static ad9528outputSettings_t clockOutputSettings = {
     },
     .outChannelDiv = {
     		5,25,25,5,5,
-			5,5,8,5,5,
-			5,5,10,5
+			5,5,5,5,5,
+			5,5,8,5
     },
     .outFrequency_Hz    = {
             200e6, 40e6, 40e6, 200e6, 200e6,
-			200e6, 200e6, 125e6, 200e6, 200e6,
-			200e6, 200e6, 100e6, 200e6
+			200e6, 200e6, 200e6, 200e6, 200e6,
+			200e6, 200e6, 125e6, 200e6
     }
 };
 

src/hwconfig.c

@@ -25,10 +25,10 @@
 #include "common.h"
 #include "error.h"
 #include "delay.h"
-#include "system_monitor.h"
 #include "hwconfig.h"
 #include "config/app_config.h"
 #include "dev_profile/dev_profile.h"
+#include "systembus/systembus.h"
 #ifdef RFSOC
 #include "xrfdc.h"
 #endif
@@ -511,7 +511,7 @@ uint8_t Hardware_GetLMK04828LockStatus(void)
 	ret |= ((regVal & 0x02) == 0x02) ? CLK_SP_PLL1_LOCK : 0;
 
 	// pll2
-	lmk04828_read(ad9528_inst, 0x0183, &regVal); // [D1] is lock indicator
+	lmk04828_read(lmk04828_inst, 0x0183, &regVal); // [D1] is lock indicator
 	ret |= ((regVal & 0x02) == 0x02) ? CLK_SP_PLL2_LOCK : 0;
 
 	return ret;

src/hwconfig.h

@@ -27,4 +27,5 @@ int8_t Hardware_GetAD9361Temp_1(void);
 int8_t Hardware_GetAD9361Temp_2(void);
 uint8_t Hardware_GetAD9361LockStatus(void);
 uint8_t Hardware_GetHMC7044LockStatus(void);
+uint8_t Hardware_GetAD9528LockStatus(void);
 uint8_t Hardware_GetLMK04828LockStatus(void);

src/main.c

@@ -28,7 +28,6 @@
 #include "error.h"
 #include "timer.h"
 #include "hwconfig.h"
-#include "system_monitor.h"
 #include "config/app_config.h"
 #include "dev_profile/dev_profile.h"
 #include "systembus/systembus.h"
@@ -124,14 +123,19 @@ TMC_CONFIG tmcConfig = {
 
 static SYSBUS_CONFIG sysbusConfig = {
 	.baseAddr = SYSBUS_BASE_ADDR,
-	.txQueueMax = 16U,
-	.rxQueueMax = 16U
+	.txQueueMax = 32U,
+	.rxQueueMax = 32U
+};
+
+static SYSMON_CONFIG sysmonConfig = {
+	.sendQueueMax = 32U,
+	.recvQueueMax = 32U
 };
 
 /*********************** Driver Instance Definitions **************************/
 static struct irq_ctrl_desc *intcDescPtr = NULL; // General interrupt controller descriptor
 static struct timer_desc *logTmPtr = NULL;
-static SYSBUS *sysbusDescPtr = NULL;
+SYSBUS *sysbusDescPtr = NULL;
 static PHY_INST *phyInstPtr = NULL;
 static TMC_INST *tmcInstPtr = NULL;
 L2_INST *linkInstPtr = NULL;
@@ -215,7 +219,7 @@ int32_t SetupInterruptSystem(struct irq_ctrl_desc *descPtr)
 		return Status;
 	}
 
-		/* Initialize linklayer layer interrupt. */
+	/* Initialize linklayer layer interrupt. */
 	Status = irq_trigger_level_set(descPtr, PERIODIC_5MS_INTR_ID, IRQ_EDGE_RISING);
 	if (Status != SUCCESS)
 	{
@@ -448,7 +452,7 @@ int main(void)
 	DBG_PRINT("Application Version: %2d.%2d.%4d.\n", _APP_VER_MAIN, _APP_VER_MINOR, _APP_VER_PATCH);
 
 	/* System Monitor Initialize */
-	Status = SysMonitor_Init();
+	Status = SysMonitor_Init(&sysmonConfig);
 	if (Status == SUCCESS)
 	{
 		DBG_PRINT("System monitor Init SUCCESS! \n");
@@ -555,7 +559,7 @@ int main(void)
 				DBG_ERROR("SystemBus_HandleCmd exit with ErrorCode: %" PRId32 ".\n", Status);
 			}
 		}
-		if (SystemBus_IsRsqPending(sysbusDescPtr) && (!SystemBus_IsTxBusy(sysbusDescPtr)))
+		if (SystemBus_IsRespPending(sysbusDescPtr) && (!SystemBus_IsTxBusy(sysbusDescPtr)))
 		{
 			Status = SystemBus_MakeResp(sysbusDescPtr);
 			if (Status != SUCCESS)

src/networking/link_layer/link_layer.c

@@ -22,7 +22,6 @@
 #include "link_layer.h"
 #include "link_layer_types.h"
 #include "node_list.h"
-#include "msg_def.h"
 #include "error.h"
 #include "common.h"
 #include "util.h"
@@ -884,14 +883,14 @@ int32_t Linklayer_EventHandler(L2_INST *instPtr, const L2_EVENT *l2Event)
 			// Reset scan net FMS for next scan process.
 			L2_Scan_Reset(instPtr->scanFSM);
 			UpdateMainSate(instPtr, L2_INIT_STATE);
-			instPtr->rtneConfig.rtneTable = initTable;
-			instPtr->rtneConfig.rtnePrd = ARRAY_SIZE(initTable);
+//			instPtr->rtneConfig.rtneTable = initTable;
+//			instPtr->rtneConfig.rtnePrd = ARRAY_SIZE(initTable);
 		}
 		else if (instPtr->nextState == L2_NORMAL_STATE)
 		{
 			UpdateMainSate(instPtr, L2_NORMAL_STATE);
-			instPtr->rtneConfig.rtneTable = normalTable;
-			instPtr->rtneConfig.rtnePrd = ARRAY_SIZE(normalTable);
+//			instPtr->rtneConfig.rtneTable = normalTable0;
+//			instPtr->rtneConfig.rtnePrd = ARRAY_SIZE(normalTable0);
 		}
 		else
 		{

src/networking/link_layer/link_layer.h

@@ -24,9 +24,10 @@
 #include "link_layer_types.h"
 #include "schdevent.h"
 #include "node_list.h"
+#include "msg_def.h"
 #include "circ_queue.h"
 #include "../phy_layer/phy_layer.h"
-#include "../../system_monitor.h"
+#include "../../systembus/systembus.h"
 /************************** Constant Definitions *****************************/
 /***************** Macros (Inline Functions) Definitions *********************/
 #define AssertL2Event(instPtr, event) (Linklayer_EventHandler((instPtr), (event)))
@@ -92,8 +93,8 @@ typedef struct
 	int64_t timeDev;	   ///< last time deviation estimation result
 	uint32_t reconnectCnt; ///< reconnect trial count
 
-	PAYLOAD rxLog;
-	PAYLOAD txLog;
+	L2_MSG_RECORD rxLog;
+	L2_MSG_RECORD txLog;
 } L2_LOG;
 
 /**
@@ -129,7 +130,9 @@ typedef struct
 
 /************************** Variable Definitions *****************************/
 extern L2_RTNE_TABLE_ENTRY *initTable[L2_INIT_RTNE_PERIOD];
-extern L2_RTNE_TABLE_ENTRY *normalTable[L2_NORMAL_RTNE_PERIOD];
+extern L2_RTNE_TABLE_ENTRY *normalTable0[L2_INIT_RTNE_PERIOD];
+extern L2_RTNE_TABLE_ENTRY *normalTable1[L2_INIT_RTNE_PERIOD];
+extern L2_RTNE_TABLE_ENTRY *normalTable2[L2_INIT_RTNE_PERIOD];
 /************************** Function Prototypes ******************************/
 /**
  * @defgroup LinkLayer_Main

src/networking/link_layer/link_layer_types.h

@@ -36,7 +36,9 @@
 #define L2_BROADCAST_ID1 0xF1 // broadcast
 #define L2_BROADCAST_ID2 0xF2
 #define L2_BROADCAST_ID3 0xF4
+#define L2_UNICAST_ID 0xF0
 #define L2_NONE_ID 0
+#define L2_HEAD_ID 0x01
 
 // Routine configure
 #define L2_INIT_RTNE_PERIOD 1
@@ -206,7 +208,6 @@ typedef struct
 	uint8_t dst;			   ///< destination node ID
 } L2_RTNE_TABLE_ENTRY;
 
-
 /**
  * @struct L2_SCAN_FSM
  * @brief Linklayer scan process FSM instance

src/networking/link_layer/msg_def.h

@@ -25,11 +25,11 @@
 
 #define L2_PACK_LEN_MAX 2048 // bytes
 
-#define L2_PAYLOAD_LEN_ADV 17
-#define L2_PAYLOAD_LEN_ACK 9
-#define L2_PAYLOAD_LEN_SVC_128K 42
-#define L2_PAYLOAD_LEN_SVC_512K 267
-#define L2_PAYLOAD_LEN_SVC_2M 1222
+#define L2_PAYLOAD_LEN_ADV 15
+#define L2_PAYLOAD_LEN_ACK 7
+#define L2_PAYLOAD_LEN_SVC_128K 40
+#define L2_PAYLOAD_LEN_SVC_512K 265
+#define L2_PAYLOAD_LEN_SVC_2M 1220
 #define L2_MSG_CRC_LEN 1
 
 
@@ -93,8 +93,9 @@ typedef struct
 	float srcPosY;			///< position y
 	float srcPosZ;			///< position z
 	uint32_t srcNetStatTime;///< net start time
-	uint32_t advDataId;		///< advertise payload id
-	uint8_t advData[L2_PAYLOAD_LEN_ADV];	///< advertise payload data
+	uint32_t dataId;		///< advertise payload id
+	uint16_t dataLen;		///< advertise payload length
+	uint8_t data[L2_PAYLOAD_LEN_ADV];	///< advertise payload data
 	uint8_t crc;			///< crc
 } L2_MSG_ADV;
 
@@ -111,8 +112,9 @@ typedef struct
 	float srcSpeedX;		///< speed x
 	float srcSpeedY;		///< speed y
 	float srcSpeedZ;		///< speed z
-	uint32_t ackDataId;		///< acknowledge payload id
-	uint8_t ackData[L2_PAYLOAD_LEN_ACK];		///< acknowledge payload data
+	uint32_t dataId;		///< acknowledge payload id
+	uint16_t dataLen;		///< acknowledge payload length
+	uint8_t data[L2_PAYLOAD_LEN_ACK];		///< acknowledge payload data
 	uint8_t crc;			///< crc
 } L2_MSG_ACK;
 
@@ -129,8 +131,9 @@ typedef struct
 	float srcSpeedX;		///< speed x
 	float srcSpeedY;		///< speed y
 	float srcSpeedZ;		///< speed z
-	uint32_t svcDataId;		///< service payload id
-	uint8_t svcData[L2_PAYLOAD_LEN_SVC_128K];	///< service payload data
+	uint32_t dataId;		///< service payload id
+	uint16_t dataLen;		///< service payload length
+	uint8_t data[L2_PAYLOAD_LEN_SVC_128K];	///< service payload data
 	uint8_t crc;			///< crc
 } L2_MSG_SVC_128K;
 
@@ -147,8 +150,9 @@ typedef struct
 	float srcSpeedX;		///< speed x
 	float srcSpeedY;		///< speed y
 	float srcSpeedZ;		///< speed z
-	uint32_t svcDataId;		///< service payload id
-	uint8_t svcData[L2_PAYLOAD_LEN_SVC_512K];	///< service payload data
+	uint32_t dataId;		///< service payload id
+	uint16_t dataLen;		///< service payload length
+	uint8_t data[L2_PAYLOAD_LEN_SVC_512K];	///< service payload data
 	uint8_t crc;			///< crc
 } L2_MSG_SVC_512K;
 
@@ -165,13 +169,24 @@ typedef struct
 	float srcSpeedX;		///< speed x
 	float srcSpeedY;		///< speed y
 	float srcSpeedZ;		///< speed z
-	uint32_t svcDataId;		///< service payload id
-	uint8_t svcData[L2_PAYLOAD_LEN_SVC_2M];	///< service payload data
+	uint32_t dataId;		///< service payload id
+	uint16_t dataLen;		///< service payload length
+	uint8_t data[L2_PAYLOAD_LEN_SVC_2M];	///< service payload data
 	uint8_t crc;			///< crc
 } L2_MSG_SVC_2M;
 
 #pragma pack(pop) // Restore original packing
 
+/**
+ * @struct SYSMON_SVC_PAYLOAD
+ * @brief Payload struct that holds the entire data packet
+ */
+typedef struct
+{
+	uint32_t dataId;  ///< data identifier
+	uint8_t data[L2_PACK_LEN_MAX];
+} L2_MSG_RECORD;
+
 #endif //__L2_MSG_DEF_H_
 
 /** @} LinkLayer_MSG_Constants*/

src/networking/link_layer/routine_table.c

@@ -25,7 +25,7 @@
 #include "link_layer.h"
 #include "link_layer_types.h"
 
-L2_RTNE_TABLE_ENTRY innerScanSubT[L2_SLOTS_PER_FRAME] =
+L2_RTNE_TABLE_ENTRY tab10Mng10Svc[L2_SLOTS_PER_FRAME] =
 {
 	// 36 slots: advertise of antenna-1 ~ antenna-3
 	// 12 slots: idle for no antenna-4
@@ -121,18 +121,18 @@ L2_RTNE_TABLE_ENTRY innerScanSubT[L2_SLOTS_PER_FRAME] =
 	{L2_SLOT_ACKNOWLEDGE, 0x03, 0x0A, 0x01},
 	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
 	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
 	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
 	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
 	{L2_SLOT_SERVICE, 0x00, 0x01, 0x04},
 	{L2_SLOT_SERVICE, 0x01, 0x01, 0x04},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x05},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x05},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x06},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x06},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x07},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x07},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x08},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x08},
+	{L2_SLOT_SERVICE, 0x00, 0x04, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x04, 0x01},
+	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
+	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
 
 	// 12 slots: network management, head <--> node
 	// 18 slots: message distribution, head ---> node
@@ -140,14 +140,14 @@ L2_RTNE_TABLE_ENTRY innerScanSubT[L2_SLOTS_PER_FRAME] =
 	// 8 slots: service
 	{L2_SLOT_MANAGE, 0x00, 0x01, 0x02},
 	{L2_SLOT_MANAGE, 0x01, 0x01, 0x02},
-	{L2_SLOT_MANAGE, 0x00, 0x01, 0x03},
-	{L2_SLOT_MANAGE, 0x01, 0x01, 0x03},
-	{L2_SLOT_MANAGE, 0x00, 0x01, 0x04},
-	{L2_SLOT_MANAGE, 0x01, 0x01, 0x04},
 	{L2_SLOT_MANAGE, 0x00, 0x02, 0x01},
 	{L2_SLOT_MANAGE, 0x01, 0x02, 0x01},
+	{L2_SLOT_MANAGE, 0x00, 0x01, 0x03},
+	{L2_SLOT_MANAGE, 0x01, 0x01, 0x03},
 	{L2_SLOT_MANAGE, 0x00, 0x03, 0x01},
 	{L2_SLOT_MANAGE, 0x01, 0x03, 0x01},
+	{L2_SLOT_MANAGE, 0x00, 0x01, 0x04},
+	{L2_SLOT_MANAGE, 0x01, 0x01, 0x04},
 	{L2_SLOT_MANAGE, 0x00, 0x04, 0x01},
 	{L2_SLOT_MANAGE, 0x01, 0x04, 0x01},
 	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x02},
@@ -170,24 +170,24 @@ L2_RTNE_TABLE_ENTRY innerScanSubT[L2_SLOTS_PER_FRAME] =
 	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x0A},
 	{L2_SLOT_RTT, 0x00, 0x01, 0x02},
 	{L2_SLOT_RTT, 0x01, 0x01, 0x02},
-	{L2_SLOT_RTT, 0x00, 0x01, 0x03},
-	{L2_SLOT_RTT, 0x01, 0x01, 0x03},
-	{L2_SLOT_RTT, 0x00, 0x01, 0x04},
-	{L2_SLOT_RTT, 0x01, 0x01, 0x04},
 	{L2_SLOT_RTT, 0x00, 0x02, 0x01},
 	{L2_SLOT_RTT, 0x01, 0x02, 0x01},
+	{L2_SLOT_RTT, 0x00, 0x01, 0x03},
+	{L2_SLOT_RTT, 0x01, 0x01, 0x03},
 	{L2_SLOT_RTT, 0x00, 0x03, 0x01},
 	{L2_SLOT_RTT, 0x01, 0x03, 0x01},
+	{L2_SLOT_RTT, 0x00, 0x01, 0x04},
+	{L2_SLOT_RTT, 0x01, 0x01, 0x04},
 	{L2_SLOT_RTT, 0x00, 0x04, 0x01},
 	{L2_SLOT_RTT, 0x01, 0x04, 0x01},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x09},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x09},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x0A},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x0A},
-	{L2_SLOT_SERVICE, 0x00, 0x01, 0x0B},
-	{L2_SLOT_SERVICE, 0x01, 0x01, 0x0B},
-	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x05},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x05},
+	{L2_SLOT_SERVICE, 0x00, 0x05, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x05, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x06},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x06},
+	{L2_SLOT_SERVICE, 0x00, 0x06, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x06, 0x01},
 
 	// 12 slots: network management, head <--> node
 	// 18 slots: message distribution, head ---> node
@@ -195,14 +195,14 @@ L2_RTNE_TABLE_ENTRY innerScanSubT[L2_SLOTS_PER_FRAME] =
 	// 8 slots: service
 	{L2_SLOT_MANAGE, 0x00, 0x01, 0x05},
 	{L2_SLOT_MANAGE, 0x01, 0x01, 0x05},
-	{L2_SLOT_MANAGE, 0x00, 0x01, 0x06},
-	{L2_SLOT_MANAGE, 0x01, 0x01, 0x06},
-	{L2_SLOT_MANAGE, 0x00, 0x01, 0x07},
-	{L2_SLOT_MANAGE, 0x01, 0x01, 0x07},
 	{L2_SLOT_MANAGE, 0x00, 0x05, 0x01},
 	{L2_SLOT_MANAGE, 0x01, 0x05, 0x01},
+	{L2_SLOT_MANAGE, 0x00, 0x01, 0x06},
+	{L2_SLOT_MANAGE, 0x01, 0x01, 0x06},
 	{L2_SLOT_MANAGE, 0x00, 0x06, 0x01},
 	{L2_SLOT_MANAGE, 0x01, 0x06, 0x01},
+	{L2_SLOT_MANAGE, 0x00, 0x01, 0x07},
+	{L2_SLOT_MANAGE, 0x01, 0x01, 0x07},
 	{L2_SLOT_MANAGE, 0x00, 0x07, 0x01},
 	{L2_SLOT_MANAGE, 0x01, 0x07, 0x01},
 	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x02},
@@ -225,24 +225,24 @@ L2_RTNE_TABLE_ENTRY innerScanSubT[L2_SLOTS_PER_FRAME] =
 	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x0A},
 	{L2_SLOT_RTT, 0x00, 0x01, 0x05},
 	{L2_SLOT_RTT, 0x01, 0x01, 0x05},
-	{L2_SLOT_RTT, 0x00, 0x01, 0x06},
-	{L2_SLOT_RTT, 0x01, 0x01, 0x06},
-	{L2_SLOT_RTT, 0x00, 0x01, 0x07},
-	{L2_SLOT_RTT, 0x01, 0x01, 0x07},
 	{L2_SLOT_RTT, 0x00, 0x05, 0x01},
 	{L2_SLOT_RTT, 0x01, 0x05, 0x01},
+	{L2_SLOT_RTT, 0x00, 0x01, 0x06},
+	{L2_SLOT_RTT, 0x01, 0x01, 0x06},
 	{L2_SLOT_RTT, 0x00, 0x06, 0x01},
 	{L2_SLOT_RTT, 0x01, 0x06, 0x01},
+	{L2_SLOT_RTT, 0x00, 0x01, 0x07},
+	{L2_SLOT_RTT, 0x01, 0x01, 0x07},
 	{L2_SLOT_RTT, 0x00, 0x07, 0x01},
 	{L2_SLOT_RTT, 0x01, 0x07, 0x01},
-	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
-	{L2_SLOT_SERVICE, 0x00, 0x04, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x04, 0x01},
-	{L2_SLOT_SERVICE, 0x00, 0x05, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x05, 0x01},
-	{L2_SLOT_SERVICE, 0x00, 0x06, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x06, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x07},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x07},
+	{L2_SLOT_SERVICE, 0x00, 0x07, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x07, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x08},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x08},
+	{L2_SLOT_SERVICE, 0x00, 0x08, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x08, 0x01},
 
 	// 12 slots: network management, head <--> node
 	// 18 slots: message distribution, head ---> node
@@ -250,14 +250,14 @@ L2_RTNE_TABLE_ENTRY innerScanSubT[L2_SLOTS_PER_FRAME] =
 	// 8 slots: service, with one slot idle
 	{L2_SLOT_MANAGE, 0x00, 0x01, 0x08},
 	{L2_SLOT_MANAGE, 0x01, 0x01, 0x08},
-	{L2_SLOT_MANAGE, 0x00, 0x01, 0x09},
-	{L2_SLOT_MANAGE, 0x01, 0x01, 0x09},
-	{L2_SLOT_MANAGE, 0x00, 0x01, 0x0A},
-	{L2_SLOT_MANAGE, 0x01, 0x01, 0x0A},
 	{L2_SLOT_MANAGE, 0x00, 0x08, 0x01},
 	{L2_SLOT_MANAGE, 0x01, 0x08, 0x01},
+	{L2_SLOT_MANAGE, 0x00, 0x01, 0x09},
+	{L2_SLOT_MANAGE, 0x01, 0x01, 0x09},
 	{L2_SLOT_MANAGE, 0x00, 0x09, 0x01},
 	{L2_SLOT_MANAGE, 0x01, 0x09, 0x01},
+	{L2_SLOT_MANAGE, 0x00, 0x01, 0x0A},
+	{L2_SLOT_MANAGE, 0x01, 0x01, 0x0A},
 	{L2_SLOT_MANAGE, 0x00, 0x0A, 0x01},
 	{L2_SLOT_MANAGE, 0x01, 0x0A, 0x01},
 	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x02},
@@ -280,34 +280,597 @@ L2_RTNE_TABLE_ENTRY innerScanSubT[L2_SLOTS_PER_FRAME] =
 	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x0A},
 	{L2_SLOT_RTT, 0x00, 0x01, 0x08},
 	{L2_SLOT_RTT, 0x01, 0x01, 0x08},
-	{L2_SLOT_RTT, 0x00, 0x01, 0x09},
-	{L2_SLOT_RTT, 0x01, 0x01, 0x09},
-	{L2_SLOT_RTT, 0x00, 0x01, 0x0A},
-	{L2_SLOT_RTT, 0x01, 0x01, 0x0A},
 	{L2_SLOT_RTT, 0x00, 0x08, 0x01},
 	{L2_SLOT_RTT, 0x01, 0x08, 0x01},
+	{L2_SLOT_RTT, 0x00, 0x01, 0x09},
+	{L2_SLOT_RTT, 0x01, 0x01, 0x09},
 	{L2_SLOT_RTT, 0x00, 0x09, 0x01},
 	{L2_SLOT_RTT, 0x01, 0x09, 0x01},
+	{L2_SLOT_RTT, 0x00, 0x01, 0x0A},
+	{L2_SLOT_RTT, 0x01, 0x01, 0x0A},
 	{L2_SLOT_RTT, 0x00, 0x0A, 0x01},
 	{L2_SLOT_RTT, 0x01, 0x0A, 0x01},
-	{L2_SLOT_SERVICE, 0x00, 0x08, 0x01},
-	{L2_SLOT_SERVICE, 0x01, 0x08, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x09},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x09},
 	{L2_SLOT_SERVICE, 0x00, 0x09, 0x01},
 	{L2_SLOT_SERVICE, 0x01, 0x09, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x0A},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x0A},
 	{L2_SLOT_SERVICE, 0x00, 0x0A, 0x01},
 	{L2_SLOT_SERVICE, 0x01, 0x0A, 0x01},
+};
+
+L2_RTNE_TABLE_ENTRY tab10Mng3Svc[L2_SLOTS_PER_FRAME] =
+{
+	// 36 slots: advertise of antenna-1 ~ antenna-3
+	// 12 slots: idle for no antenna-4
+	// 2 slots: service slot, set to idle
+	{L2_SLOT_ADVERTISE, 0x00, 0x01, L2_BROADCAST_ID1},
+	{L2_SLOT_ADVERTISE, 0x01, 0x01, L2_BROADCAST_ID1},
+	{L2_SLOT_ADVERTISE, 0x02, 0x01, L2_BROADCAST_ID1},
+	{L2_SLOT_ADVERTISE, 0x03, 0x01, L2_BROADCAST_ID1},
+	{L2_SLOT_ADVERTISE, 0x04, 0x01, L2_BROADCAST_ID1},
+	{L2_SLOT_ADVERTISE, 0x05, 0x01, L2_BROADCAST_ID1},
+	{L2_SLOT_ADVERTISE, 0x06, 0x01, L2_BROADCAST_ID1},
+	{L2_SLOT_ADVERTISE, 0x07, 0x01, L2_BROADCAST_ID1},
+	{L2_SLOT_ADVERTISE, 0x08, 0x01, L2_BROADCAST_ID1},
+	{L2_SLOT_ADVERTISE, 0x09, 0x01, L2_BROADCAST_ID1},
+	{L2_SLOT_ADVERTISE, 0x0A, 0x01, L2_BROADCAST_ID1},
+	{L2_SLOT_ADVERTISE, 0x0B, 0x01, L2_BROADCAST_ID1},
+	{L2_SLOT_ADVERTISE, 0x00, 0x01, L2_BROADCAST_ID2},
+	{L2_SLOT_ADVERTISE, 0x01, 0x01, L2_BROADCAST_ID2},
+	{L2_SLOT_ADVERTISE, 0x02, 0x01, L2_BROADCAST_ID2},
+	{L2_SLOT_ADVERTISE, 0x03, 0x01, L2_BROADCAST_ID2},
+	{L2_SLOT_ADVERTISE, 0x04, 0x01, L2_BROADCAST_ID2},
+	{L2_SLOT_ADVERTISE, 0x05, 0x01, L2_BROADCAST_ID2},
+	{L2_SLOT_ADVERTISE, 0x06, 0x01, L2_BROADCAST_ID2},
+	{L2_SLOT_ADVERTISE, 0x07, 0x01, L2_BROADCAST_ID2},
+	{L2_SLOT_ADVERTISE, 0x08, 0x01, L2_BROADCAST_ID2},
+	{L2_SLOT_ADVERTISE, 0x09, 0x01, L2_BROADCAST_ID2},
+	{L2_SLOT_ADVERTISE, 0x0A, 0x01, L2_BROADCAST_ID2},
+	{L2_SLOT_ADVERTISE, 0x0B, 0x01, L2_BROADCAST_ID2},
+	{L2_SLOT_ADVERTISE, 0x00, 0x01, L2_BROADCAST_ID3},
+	{L2_SLOT_ADVERTISE, 0x01, 0x01, L2_BROADCAST_ID3},
+	{L2_SLOT_ADVERTISE, 0x02, 0x01, L2_BROADCAST_ID3},
+	{L2_SLOT_ADVERTISE, 0x03, 0x01, L2_BROADCAST_ID3},
+	{L2_SLOT_ADVERTISE, 0x04, 0x01, L2_BROADCAST_ID3},
+	{L2_SLOT_ADVERTISE, 0x05, 0x01, L2_BROADCAST_ID3},
+	{L2_SLOT_ADVERTISE, 0x06, 0x01, L2_BROADCAST_ID3},
+	{L2_SLOT_ADVERTISE, 0x07, 0x01, L2_BROADCAST_ID3},
+	{L2_SLOT_ADVERTISE, 0x08, 0x01, L2_BROADCAST_ID3},
+	{L2_SLOT_ADVERTISE, 0x09, 0x01, L2_BROADCAST_ID3},
+	{L2_SLOT_ADVERTISE, 0x0A, 0x01, L2_BROADCAST_ID3},
+	{L2_SLOT_ADVERTISE, 0x0B, 0x01, L2_BROADCAST_ID3},
+	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
+	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
+	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
+	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
+	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
+	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
+	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
+	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
+	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
+	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
+	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
+	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
+	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
+	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
+
+	// 36 slots: acknowledge of member nodes
+	// 14 slots: service
+	{L2_SLOT_ACKNOWLEDGE, 0x00, 0x02, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x01, 0x02, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x02, 0x02, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x03, 0x02, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x00, 0x03, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x01, 0x03, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x02, 0x03, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x03, 0x03, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x00, 0x04, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x01, 0x04, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x02, 0x04, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x03, 0x04, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x00, 0x05, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x01, 0x05, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x02, 0x05, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x03, 0x05, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x00, 0x06, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x01, 0x06, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x02, 0x06, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x03, 0x06, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x00, 0x07, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x01, 0x07, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x02, 0x07, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x03, 0x07, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x00, 0x08, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x01, 0x08, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x02, 0x08, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x03, 0x08, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x00, 0x09, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x01, 0x09, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x02, 0x09, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x03, 0x09, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x00, 0x0A, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x01, 0x0A, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x02, 0x0A, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x03, 0x0A, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+
+	// 12 slots: network management, head <--> node
+	// 18 slots: message distribution, head ---> node
+	// 12 slots: rtt, head <--> node
+	// 8 slots: service
+	{L2_SLOT_MANAGE, 0x00, 0x01, 0x02},
+	{L2_SLOT_MANAGE, 0x01, 0x01, 0x02},
+	{L2_SLOT_MANAGE, 0x00, 0x02, 0x01},
+	{L2_SLOT_MANAGE, 0x01, 0x02, 0x01},
+	{L2_SLOT_MANAGE, 0x00, 0x01, 0x03},
+	{L2_SLOT_MANAGE, 0x01, 0x01, 0x03},
+	{L2_SLOT_MANAGE, 0x00, 0x03, 0x01},
+	{L2_SLOT_MANAGE, 0x01, 0x03, 0x01},
+	{L2_SLOT_MANAGE, 0x00, 0x01, 0x04},
+	{L2_SLOT_MANAGE, 0x01, 0x01, 0x04},
+	{L2_SLOT_MANAGE, 0x00, 0x04, 0x01},
+	{L2_SLOT_MANAGE, 0x01, 0x04, 0x01},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x02},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x02},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x03},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x03},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x04},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x04},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x05},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x05},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x06},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x06},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x07},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x07},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x08},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x08},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x09},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x09},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x0A},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x0A},
+	{L2_SLOT_RTT, 0x00, 0x01, 0x02},
+	{L2_SLOT_RTT, 0x01, 0x01, 0x02},
+	{L2_SLOT_RTT, 0x00, 0x02, 0x01},
+	{L2_SLOT_RTT, 0x01, 0x02, 0x01},
+	{L2_SLOT_RTT, 0x00, 0x01, 0x03},
+	{L2_SLOT_RTT, 0x01, 0x01, 0x03},
+	{L2_SLOT_RTT, 0x00, 0x03, 0x01},
+	{L2_SLOT_RTT, 0x01, 0x03, 0x01},
+	{L2_SLOT_RTT, 0x00, 0x01, 0x04},
+	{L2_SLOT_RTT, 0x01, 0x01, 0x04},
+	{L2_SLOT_RTT, 0x00, 0x04, 0x01},
+	{L2_SLOT_RTT, 0x01, 0x04, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
+
+	// 12 slots: network management, head <--> node
+	// 18 slots: message distribution, head ---> node
+	// 12 slots: rtt, head <--> node
+	// 8 slots: service
+	{L2_SLOT_MANAGE, 0x00, 0x01, 0x05},
+	{L2_SLOT_MANAGE, 0x01, 0x01, 0x05},
+	{L2_SLOT_MANAGE, 0x00, 0x05, 0x01},
+	{L2_SLOT_MANAGE, 0x01, 0x05, 0x01},
+	{L2_SLOT_MANAGE, 0x00, 0x01, 0x06},
+	{L2_SLOT_MANAGE, 0x01, 0x01, 0x06},
+	{L2_SLOT_MANAGE, 0x00, 0x06, 0x01},
+	{L2_SLOT_MANAGE, 0x01, 0x06, 0x01},
+	{L2_SLOT_MANAGE, 0x00, 0x01, 0x07},
+	{L2_SLOT_MANAGE, 0x01, 0x01, 0x07},
+	{L2_SLOT_MANAGE, 0x00, 0x07, 0x01},
+	{L2_SLOT_MANAGE, 0x01, 0x07, 0x01},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x02},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x02},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x03},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x03},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x04},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x04},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x05},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x05},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x06},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x06},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x07},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x07},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x08},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x08},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x09},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x09},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x0A},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x0A},
+	{L2_SLOT_RTT, 0x00, 0x01, 0x05},
+	{L2_SLOT_RTT, 0x01, 0x01, 0x05},
+	{L2_SLOT_RTT, 0x00, 0x05, 0x01},
+	{L2_SLOT_RTT, 0x01, 0x05, 0x01},
+	{L2_SLOT_RTT, 0x00, 0x01, 0x06},
+	{L2_SLOT_RTT, 0x01, 0x01, 0x06},
+	{L2_SLOT_RTT, 0x00, 0x06, 0x01},
+	{L2_SLOT_RTT, 0x01, 0x06, 0x01},
+	{L2_SLOT_RTT, 0x00, 0x01, 0x07},
+	{L2_SLOT_RTT, 0x01, 0x01, 0x07},
+	{L2_SLOT_RTT, 0x00, 0x07, 0x01},
+	{L2_SLOT_RTT, 0x01, 0x07, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
+
+	// 12 slots: network management, head <--> node
+	// 18 slots: message distribution, head ---> node
+	// 12 slots: rtt, head <--> node
+	// 8 slots: service, with one slot idle
+	{L2_SLOT_MANAGE, 0x00, 0x01, 0x08},
+	{L2_SLOT_MANAGE, 0x01, 0x01, 0x08},
+	{L2_SLOT_MANAGE, 0x00, 0x08, 0x01},
+	{L2_SLOT_MANAGE, 0x01, 0x08, 0x01},
+	{L2_SLOT_MANAGE, 0x00, 0x01, 0x09},
+	{L2_SLOT_MANAGE, 0x01, 0x01, 0x09},
+	{L2_SLOT_MANAGE, 0x00, 0x09, 0x01},
+	{L2_SLOT_MANAGE, 0x01, 0x09, 0x01},
+	{L2_SLOT_MANAGE, 0x00, 0x01, 0x0A},
+	{L2_SLOT_MANAGE, 0x01, 0x01, 0x0A},
+	{L2_SLOT_MANAGE, 0x00, 0x0A, 0x01},
+	{L2_SLOT_MANAGE, 0x01, 0x0A, 0x01},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x02},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x02},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x03},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x03},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x04},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x04},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x05},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x05},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x06},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x06},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x07},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x07},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x08},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x08},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x09},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x09},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x0A},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x0A},
+	{L2_SLOT_RTT, 0x00, 0x01, 0x08},
+	{L2_SLOT_RTT, 0x01, 0x01, 0x08},
+	{L2_SLOT_RTT, 0x00, 0x08, 0x01},
+	{L2_SLOT_RTT, 0x01, 0x08, 0x01},
+	{L2_SLOT_RTT, 0x00, 0x01, 0x09},
+	{L2_SLOT_RTT, 0x01, 0x01, 0x09},
+	{L2_SLOT_RTT, 0x00, 0x09, 0x01},
+	{L2_SLOT_RTT, 0x01, 0x09, 0x01},
+	{L2_SLOT_RTT, 0x00, 0x01, 0x0A},
+	{L2_SLOT_RTT, 0x01, 0x01, 0x0A},
+	{L2_SLOT_RTT, 0x00, 0x0A, 0x01},
+	{L2_SLOT_RTT, 0x01, 0x0A, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01}
+};
+
+L2_RTNE_TABLE_ENTRY tab3Mng3Svc[L2_SLOTS_PER_FRAME] =
+{
+	// ---------------------------------------
+	// 1 round of advertise: 36 slots
+	// 1 round of acknowledge: 8 slots
+	// 1 round of manage: 8 slots
+	// 1 round of distribute: 4 slots
+	// 1 round of rtt: 8 slots
+	// 23 rounds of 3 node communication: 184 slots
+	// 2 idle slots
+	// ---------------------------------------
+	// 36 slots: advertise of antenna-1 ~ antenna-3
+	// 8 slots: acknowledge of 2 member nodes
+	// 8 slots: service slot
+	{L2_SLOT_ADVERTISE, 0x00, 0x01, L2_BROADCAST_ID1},
+	{L2_SLOT_ADVERTISE, 0x01, 0x01, L2_BROADCAST_ID1},
+	{L2_SLOT_ADVERTISE, 0x02, 0x01, L2_BROADCAST_ID1},
+	{L2_SLOT_ADVERTISE, 0x03, 0x01, L2_BROADCAST_ID1},
+	{L2_SLOT_ADVERTISE, 0x04, 0x01, L2_BROADCAST_ID1},
+	{L2_SLOT_ADVERTISE, 0x05, 0x01, L2_BROADCAST_ID1},
+	{L2_SLOT_ADVERTISE, 0x06, 0x01, L2_BROADCAST_ID1},
+	{L2_SLOT_ADVERTISE, 0x07, 0x01, L2_BROADCAST_ID1},
+	{L2_SLOT_ADVERTISE, 0x08, 0x01, L2_BROADCAST_ID1},
+	{L2_SLOT_ADVERTISE, 0x09, 0x01, L2_BROADCAST_ID1},
+	{L2_SLOT_ADVERTISE, 0x0A, 0x01, L2_BROADCAST_ID1},
+	{L2_SLOT_ADVERTISE, 0x0B, 0x01, L2_BROADCAST_ID1},
+	{L2_SLOT_ADVERTISE, 0x00, 0x01, L2_BROADCAST_ID2},
+	{L2_SLOT_ADVERTISE, 0x01, 0x01, L2_BROADCAST_ID2},
+	{L2_SLOT_ADVERTISE, 0x02, 0x01, L2_BROADCAST_ID2},
+	{L2_SLOT_ADVERTISE, 0x03, 0x01, L2_BROADCAST_ID2},
+	{L2_SLOT_ADVERTISE, 0x04, 0x01, L2_BROADCAST_ID2},
+	{L2_SLOT_ADVERTISE, 0x05, 0x01, L2_BROADCAST_ID2},
+	{L2_SLOT_ADVERTISE, 0x06, 0x01, L2_BROADCAST_ID2},
+	{L2_SLOT_ADVERTISE, 0x07, 0x01, L2_BROADCAST_ID2},
+	{L2_SLOT_ADVERTISE, 0x08, 0x01, L2_BROADCAST_ID2},
+	{L2_SLOT_ADVERTISE, 0x09, 0x01, L2_BROADCAST_ID2},
+	{L2_SLOT_ADVERTISE, 0x0A, 0x01, L2_BROADCAST_ID2},
+	{L2_SLOT_ADVERTISE, 0x0B, 0x01, L2_BROADCAST_ID2},
+	{L2_SLOT_ADVERTISE, 0x00, 0x01, L2_BROADCAST_ID3},
+	{L2_SLOT_ADVERTISE, 0x01, 0x01, L2_BROADCAST_ID3},
+	{L2_SLOT_ADVERTISE, 0x02, 0x01, L2_BROADCAST_ID3},
+	{L2_SLOT_ADVERTISE, 0x03, 0x01, L2_BROADCAST_ID3},
+	{L2_SLOT_ADVERTISE, 0x04, 0x01, L2_BROADCAST_ID3},
+	{L2_SLOT_ADVERTISE, 0x05, 0x01, L2_BROADCAST_ID3},
+	{L2_SLOT_ADVERTISE, 0x06, 0x01, L2_BROADCAST_ID3},
+	{L2_SLOT_ADVERTISE, 0x07, 0x01, L2_BROADCAST_ID3},
+	{L2_SLOT_ADVERTISE, 0x08, 0x01, L2_BROADCAST_ID3},
+	{L2_SLOT_ADVERTISE, 0x09, 0x01, L2_BROADCAST_ID3},
+	{L2_SLOT_ADVERTISE, 0x0A, 0x01, L2_BROADCAST_ID3},
+	{L2_SLOT_ADVERTISE, 0x0B, 0x01, L2_BROADCAST_ID3},
+	{L2_SLOT_ACKNOWLEDGE, 0x00, 0x02, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x01, 0x02, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x02, 0x02, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x03, 0x02, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x00, 0x03, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x01, 0x03, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x02, 0x03, 0x01},
+	{L2_SLOT_ACKNOWLEDGE, 0x03, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+
+	// 50 slots: service
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
+
+	// 8 slots: network management, head <--> node
+	// 4 slots: message distribution, head ---> node
+	// 8 slots: rtt, head <--> node
+	// 30 slots: service
+	{L2_SLOT_MANAGE, 0x00, 0x01, 0x02},
+	{L2_SLOT_MANAGE, 0x01, 0x01, 0x02},
+	{L2_SLOT_MANAGE, 0x00, 0x02, 0x01},
+	{L2_SLOT_MANAGE, 0x01, 0x02, 0x01},
+	{L2_SLOT_MANAGE, 0x00, 0x01, 0x03},
+	{L2_SLOT_MANAGE, 0x01, 0x01, 0x03},
+	{L2_SLOT_MANAGE, 0x00, 0x03, 0x01},
+	{L2_SLOT_MANAGE, 0x01, 0x03, 0x01},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x02},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x02},
+	{L2_SLOT_DISTRIBUTE, 0x00, 0x01, 0x03},
+	{L2_SLOT_DISTRIBUTE, 0x01, 0x01, 0x03},
+	{L2_SLOT_RTT, 0x00, 0x01, 0x02},
+	{L2_SLOT_RTT, 0x01, 0x01, 0x02},
+	{L2_SLOT_RTT, 0x00, 0x02, 0x01},
+	{L2_SLOT_RTT, 0x01, 0x02, 0x01},
+	{L2_SLOT_RTT, 0x00, 0x01, 0x03},
+	{L2_SLOT_RTT, 0x01, 0x01, 0x03},
+	{L2_SLOT_RTT, 0x00, 0x03, 0x01},
+	{L2_SLOT_RTT, 0x01, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+
+	// 50 slots: service
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
+
+	// 48 slots: service
+	// 2 slots: idle
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x02},
+	{L2_SLOT_SERVICE, 0x00, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x02, 0x01},
+	{L2_SLOT_SERVICE, 0x00, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x01, 0x01, 0x03},
+	{L2_SLOT_SERVICE, 0x00, 0x03, 0x01},
+	{L2_SLOT_SERVICE, 0x01, 0x03, 0x01},
 	{L2_SLOT_IDLE, 0x00, 0x00, 0x00},
 	{L2_SLOT_IDLE, 0x00, 0x00, 0x00}
 };
 
 L2_RTNE_TABLE_ENTRY *initTable[L2_INIT_RTNE_PERIOD] =
 {
-	innerScanSubT
+	tab10Mng10Svc
 };
 
-L2_RTNE_TABLE_ENTRY *normalTable[L2_NORMAL_RTNE_PERIOD] =
+L2_RTNE_TABLE_ENTRY *normalTable0[L2_INIT_RTNE_PERIOD] =
 {
-	innerScanSubT
+	tab10Mng10Svc
+};
+
+L2_RTNE_TABLE_ENTRY *normalTable1[L2_INIT_RTNE_PERIOD] =
+{
+	tab10Mng3Svc
+};
+
+L2_RTNE_TABLE_ENTRY *normalTable2[L2_INIT_RTNE_PERIOD] =
+{
+	tab3Mng3Svc
 };
 
 /** @} RoutineTable*/

src/networking/link_layer/scan.c

@@ -63,13 +63,15 @@ static int32_t ScanMsg_Packing(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t dst
 	case L2_FRAME_ADV:
 	{
 		L2_MSG_ADV *message = (L2_MSG_ADV *)(instPtr->sendPktData);
+		size_t msgLen = sizeof(L2_MSG_ADV);
+		size_t maxDataLen = L2_PAYLOAD_LEN_ADV;
 
 		// Common section of link layer package
 		message->common.frameNum = L2_GetNextFrameNum(instPtr);
 		message->common.slotNum = L2_GetNextSlotNum(instPtr);
 		message->common.src = L2_GetNodeId(instPtr);
 		message->common.dst = dstId;
-		message->common.msgType = L2_FRAME_ADV;
+		message->common.msgType = type;
 
 		// insert position and speed info
 		SysMonitor_GetSysinfo(&(instPtr->sysInfo));
@@ -80,16 +82,14 @@ static int32_t ScanMsg_Packing(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t dst
 		// Insert net start time
 		message->srcNetStatTime = instPtr->netStartTime;
 
-		// Packing extra payload
-		SysMonitor_GetSendPayload(message->advData, &(message->advDataId), L2_PAYLOAD_LEN_ADV);
-		if (message->advDataId == DATA_ID_NONE)
-		{
-			memset(message->advData, 0xAA, L2_PAYLOAD_LEN_ADV);
-		}
+		// TODO: Packing extra payload
+		message->dataId = DATA_ID_NONE;
+		message->dataLen = 0;
+		memset(message->data, 0xAA, maxDataLen);
 
 		// Append CRC
 		uint32_t crcVal;
-		Status = L2_CrcGen((uint8_t *)message, sizeof(L2_MSG_ADV) - L2_MSG_CRC_LEN, L2_CRC8_31, &crcVal);
+		Status = L2_CrcGen((uint8_t *)message, msgLen - L2_MSG_CRC_LEN, L2_CRC8_31, &crcVal);
 		if (Status != SUCCESS)
 		{
 			DBG_ERROR("Fail to generate CRC, error code: %" PRId32 ".\n", Status);
@@ -98,14 +98,16 @@ static int32_t ScanMsg_Packing(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t dst
 		message->crc = (uint8_t)crcVal;
 
 		// Logging...
-		memcpy(instPtr->log.txLog.data, message, sizeof(L2_MSG_ADV));
-		instPtr->log.txLog.dataId = message->advDataId;
+		instPtr->log.txLog.dataId = message->dataId;
+		memcpy(instPtr->log.txLog.data, message, msgLen);
 
 		break;
 	}
 	case L2_FRAME_ACK:
 	{
 		L2_MSG_ACK *message = (L2_MSG_ACK *)(instPtr->sendPktData);
+		size_t msgLen = sizeof(L2_MSG_ACK);
+		size_t maxDataLen = L2_PAYLOAD_LEN_ACK;
 
 		// Common section of link layer package
 		message->common.frameNum = L2_GetNextFrameNum(instPtr);
@@ -123,16 +125,14 @@ static int32_t ScanMsg_Packing(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t dst
 		message->srcSpeedY = instPtr->sysInfo.vY;
 		message->srcSpeedZ = instPtr->sysInfo.vZ;
 
-		// Packing extra payload
-		SysMonitor_GetSendPayload(message->ackData, &(message->ackDataId), L2_PAYLOAD_LEN_ACK);
-		if (message->ackDataId == DATA_ID_NONE)
-		{
-			memset(message->ackData, 0xAA, L2_PAYLOAD_LEN_ACK);
-		}
+		// TODO: Packing extra payload
+		message->dataId = DATA_ID_NONE;
+		message->dataLen = 0;
+		memset(message->data, 0xAA, maxDataLen);
 
 		// Append CRC
 		uint32_t crcVal;
-		Status = L2_CrcGen((uint8_t *)message, sizeof(L2_MSG_ACK) - L2_MSG_CRC_LEN, L2_CRC8_31, &crcVal);
+		Status = L2_CrcGen((uint8_t *)message, msgLen - L2_MSG_CRC_LEN, L2_CRC8_31, &crcVal);
 		if (Status != SUCCESS)
 		{
 			DBG_ERROR("Fail to generate CRC, error code: %" PRId32 ".\n", Status);
@@ -141,8 +141,8 @@ static int32_t ScanMsg_Packing(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t dst
 		message->crc = crcVal;
 
 		// Logging...
-		memcpy(instPtr->log.txLog.data, message, sizeof(L2_MSG_ACK));
-		instPtr->log.txLog.dataId = message->ackDataId;
+		instPtr->log.txLog.dataId = message->dataId;
+		memcpy(instPtr->log.txLog.data, message, msgLen);
 
 		break;
 	}
@@ -168,7 +168,6 @@ 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_FRAME_NONE;
 	L2_FrameGetChunk(msg, L2_MSG_TYPE, L2_MSG_TYPE_LEN, &frameType);
 
@@ -184,6 +183,8 @@ int32_t L2_Scan_PktHandler(L2_INST *instPtr, uint8_t *msg)
 		}
 
 		L2_MSG_ADV *message = (L2_MSG_ADV *)msg;
+		size_t msgLen = sizeof(L2_MSG_ADV);
+		size_t maxDataLen = L2_PAYLOAD_LEN_ADV;
 
 		// Update node status.
 		uint8_t nodeId = message->common.src;
@@ -241,13 +242,25 @@ int32_t L2_Scan_PktHandler(L2_INST *instPtr, uint8_t *msg)
 		// Time sync.
 		L2_TimeAdjust(instPtr, &(instPtr->log.timeDev));
 
-		// Get data payload
-		uint32_t dataId = message->advDataId;
-		SysMonitor_UpdateRecvPayload(message->advData, dataId, L2_PAYLOAD_LEN_ADV);
+		// Get data payload & upload
+		if (message->dataId != DATA_ID_NONE)
+		{
+			if (message->dataLen > maxDataLen)
+			{
+				DBG_ERROR("Payload length" PRIu16 " out of range.\n", message->dataLen);
+				return EIGNORE;
+			}
+			SYSBUS_SVC_PLD *recvPayload = calloc(1, sizeof(SYSBUS_SVC_PLD));
+			recvPayload->dataId = message->dataId;
+			recvPayload->nodeId = message->common.src;
+			recvPayload->dataLen = message->dataLen;
+			memcpy(recvPayload->data, message->data, message->dataLen);
+			SysMonitor_GenRecvRsp(recvPayload);
+		}
 
 		// Logging...
-		memcpy(instPtr->log.rxLog.data, msg, sizeof(L2_MSG_ADV));
-		instPtr->log.rxLog.dataId = dataId;
+		instPtr->log.rxLog.dataId = message->dataId;
+		memcpy(instPtr->log.rxLog.data, message, msgLen);
 
 		Status = SUCCESS;
 		break;
@@ -262,6 +275,8 @@ int32_t L2_Scan_PktHandler(L2_INST *instPtr, uint8_t *msg)
 		}
 
 		L2_MSG_ACK *message = (L2_MSG_ACK *)msg;
+		size_t msgLen = sizeof(L2_MSG_ACK);
+		size_t dataLen = L2_PAYLOAD_LEN_ACK;
 
 		// Update node status.
 		uint8_t nodeId = message->common.src;
@@ -310,13 +325,17 @@ int32_t L2_Scan_PktHandler(L2_INST *instPtr, uint8_t *msg)
 			(void)AssertL2Event(instPtr, &l2Event);
 		}
 
-		// Get data payload
-		uint32_t dataId = message->ackDataId;
-		SysMonitor_UpdateRecvPayload(message->ackData, dataId, L2_PAYLOAD_LEN_ACK);
+		// Get data payload & upload
+		SYSBUS_SVC_PLD recvPayload;
+		recvPayload.dataId = message->dataId;
+		recvPayload.nodeId = message->common.src;
+		recvPayload.dataLen = message->dataLen;
+		memcpy(recvPayload.data, message->data, dataLen);
+		SysMonitor_GenRecvRsp(&recvPayload);
 
 		// Logging...
-		memcpy(instPtr->log.rxLog.data, msg, sizeof(L2_MSG_ACK));
-		instPtr->log.rxLog.dataId = dataId;
+		instPtr->log.rxLog.dataId = message->dataId;
+		memcpy(instPtr->log.rxLog.data, message, msgLen);
 
 		Status = SUCCESS;
 		break;
@@ -490,7 +509,7 @@ int32_t L2_Scan_Routine(L2_INST *instPtr, const L2_RTNE_TABLE_ENTRY *rtneEntry)
 			antIndex = PHY_ANT_INDEX_NONE;
 			torState = L2_TOR_SUSPEND;
 		}
-		(void)Phy_SetAntIndex(instPtr->config.phyInstPtr, antIndex);
+		(void)Phy_SetAntIndex(phyRef, antIndex);
 		(void)L2_SetupNextSlot(instPtr, torState, L2_FRAME_ADV);
 		break;
 	case L2_SLOT_ACKNOWLEDGE:
@@ -523,7 +542,7 @@ int32_t L2_Scan_Routine(L2_INST *instPtr, const L2_RTNE_TABLE_ENTRY *rtneEntry)
 			antIndex = PHY_ANT_INDEX_NONE;
 			torState = L2_TOR_SUSPEND;
 		}
-		(void)Phy_SetAntIndex(instPtr->config.phyInstPtr, antIndex);
+		(void)Phy_SetAntIndex(phyRef, antIndex);
 		(void)L2_SetupNextSlot(instPtr, torState, L2_FRAME_ACK);
 		break;
 	default:

src/networking/link_layer/service.c

@@ -185,7 +185,7 @@ static int32_t Service_Packing128K(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t
 
 	L2_MSG_SVC_128K *message = (L2_MSG_SVC_128K *)(instPtr->sendPktData);
 	size_t msgLen = sizeof(L2_MSG_SVC_128K);
-	size_t dataLen = L2_PAYLOAD_LEN_SVC_128K;
+	size_t maxDataLen = L2_PAYLOAD_LEN_SVC_128K;
 
 	// insert position and speed info
 	SysMonitor_GetSysinfo(&(instPtr->sysInfo));
@@ -196,11 +196,36 @@ static int32_t Service_Packing128K(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t
 	message->srcSpeedY = instPtr->sysInfo.vY;
 	message->srcSpeedZ = instPtr->sysInfo.vZ;
 
-	// Packing extra payload
-	SysMonitor_GetSendPayload(message->svcData, &(message->svcDataId), dataLen);
-	if (message->svcDataId == DATA_ID_NONE)
+	// Pack extra payload
+	if (type == L2_FRAME_SVC)
 	{
-		memset(message->svcData, 0xAA, dataLen);
+		// Packing extra payload
+		SYSBUS_SVC_PLD *sendPayload;
+		SysMonitor_GetSendPayload(&sendPayload);
+		if(sendPayload == NULL)
+		{
+			message->common.dst = L2_NONE_ID;
+			message->dataId = DATA_ID_NONE;
+			message->dataLen = 0;
+			memset(message->data, 0xAA, maxDataLen);
+		}
+		else
+		{
+//			message->common.dst = sendPayload->nodeId;
+			message->dataId = sendPayload->dataId;
+			message->dataLen = sendPayload->dataLen;
+			memset(message->data, 0xAA, maxDataLen);
+			memcpy(message->data, sendPayload->data, (sendPayload->dataLen > maxDataLen) ?
+					maxDataLen : sendPayload->dataLen);
+			free(sendPayload);
+		}
+	}
+	else
+	{
+		message->common.dst = L2_NONE_ID;
+		message->dataId = DATA_ID_NONE;
+		message->dataLen = 0;
+		memset(message->data, 0xAA, maxDataLen);
 	}
 
 	// Append CRC
@@ -214,8 +239,8 @@ static int32_t Service_Packing128K(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t
 	message->crc = crcVal;
 
 	// Logging...
+	instPtr->log.txLog.dataId = message->dataId;
 	memcpy(instPtr->log.txLog.data, message, msgLen);
-	instPtr->log.txLog.dataId = message->svcDataId;
 
 	return SUCCESS;
 }
@@ -241,7 +266,7 @@ static int32_t Service_Packing512K(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t
 
 	L2_MSG_SVC_512K *message = (L2_MSG_SVC_512K *)(instPtr->sendPktData);
 	size_t msgLen = sizeof(L2_MSG_SVC_512K);
-	size_t dataLen = L2_PAYLOAD_LEN_SVC_512K;
+	size_t maxDataLen = L2_PAYLOAD_LEN_SVC_512K;
 
 	// insert position and speed info
 	SysMonitor_GetSysinfo(&(instPtr->sysInfo));
@@ -252,11 +277,25 @@ static int32_t Service_Packing512K(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t
 	message->srcSpeedY = instPtr->sysInfo.vY;
 	message->srcSpeedZ = instPtr->sysInfo.vZ;
 
-	// Packing extra payload
-	SysMonitor_GetSendPayload(message->svcData, &(message->svcDataId), dataLen);
-	if (message->svcDataId == DATA_ID_NONE)
+	// Pack extra payload
+	SYSBUS_SVC_PLD *sendPayload;
+	SysMonitor_GetSendPayload(&sendPayload);
+	if(sendPayload == NULL)
 	{
-		memset(message->svcData, 0xAA, dataLen);
+		message->common.dst = L2_NONE_ID;
+		message->dataId = DATA_ID_NONE;
+		message->dataLen = 0;
+		memset(message->data, 0xAA, maxDataLen);
+	}
+	else
+	{
+//		message->common.dst = sendPayload->nodeId;
+		message->dataId = sendPayload->dataId;
+		message->dataLen = sendPayload->dataLen;
+		memset(message->data, 0xAA, maxDataLen);
+		memcpy(message->data, sendPayload->data, (sendPayload->dataLen > maxDataLen) ?
+				maxDataLen : sendPayload->dataLen);
+		free(sendPayload);
 	}
 
 	// Append CRC
@@ -270,9 +309,8 @@ static int32_t Service_Packing512K(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t
 	message->crc = crcVal;
 
 	// Logging...
+	instPtr->log.txLog.dataId = message->dataId;
 	memcpy(instPtr->log.txLog.data, message, msgLen);
-	instPtr->log.txLog.dataId = message->svcDataId;
-
 
 	return SUCCESS;
 }
@@ -298,7 +336,7 @@ static int32_t Service_Packing2M(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t d
 
 	L2_MSG_SVC_2M *message = (L2_MSG_SVC_2M *)(instPtr->sendPktData);
 	size_t msgLen = sizeof(L2_MSG_SVC_2M);
-	size_t dataLen = L2_PAYLOAD_LEN_SVC_2M;
+	size_t maxDataLen = L2_PAYLOAD_LEN_SVC_2M;
 
 	// insert position and speed info
 	SysMonitor_GetSysinfo(&(instPtr->sysInfo));
@@ -310,10 +348,24 @@ static int32_t Service_Packing2M(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t d
 	message->srcSpeedZ = instPtr->sysInfo.vZ;
 
 	// Packing extra payload
-	SysMonitor_GetSendPayload(message->svcData, &(message->svcDataId), dataLen);
-	if (message->svcDataId == DATA_ID_NONE)
+	SYSBUS_SVC_PLD *sendPayload;
+	SysMonitor_GetSendPayload(&sendPayload);
+	if(sendPayload == NULL)
 	{
-		memset(message->svcData, 0xAA, dataLen);
+		message->common.dst = L2_NONE_ID;
+		message->dataId = DATA_ID_NONE;
+		message->dataLen = 0;
+		memset(message->data, 0xAA, maxDataLen);
+	}
+	else
+	{
+//		message->common.dst = sendPayload->nodeId;
+		message->dataId = sendPayload->dataId;
+		message->dataLen = sendPayload->dataLen;
+		memset(message->data, 0xAA, maxDataLen);
+		memcpy(message->data, sendPayload->data, (sendPayload->dataLen > maxDataLen) ?
+				maxDataLen : sendPayload->dataLen);
+		free(sendPayload);
 	}
 
 	// Append CRC
@@ -327,9 +379,8 @@ static int32_t Service_Packing2M(L2_INST *instPtr, L2_FRAME_TYPE type, uint8_t d
 	message->crc = crcVal;
 
 	// Logging...
+	instPtr->log.txLog.dataId = message->dataId;
 	memcpy(instPtr->log.txLog.data, message, msgLen);
-	instPtr->log.txLog.dataId = message->svcDataId;
-
 
 	return SUCCESS;
 }
@@ -438,7 +489,7 @@ static int32_t Service_PktHandler128K(L2_INST *instPtr, uint8_t *msg)
 
 	L2_MSG_SVC_128K *message = (L2_MSG_SVC_128K *)msg;
 	size_t msgLen = sizeof(L2_MSG_SVC_128K);
-	size_t dataLen = L2_PAYLOAD_LEN_SVC_128K;
+	size_t maxDataLen = L2_PAYLOAD_LEN_SVC_128K;
 
 	// Update node status.
 	uint8_t nodeId = message->common.src;
@@ -477,11 +528,24 @@ static int32_t Service_PktHandler128K(L2_INST *instPtr, uint8_t *msg)
 	}
 
 	// Get data payload
-	SysMonitor_UpdateRecvPayload(message->svcData, message->svcDataId, dataLen);
+	if (message->dataId != DATA_ID_NONE)
+	{
+		if (message->dataLen > maxDataLen)
+		{
+			DBG_ERROR("Payload length" PRIu16 " out of range.\n", message->dataLen);
+			return EIGNORE;
+		}
+		SYSBUS_SVC_PLD *recvPayload = calloc(1, sizeof(SYSBUS_SVC_PLD));
+		recvPayload->dataId = message->dataId;
+		recvPayload->nodeId = message->common.src;
+		recvPayload->dataLen = message->dataLen;
+		memcpy(recvPayload->data, message->data, message->dataLen);
+		SysMonitor_GenRecvRsp(recvPayload);
+	}
 
 	// Logging...
-	memcpy(instPtr->log.rxLog.data, msg, msgLen);
-	instPtr->log.rxLog.dataId = message->svcDataId;
+	instPtr->log.rxLog.dataId = message->dataId;
+	memcpy(instPtr->log.rxLog.data, message, msgLen);
 
 #ifdef DATALINK_ENABLE_AUTOTIMESYNC
 	// Implement a auto time sync.
@@ -513,7 +577,7 @@ static int32_t Service_PktHandler512K(L2_INST *instPtr, uint8_t *msg)
 
 	L2_MSG_SVC_512K *message = (L2_MSG_SVC_512K *)msg;
 	size_t msgLen = sizeof(L2_MSG_SVC_512K);
-	size_t dataLen = L2_PAYLOAD_LEN_SVC_512K;
+	size_t maxDataLen = L2_PAYLOAD_LEN_SVC_512K;
 
 	// Update node status.
 	uint8_t nodeId = message->common.src;
@@ -552,11 +616,24 @@ static int32_t Service_PktHandler512K(L2_INST *instPtr, uint8_t *msg)
 	}
 
 	// Get data payload
-	SysMonitor_UpdateRecvPayload(message->svcData, message->svcDataId, dataLen);
+	if (message->dataId != DATA_ID_NONE)
+	{
+		if (message->dataLen > maxDataLen)
+		{
+			DBG_ERROR("Payload length" PRIu16 " out of range.\n", message->dataLen);
+			return EIGNORE;
+		}
+		SYSBUS_SVC_PLD *recvPayload = calloc(1, sizeof(SYSBUS_SVC_PLD));
+		recvPayload->dataId = message->dataId;
+		recvPayload->nodeId = message->common.src;
+		recvPayload->dataLen = message->dataLen;
+		memcpy(recvPayload->data, message->data, message->dataLen);
+		SysMonitor_GenRecvRsp(recvPayload);
+	}
 
 	// Logging...
-	memcpy(instPtr->log.rxLog.data, msg, msgLen);
-	instPtr->log.rxLog.dataId = message->svcDataId;
+	instPtr->log.rxLog.dataId = message->dataId;
+	memcpy(instPtr->log.rxLog.data, message, msgLen);
 
 #ifdef DATALINK_ENABLE_AUTOTIMESYNC
 	// Implement a auto time sync.
@@ -588,7 +665,7 @@ static int32_t Service_PktHandler2M(L2_INST *instPtr, uint8_t *msg)
 
 	L2_MSG_SVC_2M *message = (L2_MSG_SVC_2M *)msg;
 	size_t msgLen = sizeof(L2_MSG_SVC_2M);
-	size_t dataLen = L2_PAYLOAD_LEN_SVC_2M;
+	size_t maxDataLen = L2_PAYLOAD_LEN_SVC_2M;
 
 	// Update node status.
 	uint8_t nodeId = message->common.src;
@@ -627,11 +704,24 @@ static int32_t Service_PktHandler2M(L2_INST *instPtr, uint8_t *msg)
 	}
 
 	// Get data payload
-	SysMonitor_UpdateRecvPayload(message->svcData, message->svcDataId, dataLen);
+	if (message->dataId != DATA_ID_NONE)
+	{
+		if (message->dataLen > maxDataLen)
+		{
+			DBG_ERROR("Payload length" PRIu16 " out of range.\n", message->dataLen);
+			return EIGNORE;
+		}
+		SYSBUS_SVC_PLD *recvPayload = calloc(1, sizeof(SYSBUS_SVC_PLD));
+		recvPayload->dataId = message->dataId;
+		recvPayload->nodeId = message->common.src;
+		recvPayload->dataLen = message->dataLen;
+		memcpy(recvPayload->data, message->data, message->dataLen);
+		SysMonitor_GenRecvRsp(recvPayload);
+	}
 
 	// Logging...
-	memcpy(instPtr->log.rxLog.data, msg, msgLen);
-	instPtr->log.rxLog.dataId = message->svcDataId;
+	instPtr->log.rxLog.dataId = message->dataId;
+	memcpy(instPtr->log.rxLog.data, message, msgLen);
 
 #ifdef DATALINK_ENABLE_AUTOTIMESYNC
 	// Implement a auto time sync.
@@ -763,7 +853,7 @@ int32_t L2_Service_Routine(L2_INST *instPtr, const L2_RTNE_TABLE_ENTRY *rtneEntr
 			antIndex = PHY_ANT_INDEX_NONE;
 			torState = L2_TOR_SUSPEND;
 		}
-		(void)Phy_SetAntIndex(instPtr->config.phyInstPtr, antIndex);
+		(void)Phy_SetAntIndex(phyRef, antIndex);
 		(void)L2_SetupNextSlot(instPtr, torState, L2_FRAME_DIS);
 		break;
 	case L2_SLOT_MANAGE:
@@ -797,7 +887,7 @@ int32_t L2_Service_Routine(L2_INST *instPtr, const L2_RTNE_TABLE_ENTRY *rtneEntr
 			antIndex = PHY_ANT_INDEX_NONE;
 			torState = L2_TOR_SUSPEND;
 		}
-		(void)Phy_SetAntIndex(instPtr->config.phyInstPtr, antIndex);
+		(void)Phy_SetAntIndex(phyRef, antIndex);
 		(void)L2_SetupNextSlot(instPtr, torState, L2_FRAME_MNG);
 		break;
 	case L2_SLOT_RTT:
@@ -831,7 +921,7 @@ int32_t L2_Service_Routine(L2_INST *instPtr, const L2_RTNE_TABLE_ENTRY *rtneEntr
 			antIndex = PHY_ANT_INDEX_NONE;
 			torState = L2_TOR_SUSPEND;
 		}
-		(void)Phy_SetAntIndex(instPtr->config.phyInstPtr, antIndex);
+		(void)Phy_SetAntIndex(phyRef, antIndex);
 		(void)L2_SetupNextSlot(instPtr, torState, L2_FRAME_RTT);
 		break;
 	case L2_SLOT_SERVICE:

src/networking/phy_layer/phy_antenna.c

@@ -63,180 +63,240 @@ const uint16_t freqTable[L1_FRAME_MAX_HOPS] =
 };
 
 
-const uint8_t antCalTable[L1_ANT_NUM][L1_FRAME_MAX_HOPS][L1_ANT_CH_NUM] =
-//Antenna-JG01
-{
-	// Antenna-1
-	{
-		{     0,   2525,  -7533,  -6846}, {     0,  12726,  -7818,  -6860},
-		{     0,   2490,  -7836,  -6907}, {     0,   4479,  -7716,  -6837},
-		{     0,   6409,  -7770,  -6776}, {     0,  14616,  -7977,  -6816},
-		{     0, -22557,  -8002,  -6911}, {     0, -22587,  -8121,  -6918},
-		{     0,  -1124,  -8123,  -7030}, {     0,   -152,  -8219,  -7042},
-		{     0,   1823,  -8209,  -7130}, {     0,   1790,  -8290,  -7214},
-		{     0,   1669,  -8362,  -7283}, {     0,   1634,  -8459,  -7276},
-		{     0,   1615,  -8315,  -7415}, {     0,   1698,  -8168,  -7366},
-		{     0,   1535,  -8285,  -7520}, {     0,   1619,  -8285,  -7532},
-		{     0,   1609,  -8201,  -7693}, {     0,   1671,  -8145,  -7769},
-		{     0,   1676,  -8135,  -7805}, {     0,    951, -10279,  -8871},
-		{     0,    976, -10235,  -8978}, {     0,   1118, -10127,  -9019},
-		{     0,   1175, -10003,  -9007}, {     0,   1386,  -9847,  -9039},
-		{     0,   1535,  -9572,  -9058}, {     0,   1729,  -9493,  -9006},
-		{     0,  -1158,  -9312,  -9003}, {     0,  23771,  -9147,  -8928},
-		{     0,  20733,  -9074,  -8924}, {     0,   2455,  -8841,  -8886},
-		{     0,   2622,  -8718,  -8735}, {     0,   2791,  -8615,  -8705},
-		{     0,   2861,  -8168,  -8331}, {     0,   3076,  -8091,  -8218},
-		{     0,   3257,  -8046,  -8100}, {     0,   3331,  -7923,  -8073},
-		{     0,   3396,  -7826,  -7994}, {     0,   3478,  -7842,  -8016},
-		{     0,   3518,  -7846,  -7765}, {     0,   3585,  -7753,  -7715},
-		{     0,    150,  -8145,  -8591}, {     0,    192,  -8090,  -8570},
-		{     0,    207,  -8150,  -8597}, {     0,    178,  -8142,  -8656},
-		{     0,     89,  -8557,  -8688}, {     0,    107,  -8614,  -8733},
-		{     0,    194,  -8605,  -8782}, {     0,    153,  -8655,  -8881},
-		{     0,     70,  -8615,  -8952}, {     0,     35,  -8596,  -9148},
-		{     0,     49,  -8636,  -9286}, {     0,      6,  -8587,  -9435},
-		{     0,    -51,  -8540,  -9549}, {     0,    -65,  -8588,  -9700},
-		{     0,    -55,  -8503,  -9820}, {     0,    -20,  -8414,  -9907},
-		{     0,   -112,  -8481, -10031}, {     0,    -69,  -8535, -10185},
-		{     0,      2,  -8550, -10052}, {     0,     -1,  -8493, -10291},
-		{     0,    -73,  -8441, -10380}, {     0,   1958,  -6930,  -8295},
-		{     0,  -1148,  -6939,  -8396}, {     0,   1915,  -6784,  -8370},
-		{     0,   1871,  -6970,  -8514}, {     0,   1821,  -6974,  -8387},
-		{     0,   1781,  -6906,  -8431}, {     0,   1736,  -6897,  -8462},
-		{     0,   1664,  -7024,  -8377}, {     0,   1629,  -7127,  -8436},
-		{     0,   1603,  -7148,  -8528}, {     0,   1577,  -7198,  -8500},
-		{     0,   1528,  -7311,  -8512}, {     0,   1577,  -7390,  -8570},
-		{     0,   1616,  -7436,  -8572}, {     0,   1589,  -7597,  -8590},
-		{     0,   1722,  -7550,  -8568}, {     0,   1741,  -7691,  -8449},
-		{     0,   1767,  -7775,  -8328},
-	},
-	// Antenna-2
-	{
-		{     0,   2525,  -7533,  -6846}, {     0,  12726,  -7818,  -6860},
-		{     0,   2490,  -7836,  -6907}, {     0,   4479,  -7716,  -6837},
-		{     0,   6409,  -7770,  -6776}, {     0,  14616,  -7977,  -6816},
-		{     0, -22557,  -8002,  -6911}, {     0, -22587,  -8121,  -6918},
-		{     0,  -1124,  -8123,  -7030}, {     0,   -152,  -8219,  -7042},
-		{     0,   1823,  -8209,  -7130}, {     0,   1790,  -8290,  -7214},
-		{     0,   1669,  -8362,  -7283}, {     0,   1634,  -8459,  -7276},
-		{     0,   1615,  -8315,  -7415}, {     0,   1698,  -8168,  -7366},
-		{     0,   1535,  -8285,  -7520}, {     0,   1619,  -8285,  -7532},
-		{     0,   1609,  -8201,  -7693}, {     0,   1671,  -8145,  -7769},
-		{     0,   1676,  -8135,  -7805}, {     0,    951, -10279,  -8871},
-		{     0,    976, -10235,  -8978}, {     0,   1118, -10127,  -9019},
-		{     0,   1175, -10003,  -9007}, {     0,   1386,  -9847,  -9039},
-		{     0,   1535,  -9572,  -9058}, {     0,   1729,  -9493,  -9006},
-		{     0,  -1158,  -9312,  -9003}, {     0,  23771,  -9147,  -8928},
-		{     0,  20733,  -9074,  -8924}, {     0,   2455,  -8841,  -8886},
-		{     0,   2622,  -8718,  -8735}, {     0,   2791,  -8615,  -8705},
-		{     0,   2861,  -8168,  -8331}, {     0,   3076,  -8091,  -8218},
-		{     0,   3257,  -8046,  -8100}, {     0,   3331,  -7923,  -8073},
-		{     0,   3396,  -7826,  -7994}, {     0,   3478,  -7842,  -8016},
-		{     0,   3518,  -7846,  -7765}, {     0,   3585,  -7753,  -7715},
-		{     0,    150,  -8145,  -8591}, {     0,    192,  -8090,  -8570},
-		{     0,    207,  -8150,  -8597}, {     0,    178,  -8142,  -8656},
-		{     0,     89,  -8557,  -8688}, {     0,    107,  -8614,  -8733},
-		{     0,    194,  -8605,  -8782}, {     0,    153,  -8655,  -8881},
-		{     0,     70,  -8615,  -8952}, {     0,     35,  -8596,  -9148},
-		{     0,     49,  -8636,  -9286}, {     0,      6,  -8587,  -9435},
-		{     0,    -51,  -8540,  -9549}, {     0,    -65,  -8588,  -9700},
-		{     0,    -55,  -8503,  -9820}, {     0,    -20,  -8414,  -9907},
-		{     0,   -112,  -8481, -10031}, {     0,    -69,  -8535, -10185},
-		{     0,      2,  -8550, -10052}, {     0,     -1,  -8493, -10291},
-		{     0,    -73,  -8441, -10380}, {     0,   1958,  -6930,  -8295},
-		{     0,  -1148,  -6939,  -8396}, {     0,   1915,  -6784,  -8370},
-		{     0,   1871,  -6970,  -8514}, {     0,   1821,  -6974,  -8387},
-		{     0,   1781,  -6906,  -8431}, {     0,   1736,  -6897,  -8462},
-		{     0,   1664,  -7024,  -8377}, {     0,   1629,  -7127,  -8436},
-		{     0,   1603,  -7148,  -8528}, {     0,   1577,  -7198,  -8500},
-		{     0,   1528,  -7311,  -8512}, {     0,   1577,  -7390,  -8570},
-		{     0,   1616,  -7436,  -8572}, {     0,   1589,  -7597,  -8590},
-		{     0,   1722,  -7550,  -8568}, {     0,   1741,  -7691,  -8449},
-		{     0,   1767,  -7775,  -8328},
-	},
-	// Antenna-3
-	{
-		{     0,   2525,  -7533,  -6846}, {     0,  12726,  -7818,  -6860},
-		{     0,   2490,  -7836,  -6907}, {     0,   4479,  -7716,  -6837},
-		{     0,   6409,  -7770,  -6776}, {     0,  14616,  -7977,  -6816},
-		{     0, -22557,  -8002,  -6911}, {     0, -22587,  -8121,  -6918},
-		{     0,  -1124,  -8123,  -7030}, {     0,   -152,  -8219,  -7042},
-		{     0,   1823,  -8209,  -7130}, {     0,   1790,  -8290,  -7214},
-		{     0,   1669,  -8362,  -7283}, {     0,   1634,  -8459,  -7276},
-		{     0,   1615,  -8315,  -7415}, {     0,   1698,  -8168,  -7366},
-		{     0,   1535,  -8285,  -7520}, {     0,   1619,  -8285,  -7532},
-		{     0,   1609,  -8201,  -7693}, {     0,   1671,  -8145,  -7769},
-		{     0,   1676,  -8135,  -7805}, {     0,    951, -10279,  -8871},
-		{     0,    976, -10235,  -8978}, {     0,   1118, -10127,  -9019},
-		{     0,   1175, -10003,  -9007}, {     0,   1386,  -9847,  -9039},
-		{     0,   1535,  -9572,  -9058}, {     0,   1729,  -9493,  -9006},
-		{     0,  -1158,  -9312,  -9003}, {     0,  23771,  -9147,  -8928},
-		{     0,  20733,  -9074,  -8924}, {     0,   2455,  -8841,  -8886},
-		{     0,   2622,  -8718,  -8735}, {     0,   2791,  -8615,  -8705},
-		{     0,   2861,  -8168,  -8331}, {     0,   3076,  -8091,  -8218},
-		{     0,   3257,  -8046,  -8100}, {     0,   3331,  -7923,  -8073},
-		{     0,   3396,  -7826,  -7994}, {     0,   3478,  -7842,  -8016},
-		{     0,   3518,  -7846,  -7765}, {     0,   3585,  -7753,  -7715},
-		{     0,    150,  -8145,  -8591}, {     0,    192,  -8090,  -8570},
-		{     0,    207,  -8150,  -8597}, {     0,    178,  -8142,  -8656},
-		{     0,     89,  -8557,  -8688}, {     0,    107,  -8614,  -8733},
-		{     0,    194,  -8605,  -8782}, {     0,    153,  -8655,  -8881},
-		{     0,     70,  -8615,  -8952}, {     0,     35,  -8596,  -9148},
-		{     0,     49,  -8636,  -9286}, {     0,      6,  -8587,  -9435},
-		{     0,    -51,  -8540,  -9549}, {     0,    -65,  -8588,  -9700},
-		{     0,    -55,  -8503,  -9820}, {     0,    -20,  -8414,  -9907},
-		{     0,   -112,  -8481, -10031}, {     0,    -69,  -8535, -10185},
-		{     0,      2,  -8550, -10052}, {     0,     -1,  -8493, -10291},
-		{     0,    -73,  -8441, -10380}, {     0,   1958,  -6930,  -8295},
-		{     0,  -1148,  -6939,  -8396}, {     0,   1915,  -6784,  -8370},
-		{     0,   1871,  -6970,  -8514}, {     0,   1821,  -6974,  -8387},
-		{     0,   1781,  -6906,  -8431}, {     0,   1736,  -6897,  -8462},
-		{     0,   1664,  -7024,  -8377}, {     0,   1629,  -7127,  -8436},
-		{     0,   1603,  -7148,  -8528}, {     0,   1577,  -7198,  -8500},
-		{     0,   1528,  -7311,  -8512}, {     0,   1577,  -7390,  -8570},
-		{     0,   1616,  -7436,  -8572}, {     0,   1589,  -7597,  -8590},
-		{     0,   1722,  -7550,  -8568}, {     0,   1741,  -7691,  -8449},
-		{     0,   1767,  -7775,  -8328},
-	},
-};
+// const uint8_t antCalTable[L1_ANT_NUM][L1_FRAME_MAX_HOPS][L1_ANT_CH_NUM] =
+// //Antenna-JG01
+// {
+// 	// Antenna-1
+// 	{
+// 		{     0,   2525,  -7533,  -6846}, {     0,  12726,  -7818,  -6860},
+// 		{     0,   2490,  -7836,  -6907}, {     0,   4479,  -7716,  -6837},
+// 		{     0,   6409,  -7770,  -6776}, {     0,  14616,  -7977,  -6816},
+// 		{     0, -22557,  -8002,  -6911}, {     0, -22587,  -8121,  -6918},
+// 		{     0,  -1124,  -8123,  -7030}, {     0,   -152,  -8219,  -7042},
+// 		{     0,   1823,  -8209,  -7130}, {     0,   1790,  -8290,  -7214},
+// 		{     0,   1669,  -8362,  -7283}, {     0,   1634,  -8459,  -7276},
+// 		{     0,   1615,  -8315,  -7415}, {     0,   1698,  -8168,  -7366},
+// 		{     0,   1535,  -8285,  -7520}, {     0,   1619,  -8285,  -7532},
+// 		{     0,   1609,  -8201,  -7693}, {     0,   1671,  -8145,  -7769},
+// 		{     0,   1676,  -8135,  -7805}, {     0,    951, -10279,  -8871},
+// 		{     0,    976, -10235,  -8978}, {     0,   1118, -10127,  -9019},
+// 		{     0,   1175, -10003,  -9007}, {     0,   1386,  -9847,  -9039},
+// 		{     0,   1535,  -9572,  -9058}, {     0,   1729,  -9493,  -9006},
+// 		{     0,  -1158,  -9312,  -9003}, {     0,  23771,  -9147,  -8928},
+// 		{     0,  20733,  -9074,  -8924}, {     0,   2455,  -8841,  -8886},
+// 		{     0,   2622,  -8718,  -8735}, {     0,   2791,  -8615,  -8705},
+// 		{     0,   2861,  -8168,  -8331}, {     0,   3076,  -8091,  -8218},
+// 		{     0,   3257,  -8046,  -8100}, {     0,   3331,  -7923,  -8073},
+// 		{     0,   3396,  -7826,  -7994}, {     0,   3478,  -7842,  -8016},
+// 		{     0,   3518,  -7846,  -7765}, {     0,   3585,  -7753,  -7715},
+// 		{     0,    150,  -8145,  -8591}, {     0,    192,  -8090,  -8570},
+// 		{     0,    207,  -8150,  -8597}, {     0,    178,  -8142,  -8656},
+// 		{     0,     89,  -8557,  -8688}, {     0,    107,  -8614,  -8733},
+// 		{     0,    194,  -8605,  -8782}, {     0,    153,  -8655,  -8881},
+// 		{     0,     70,  -8615,  -8952}, {     0,     35,  -8596,  -9148},
+// 		{     0,     49,  -8636,  -9286}, {     0,      6,  -8587,  -9435},
+// 		{     0,    -51,  -8540,  -9549}, {     0,    -65,  -8588,  -9700},
+// 		{     0,    -55,  -8503,  -9820}, {     0,    -20,  -8414,  -9907},
+// 		{     0,   -112,  -8481, -10031}, {     0,    -69,  -8535, -10185},
+// 		{     0,      2,  -8550, -10052}, {     0,     -1,  -8493, -10291},
+// 		{     0,    -73,  -8441, -10380}, {     0,   1958,  -6930,  -8295},
+// 		{     0,  -1148,  -6939,  -8396}, {     0,   1915,  -6784,  -8370},
+// 		{     0,   1871,  -6970,  -8514}, {     0,   1821,  -6974,  -8387},
+// 		{     0,   1781,  -6906,  -8431}, {     0,   1736,  -6897,  -8462},
+// 		{     0,   1664,  -7024,  -8377}, {     0,   1629,  -7127,  -8436},
+// 		{     0,   1603,  -7148,  -8528}, {     0,   1577,  -7198,  -8500},
+// 		{     0,   1528,  -7311,  -8512}, {     0,   1577,  -7390,  -8570},
+// 		{     0,   1616,  -7436,  -8572}, {     0,   1589,  -7597,  -8590},
+// 		{     0,   1722,  -7550,  -8568}, {     0,   1741,  -7691,  -8449},
+// 		{     0,   1767,  -7775,  -8328},
+// 	},
+// 	// Antenna-2
+// 	{
+// 		{     0,   2525,  -7533,  -6846}, {     0,  12726,  -7818,  -6860},
+// 		{     0,   2490,  -7836,  -6907}, {     0,   4479,  -7716,  -6837},
+// 		{     0,   6409,  -7770,  -6776}, {     0,  14616,  -7977,  -6816},
+// 		{     0, -22557,  -8002,  -6911}, {     0, -22587,  -8121,  -6918},
+// 		{     0,  -1124,  -8123,  -7030}, {     0,   -152,  -8219,  -7042},
+// 		{     0,   1823,  -8209,  -7130}, {     0,   1790,  -8290,  -7214},
+// 		{     0,   1669,  -8362,  -7283}, {     0,   1634,  -8459,  -7276},
+// 		{     0,   1615,  -8315,  -7415}, {     0,   1698,  -8168,  -7366},
+// 		{     0,   1535,  -8285,  -7520}, {     0,   1619,  -8285,  -7532},
+// 		{     0,   1609,  -8201,  -7693}, {     0,   1671,  -8145,  -7769},
+// 		{     0,   1676,  -8135,  -7805}, {     0,    951, -10279,  -8871},
+// 		{     0,    976, -10235,  -8978}, {     0,   1118, -10127,  -9019},
+// 		{     0,   1175, -10003,  -9007}, {     0,   1386,  -9847,  -9039},
+// 		{     0,   1535,  -9572,  -9058}, {     0,   1729,  -9493,  -9006},
+// 		{     0,  -1158,  -9312,  -9003}, {     0,  23771,  -9147,  -8928},
+// 		{     0,  20733,  -9074,  -8924}, {     0,   2455,  -8841,  -8886},
+// 		{     0,   2622,  -8718,  -8735}, {     0,   2791,  -8615,  -8705},
+// 		{     0,   2861,  -8168,  -8331}, {     0,   3076,  -8091,  -8218},
+// 		{     0,   3257,  -8046,  -8100}, {     0,   3331,  -7923,  -8073},
+// 		{     0,   3396,  -7826,  -7994}, {     0,   3478,  -7842,  -8016},
+// 		{     0,   3518,  -7846,  -7765}, {     0,   3585,  -7753,  -7715},
+// 		{     0,    150,  -8145,  -8591}, {     0,    192,  -8090,  -8570},
+// 		{     0,    207,  -8150,  -8597}, {     0,    178,  -8142,  -8656},
+// 		{     0,     89,  -8557,  -8688}, {     0,    107,  -8614,  -8733},
+// 		{     0,    194,  -8605,  -8782}, {     0,    153,  -8655,  -8881},
+// 		{     0,     70,  -8615,  -8952}, {     0,     35,  -8596,  -9148},
+// 		{     0,     49,  -8636,  -9286}, {     0,      6,  -8587,  -9435},
+// 		{     0,    -51,  -8540,  -9549}, {     0,    -65,  -8588,  -9700},
+// 		{     0,    -55,  -8503,  -9820}, {     0,    -20,  -8414,  -9907},
+// 		{     0,   -112,  -8481, -10031}, {     0,    -69,  -8535, -10185},
+// 		{     0,      2,  -8550, -10052}, {     0,     -1,  -8493, -10291},
+// 		{     0,    -73,  -8441, -10380}, {     0,   1958,  -6930,  -8295},
+// 		{     0,  -1148,  -6939,  -8396}, {     0,   1915,  -6784,  -8370},
+// 		{     0,   1871,  -6970,  -8514}, {     0,   1821,  -6974,  -8387},
+// 		{     0,   1781,  -6906,  -8431}, {     0,   1736,  -6897,  -8462},
+// 		{     0,   1664,  -7024,  -8377}, {     0,   1629,  -7127,  -8436},
+// 		{     0,   1603,  -7148,  -8528}, {     0,   1577,  -7198,  -8500},
+// 		{     0,   1528,  -7311,  -8512}, {     0,   1577,  -7390,  -8570},
+// 		{     0,   1616,  -7436,  -8572}, {     0,   1589,  -7597,  -8590},
+// 		{     0,   1722,  -7550,  -8568}, {     0,   1741,  -7691,  -8449},
+// 		{     0,   1767,  -7775,  -8328},
+// 	},
+// 	// Antenna-3
+// 	{
+// 		{     0,   2525,  -7533,  -6846}, {     0,  12726,  -7818,  -6860},
+// 		{     0,   2490,  -7836,  -6907}, {     0,   4479,  -7716,  -6837},
+// 		{     0,   6409,  -7770,  -6776}, {     0,  14616,  -7977,  -6816},
+// 		{     0, -22557,  -8002,  -6911}, {     0, -22587,  -8121,  -6918},
+// 		{     0,  -1124,  -8123,  -7030}, {     0,   -152,  -8219,  -7042},
+// 		{     0,   1823,  -8209,  -7130}, {     0,   1790,  -8290,  -7214},
+// 		{     0,   1669,  -8362,  -7283}, {     0,   1634,  -8459,  -7276},
+// 		{     0,   1615,  -8315,  -7415}, {     0,   1698,  -8168,  -7366},
+// 		{     0,   1535,  -8285,  -7520}, {     0,   1619,  -8285,  -7532},
+// 		{     0,   1609,  -8201,  -7693}, {     0,   1671,  -8145,  -7769},
+// 		{     0,   1676,  -8135,  -7805}, {     0,    951, -10279,  -8871},
+// 		{     0,    976, -10235,  -8978}, {     0,   1118, -10127,  -9019},
+// 		{     0,   1175, -10003,  -9007}, {     0,   1386,  -9847,  -9039},
+// 		{     0,   1535,  -9572,  -9058}, {     0,   1729,  -9493,  -9006},
+// 		{     0,  -1158,  -9312,  -9003}, {     0,  23771,  -9147,  -8928},
+// 		{     0,  20733,  -9074,  -8924}, {     0,   2455,  -8841,  -8886},
+// 		{     0,   2622,  -8718,  -8735}, {     0,   2791,  -8615,  -8705},
+// 		{     0,   2861,  -8168,  -8331}, {     0,   3076,  -8091,  -8218},
+// 		{     0,   3257,  -8046,  -8100}, {     0,   3331,  -7923,  -8073},
+// 		{     0,   3396,  -7826,  -7994}, {     0,   3478,  -7842,  -8016},
+// 		{     0,   3518,  -7846,  -7765}, {     0,   3585,  -7753,  -7715},
+// 		{     0,    150,  -8145,  -8591}, {     0,    192,  -8090,  -8570},
+// 		{     0,    207,  -8150,  -8597}, {     0,    178,  -8142,  -8656},
+// 		{     0,     89,  -8557,  -8688}, {     0,    107,  -8614,  -8733},
+// 		{     0,    194,  -8605,  -8782}, {     0,    153,  -8655,  -8881},
+// 		{     0,     70,  -8615,  -8952}, {     0,     35,  -8596,  -9148},
+// 		{     0,     49,  -8636,  -9286}, {     0,      6,  -8587,  -9435},
+// 		{     0,    -51,  -8540,  -9549}, {     0,    -65,  -8588,  -9700},
+// 		{     0,    -55,  -8503,  -9820}, {     0,    -20,  -8414,  -9907},
+// 		{     0,   -112,  -8481, -10031}, {     0,    -69,  -8535, -10185},
+// 		{     0,      2,  -8550, -10052}, {     0,     -1,  -8493, -10291},
+// 		{     0,    -73,  -8441, -10380}, {     0,   1958,  -6930,  -8295},
+// 		{     0,  -1148,  -6939,  -8396}, {     0,   1915,  -6784,  -8370},
+// 		{     0,   1871,  -6970,  -8514}, {     0,   1821,  -6974,  -8387},
+// 		{     0,   1781,  -6906,  -8431}, {     0,   1736,  -6897,  -8462},
+// 		{     0,   1664,  -7024,  -8377}, {     0,   1629,  -7127,  -8436},
+// 		{     0,   1603,  -7148,  -8528}, {     0,   1577,  -7198,  -8500},
+// 		{     0,   1528,  -7311,  -8512}, {     0,   1577,  -7390,  -8570},
+// 		{     0,   1616,  -7436,  -8572}, {     0,   1589,  -7597,  -8590},
+// 		{     0,   1722,  -7550,  -8568}, {     0,   1741,  -7691,  -8449},
+// 		{     0,   1767,  -7775,  -8328},
+// 	},
+// };
 
 const uint8_t hopPattern_ADV_24MS[L1_FRAME_ADV_24MS_HOPS] =
 {
-	0U, 35U, 66U, 47U, 40U, 16U, 30U, 65U,
-	43U, 7U, 70U, 63U, 7U, 65U, 42U, 28U,
-	2U
+	 0U,  1U,  2U,  3U,  4U,  5U,  6U,  7U,
+	 8U,  9U, 10U, 11U, 12U, 13U, 14U, 15U,
+	16U,
 };
 
 const uint8_t hopPattern_ACK_8MS[L1_FRAME_ACK_8MS_HOPS] =
 {
-	0U,  5U, 49U, 25U, 7U
+	10U, 11U, 12U, 13U, 14U,
 };
 
+//const uint8_t hopPattern_128KBPS_4MS[L1_FRAME_128KBPS_4MS_HOPS] =
+//{
+//	80U, 16U, 17U, 65U, 60U, 54U, 31U, 15U,
+//	6U, 19U, 79U, 52U, 29U, 42U, 23U, 59U,
+//	60U, 58U, 76U, 67U, 31U, 76U, 77U, 79U,
+//	79U, 14U, 61U, 5U, 71U, 50U, 32U, 77U,
+//	60U,
+//};
+
+//const uint8_t hopPattern_128KBPS_4MS[L1_FRAME_128KBPS_4MS_HOPS] =
+//{
+//	 0U,  1U,  2U,  3U,  4U,  5U,  6U,  7U,
+//	 8U,  9U, 10U, 11U, 12U, 13U, 14U, 15U,
+//	16U, 17U, 18U, 19U, 20U, 21U, 22U, 23U,
+//	24U, 25U, 26U, 27U, 28U, 29U, 30U, 31U,
+//	32U,
+//};
+
 const uint8_t hopPattern_128KBPS_4MS[L1_FRAME_128KBPS_4MS_HOPS] =
 {
-	80U, 16U, 17U, 65U, 60U, 54U, 31U, 15U,
-	6U, 19U, 79U, 52U, 29U, 42U, 23U, 59U,
-	60U, 58U, 76U, 67U, 31U, 76U, 77U, 79U,
-	79U, 14U, 61U, 5U, 71U, 50U, 32U, 77U,
-	60U,
+	 0U,  1U,  2U,  3U,  4U,  5U,  6U,  7U,
+	10U, 11U, 10U, 11U, 10U, 11U, 10U, 11U,
+	10U, 12U, 10U, 12U, 10U, 12U, 10U, 12U,
+	10U, 13U, 10U, 13U, 10U, 13U, 10U, 13U,
+	10U,
 };
 
+//const uint8_t hopPattern_128KBPS_4MS[L1_FRAME_128KBPS_4MS_HOPS] =
+//{
+//	 0U,  1U,  2U,  3U,  4U,  5U,  6U,
+//};
+
+//const uint8_t hopPattern_128KBPS_4MS[L1_FRAME_128KBPS_4MS_HOPS] =
+//{
+//	0U, 16U, 17U, 65U, 60U, 54U, 31U, 15U,
+//	6U, 19U, 39U, 52U, 29U, 42U, 23U, 49U,
+//	33U, 58U, 24U, 67U, 31U, 13U, 17U, 10U,
+//	59U, 14U, 61U, 5U, 41U, 44U, 32U, 35U,
+//	60U,
+//};
+
+//const uint8_t hopPattern_512KBPS_4MS[L1_FRAME_512KBPS_4MS_HOPS] =
+//{
+//	8U,  9U, 10U, 11U, 12U, 13U, 14U, 15U,
+//	16U, 17U, 18U, 19U, 20U, 21U, 22U, 23U,
+//	24U, 25U, 26U, 27U, 28U, 29U, 30U, 31U,
+//	32U, 33U, 34U, 35U, 36U, 37U, 38U, 39U,
+//	40U, 41U, 42U, 43U,
+//};
+
 const uint8_t hopPattern_512KBPS_4MS[L1_FRAME_512KBPS_4MS_HOPS] =
 {
-	80U,  62U, 40U, 66U, 65U, 33U, 55U, 33U,
-	57U, 11U, 37U, 45U, 5U, 69U, 77U, 54U,
-	37U, 63U, 14U, 64U, 76U, 31U, 45U, 52U,
-	40U, 20U, 20U, 32U, 0U, 60U, 23U, 19U,
-	15U, 38U, 62U, 18U,
+	8U,  9U, 10U, 11U, 12U, 13U, 14U, 15U,
+	16U, 17U, 16U, 17U, 16U, 17U, 16U, 17U,
+	16U, 18U, 16U, 18U, 16U, 18U, 16U, 18U,
+	16U, 19U, 16U, 19U, 16U, 19U, 16U, 19U,
+	16U, 20U, 16U, 20U,
 };
 
+
+//const uint8_t hopPattern_2MBPS_4MS[L1_FRAME_2MBPS_4MS_HOPS] =
+//{
+//	16U, 17U, 18U, 19U, 20U, 21U, 22U, 23U,
+//	24U, 25U, 26U, 27U, 28U, 29U, 30U, 31U,
+//	32U, 33U, 34U, 35U, 36U, 37U, 38U, 39U,
+//	40U, 41U, 42U, 43U, 44U, 45U, 46U, 47U,
+//	48U, 49U, 50U, 51U, 52U, 53U,
+//};
+
+//const uint8_t hopPattern_2MBPS_4MS[L1_FRAME_2MBPS_4MS_HOPS] =
+//{
+//	16U, 17U, 18U, 19U, 20U, 21U, 22U, 23U,
+//	24U, 25U, 24U, 25U, 24U, 25U, 24U, 25U,
+//	24U, 26U, 24U, 26U, 24U, 26U, 24U, 26U,
+//	24U, 27U, 24U, 27U, 24U, 27U, 24U, 27U,
+//	24U, 28U, 24U, 28U, 24U, 28U,
+//};
+
 const uint8_t hopPattern_2MBPS_4MS[L1_FRAME_2MBPS_4MS_HOPS] =
 {
-	0U,  13U, 37U, 44U, 16U, 0U, 59U, 50U,
-	69U, 70U, 58U, 14U, 9U, 72U, 27U, 25U,
-	21U, 76U, 20U, 35U, 30U, 58U, 22U, 59U,
-	48U, 33U, 8U, 7U, 41U, 12U, 44U, 79U,
-	77U, 38U, 76U, 75U, 48U, 56U,
+	16U, 17U, 18U, 19U, 20U, 21U, 20U, 20U,
+	20U, 20U, 20U, 20U, 20U, 20U, 20U, 20U,
+	20U, 20U, 20U, 20U, 20U, 20U, 20U, 20U,
+	20U, 20U, 20U, 20U, 20U, 20U, 20U, 20U,
+	20U, 20U, 20U, 20U, 20U, 20U,
 };
 
 /** @} PhysicalLayer_AntennaConfig_Constants*/
@@ -402,7 +462,7 @@ int32_t Phy_SetAntIndex(PHY_INST *instPtr, PHY_ANT_INDEX antIndex)
 {
 	ASSERT(instPtr != NULL);
 
-	if (antIndex < 0 || antIndex >= L1_ANT_NUM)
+	if (antIndex < PHY_ANT_INDEX_NONE || antIndex > PHY_ANT_INDEX_3)
 	{
 		DBG_ERROR("Antenna index out of range: %" PRIu8 ". \n", antIndex);
 		return EPARAM;

src/networking/phy_layer/phy_layer.c

@@ -64,7 +64,7 @@
 
 /************************** Variable Definitions *****************************/
 extern const uint16_t freqTable[L1_FRAME_MAX_HOPS];
-extern const int16_t antCalTable[L1_ANT_NUM][L1_FRAME_MAX_HOPS][L1_ANT_CH_NUM];
+//extern const int16_t antCalTable[L1_ANT_NUM][L1_FRAME_MAX_HOPS][L1_ANT_CH_NUM];
 extern const uint8_t hopPattern_ADV_24MS[L1_FRAME_ADV_24MS_HOPS];
 extern const uint8_t hopPattern_ACK_8MS[L1_FRAME_ACK_8MS_HOPS];
 extern const uint8_t hopPattern_128KBPS_4MS[L1_FRAME_128KBPS_4MS_HOPS];

src/networking/phy_layer/phy_layer.h

@@ -31,7 +31,7 @@
 #include "xadcps.h"
 #endif
 #endif
-#include "../../system_monitor.h"
+#include "../../systembus/systembus.h"
 #include "../../time_ctrl/time_ctrl.h"
 /************************** Constant Definitions *****************************/
 /**

src/system_monitor.c

@@ -1,408 +0,0 @@
-/**
- * @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
-
-#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
-/** @} SystemMonitor_Private_Constants*/
-/************************** 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
-{
-	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;
-
-/************************** Function Prototypes ******************************/
-static uint8_t GetWritable(PINGPONG ctrllor);
-static uint8_t GetReadable(PINGPONG ctrllor);
-/************************** Variable Definitions *****************************/
-static SYSMONITOR *sysMonitorInst;
-
-/*********************** Function Implementations  ***************************/
-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);
-}
-
-/**
- * @brief Initialize System monitor
- *
- * @return SUCCESS
- */
-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;
-}
-
-/**
- * @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 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;
-	memcpy(sysMonitorInst->send[buffIndx].data, buff, len);
-	sysMonitorInst->send[buffIndx].dataId++;
-	sysMonitorInst->sendCtrl.latest = buffIndx;
-	sysMonitorInst->sendCtrl.wBusy = BUFF_NONE;
-}
-
-/**
- * @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)
-	{
-		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;
-}
-
-/**
- * @brief Update receive payload.
- *
- * @param buff
- * @param id
- * @param 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 = id;
-	sysMonitorInst->recvCtrl.latest = buffIndx;
-	sysMonitorInst->recvCtrl.wBusy = BUFF_NONE;
-}
-
-/**
- * @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)
-		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;
-}
-/** @} 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;
-}
-
-/** @} HardwareState_Log_API */
-
-/** @} SystemMonitor*/

src/system_monitor.h

@@ -1,249 +0,0 @@
-/**
- * @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
-#define PAYLOAD_LEN_LJ_RX 66
-#define PAYLOAD_LEN_LJ_TX 168
-
-#define DATA_ID_NONE UINT32_MAX
-#define DATA_ID_TEST 0x02030203
-
-#define VOLTAGE_LSB 0.01 // volt
-#define VOLTAGE_MAX 2.55 // volt
-
-#define VOLT_PS_STD 1.0
-#define VOLT_PSAUX_STD 1.8
-#define VOLT_DDR_STD 1.5
-#define VOLT_PL_STD 1.0
-#define VOLT_PLAUX_STD 1.8
-#define VOLT_BRAM_STD 1.0
-
-#define VOLT_PS_OK BIT(0)
-#define VOLT_PSAUX_OK BIT(1)
-#define VOLT_DDR_OK BIT(2)
-#define VOLT_PL_OK BIT(3)
-#define VOLT_PLAUX_OK BIT(4)
-#define VOLT_BRAM_OK BIT(5)
-
-#define VOLT_ANT_PROC_OK BIT(0)
-#define VOLT_ANT_RF_OK BIT(2)
-#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.1 && (x) >= 0.9)
-#define IS_PSAUX_VALID(x) ((x) <= 2.0 && (x) >= 1.6)
-#define IS_DDR_VALID(x) ((x) <= 1.7 && (x) >= 1.3)
-#define IS_PL_VALID(x) (x <= 1.1 && (x) >= 0.9)
-#define IS_PLAUX_VALID(x) ((x) <= 2.0 && (x) >= 1.6)
-#define IS_BRAM_VALID(x) ((x) <= 1.1 && (x) >= 0.9)
-
-#define CLK_SP_PLL1_LOCK BIT(0)
-#define CLK_SP_PLL2_LOCK BIT(2)
-
-#define CLK_AD0_BBPLL_LOCK BIT(0)
-#define CLK_AD0_RFPLL_LOCK BIT(2)
-#define CLK_AD1_BBPLL_LOCK BIT(4)
-#define CLK_AD1_RFPLL_LOCK BIT(6)
-
-#define CLK_ANT_BBPLL_LOCK BIT(0)
-#define CLK_ANT_RFPLL1_LOCK BIT(2)
-#define CLK_ANT_RFPLL2_LOCK BIT(4)
-
-#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))
-{
-	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
-	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
-
-	uint8_t lastConfig[2]; ///< Last valid config \n
-						   //  byte 0: 0x11 FLJ, 0x00 LJ \n
-						   //   byte 1: 0x66 Full Power, 0x88 Low Power
-	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;			///< 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 antIndex;		///< current working antenna index
-	uint16_t advTxCnt;		///< adv frame send count
-	uint16_t advRecvCnt;	///< adv frame received count
-	uint16_t advCorrectCnt; ///< adv frame received correctly count
-	uint32_t ackTxCnt;		///< ack frame send count
-	uint32_t ackRecvCnt;	///< ack frame received count
-	uint32_t ackCorrectCnt; ///< ack frame received correctly count
-	uint32_t disTxCnt;		///< dist frame send count
-	uint32_t disRecvCnt;	///< dist frame received count
-	uint32_t disCorrectCnt;///< dist frame received correctly count
-	uint32_t mngTxCnt;		///< mng frame send count
-	uint32_t mngRecvCnt;	///< mng frame received count
-	uint32_t mngCorrectCnt; ///< mng frame received correctly count
-	uint32_t rttTxCnt;		///< rtt frame send count
-	uint32_t rttRecvCnt;	///< rtt frame received count
-	uint32_t rttCorrectCnt; ///< rtt frame received correctly count
-	uint32_t svcTxCnt;		///< svc frame send count
-	uint32_t svcRecvCnt;	///< svc frame received count
-	uint32_t svcCorrectCnt; ///< svc frame received correctly count
-	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;		///< 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 antControl;		///< current antenna rf mode
-	uint8_t reserve[3];		///< reserved data
-} PHYLOG;
-
-/**
- * @struct HWSTATE
- * @brief Hardware Status Log struct holds all hardware status
- */
-typedef struct __attribute__((packed))
-{
-	bool isSpOk;  ///< signal processor state
-	bool isAntOk; ///< antenna state
-	// -- Signal processor status
-	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
-	int8_t spAdTemp_0;     ///< Signal processor adc0 temperature
-	int8_t spAdTemp_1;     ///< Signal processor adc1 temperature
-	int8_t spFpgaTemp;     ///< Signal processor FPGA temperature
-	// -- Antenna status
-	uint16_t ant1Freq; ///< Antenna 1 frequency
-	uint16_t ant2Freq; ///< Antenna 2 frequency
-	uint16_t ant3Freq; ///< Antenna 3 frequency
-	uint8_t antPll;	   ///< Antenna pll lock state indicator
-	uint8_t antMode;   ///< Antenna mode indicator
-	int8_t antTemp;	   ///< Antenna rf temperature
-	uint8_t antRsvd;   ///< Antenna reserved status register
-	uint8_t phyId;
-	uint8_t reserve[1];
-} 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);
-
-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, 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);
-
-void SysMonitor_UpdateLinklayerLog(const LINKLOG *log);
-void SysMonitor_UpdatePhysicalLayerLog(const PHYLOG *log);
-void SysMonitor_UpdateHardwareStatus(const HWSTATE *state);
-void SysMonitor_GetLinklayerLog(LINKLOG *log);
-void SysMonitor_GetPhysicalLayerLog(PHYLOG *log);
-void SysMonitor_GetHardwareStatus(HWSTATE *state);
-
-#endif //__SYSTEM_MONITOR_H_
-
-/** @} */

src/systembus/systembus.h

@@ -23,9 +23,74 @@
 #include <stdbool.h>
 #include "systembus_uart.h" // SystemBus UART driver
 #include "circ_queue.h"
-#include "../system_monitor.h"
 
 /************************** Constant Definitions *****************************/
+/**
+ * @name SystemMonitor_Constants
+ * @{
+ */
+#define SYSBUS_FRM_MAX UART_FRM_MAX
+#define SYSBUS_DAT_MAX UART_DAT_MAX
+#define SYSBUS_PRE_LEN 2 // length of preamble of data chunk (command + node type)
+#define SYSBUS_PLD_MAX SYSBUS_DAT_MAX-SYSBUS_PRE_LEN // max length of payload chunk (part of data chunk)
+#define SYSBUS_SVC_PRE_LEN 7 // length of service premable
+#define SYSBUS_SVC_PLD_MAX SYSBUS_PLD_MAX-SYSBUS_SVC_PRE_LEN // max length of service payload
+
+#define DATA_ID_NONE UINT32_MAX
+#define DATA_ID_TEST 0x02030203
+
+#define VOLTAGE_LSB 0.01 // volt
+#define VOLTAGE_MAX 2.55 // volt
+
+#define VOLT_PS_STD 1.0
+#define VOLT_PSAUX_STD 1.8
+#define VOLT_DDR_STD 1.5
+#define VOLT_PL_STD 1.0
+#define VOLT_PLAUX_STD 1.8
+#define VOLT_BRAM_STD 1.0
+
+#define VOLT_PS_OK BIT(0)
+#define VOLT_PSAUX_OK BIT(1)
+#define VOLT_DDR_OK BIT(2)
+#define VOLT_PL_OK BIT(3)
+#define VOLT_PLAUX_OK BIT(4)
+#define VOLT_BRAM_OK BIT(5)
+
+#define VOLT_ANT_PROC_OK BIT(0)
+#define VOLT_ANT_RF_OK BIT(2)
+#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.1 && (x) >= 0.9)
+#define IS_PSAUX_VALID(x) ((x) <= 2.0 && (x) >= 1.6)
+#define IS_DDR_VALID(x) ((x) <= 1.7 && (x) >= 1.3)
+#define IS_PL_VALID(x) (x <= 1.1 && (x) >= 0.9)
+#define IS_PLAUX_VALID(x) ((x) <= 2.0 && (x) >= 1.6)
+#define IS_BRAM_VALID(x) ((x) <= 1.1 && (x) >= 0.9)
+
+#define CLK_SP_PLL1_LOCK BIT(0)
+#define CLK_SP_PLL2_LOCK BIT(2)
+
+#define CLK_AD0_BBPLL_LOCK BIT(0)
+#define CLK_AD0_RFPLL_LOCK BIT(2)
+#define CLK_AD1_BBPLL_LOCK BIT(4)
+#define CLK_AD1_RFPLL_LOCK BIT(6)
+
+#define CLK_ANT_BBPLL_LOCK BIT(0)
+#define CLK_ANT_RFPLL1_LOCK BIT(2)
+#define CLK_ANT_RFPLL2_LOCK BIT(4)
+
+#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 ****************************/
 
 /**
@@ -39,6 +104,156 @@ typedef struct
 	uint32_t rxQueueMax; ///< maximum rx queue length
 } SYSBUS_CONFIG;
 
+
+/**
+ * @struct SYSBUS_SVC_PLD
+ * @brief Payload struct that holds the service payload
+ */
+typedef struct
+{
+	uint32_t dataId;  ///< data identifier
+	uint8_t nodeId;   ///< destination ID for tx, source ID for rx
+	uint16_t dataLen; ///< data length
+	uint8_t data[SYSBUS_SVC_PLD_MAX];
+} SYSBUS_SVC_PLD;
+
+/**
+ * @struct SYSINFO
+ * @brief System Infomation log
+ */
+typedef struct __attribute__((packed))
+{
+	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
+	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
+
+	uint8_t lastConfig[4]; ///< Last valid config \n
+						   //  byte 0: Enable control, 0xAA - enable, 0x55 - disable \n
+						   //  byte 1: Node ID \n
+						   //  byte 2: Service rate \n
+						   //  byte 3: routing table number
+	uint32_t recvCnt;	   ///< number of received data packet
+	uint32_t sendCnt;	   ///< number of send data packet
+	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;			///< 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 antIndex;		///< current working antenna index
+	uint32_t advTxCnt;		///< adv frame send count
+	uint32_t advRecvCnt;	///< adv frame received count
+	uint32_t advCorrectCnt; ///< adv frame received correctly count
+	uint32_t ackTxCnt;		///< ack frame send count
+	uint32_t ackRecvCnt;	///< ack frame received count
+	uint32_t ackCorrectCnt; ///< ack frame received correctly count
+	uint32_t disTxCnt;		///< dist frame send count
+	uint32_t disRecvCnt;	///< dist frame received count
+	uint32_t disCorrectCnt;///< dist frame received correctly count
+	uint32_t mngTxCnt;		///< mng frame send count
+	uint32_t mngRecvCnt;	///< mng frame received count
+	uint32_t mngCorrectCnt; ///< mng frame received correctly count
+	uint32_t rttTxCnt;		///< rtt frame send count
+	uint32_t rttRecvCnt;	///< rtt frame received count
+	uint32_t rttCorrectCnt; ///< rtt frame received correctly count
+	uint32_t svcTxCnt;		///< svc frame send count
+	uint32_t svcRecvCnt;	///< svc frame received count
+	uint32_t svcCorrectCnt; ///< svc frame received correctly count
+	int32_t timeDev;		///< last time deviation result
+	uint32_t sendId;		///< last send data id
+	uint32_t recvId;		///< last received data id
+	uint8_t reserve[3];		///< reserved data
+} LINKLOG;
+
+/**
+ * @struct PHYLOG
+ * @brief Physical Layer Log struct holds the Linklayer log
+ */
+typedef struct __attribute__((packed))
+{
+	uint32_t acqCnt;		///< acquisition 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 antControl;		///< current antenna rf mode
+	uint8_t reserve[2];		///< reserved data
+} PHYLOG;
+
+/**
+ * @struct HWSTATE
+ * @brief Hardware Status Log struct holds all hardware status
+ */
+typedef struct __attribute__((packed))
+{
+	bool isSpOk;  ///< signal processor state
+	bool isAntOk; ///< antenna state
+	// -- Signal processor status
+	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
+	int8_t spAdTemp_0;     ///< Signal processor adc0 temperature
+	int8_t spAdTemp_1;     ///< Signal processor adc1 temperature
+	int8_t spFpgaTemp;     ///< Signal processor FPGA temperature
+	// -- Antenna status
+	uint16_t ant1Freq; ///< Antenna 1 frequency
+	uint16_t ant2Freq; ///< Antenna 2 frequency
+	uint16_t ant3Freq; ///< Antenna 3 frequency
+	uint8_t antPll;	   ///< Antenna pll lock state indicator
+	uint8_t antMode;   ///< Antenna mode indicator
+	int8_t antTemp;	   ///< Antenna rf temperature
+	uint8_t antRsvd;   ///< Antenna reserved status register
+	uint8_t phyId;
+	uint8_t reserve[3];
+} HWSTATE;
+
 /**
  * @struct SYSBUS
  * @brief SystemBus Instance struct
@@ -57,8 +272,19 @@ typedef struct
 	bool isRxDone;		   ///< rx done indicator
 } SYSBUS;
 
+/**
+ * @struct SYSMON_CONFIG
+ * @brief System monitor config struct holds system monitor initialization parameters
+ */
+typedef struct
+{
+	uint32_t sendQueueMax; ///< maximum send queue length
+	uint32_t recvQueueMax; ///< maximum receive queue length
+} SYSMON_CONFIG;
+
 /************************** Function Prototypes ******************************/
 
+int32_t SystemBus_GenRecvRsp(SYSBUS *instPtr, SYSBUS_SVC_PLD *payload);
 int32_t SystemBus_Init(SYSBUS **instPtr, SYSBUS_CONFIG *config);
 void SystemBus_Destroy(SYSBUS *instPtr);
 
@@ -74,11 +300,29 @@ int32_t SystemBus_TxIntrHandler(SYSBUS *instPtr);
 int32_t SystemBus_RxIntrHandler(SYSBUS *instPtr);
 
 bool SystemBus_IsReqPending(SYSBUS *instPtr);
-bool SystemBus_IsRsqPending(SYSBUS *instPtr);
+bool SystemBus_IsRespPending(SYSBUS *instPtr);
 
 bool SystemBus_IsTxBusy(SYSBUS *instPtr);
 bool SystemBus_IsRxBusy(SYSBUS *instPtr);
 
+
+int32_t SysMonitor_Init(SYSMON_CONFIG *config);
+void SysMonitor_Destroy(void);
+
+void SysMonitor_UpdateSysinfo(const SYSINFO *info);
+void SysMonitor_GetSysinfo(SYSINFO *info);
+
+int32_t SysMonitor_UpdateSendPayload(SYSBUS_SVC_PLD *payload);
+void SysMonitor_GetSendPayload(SYSBUS_SVC_PLD **payload);
+int32_t SysMonitor_GenRecvRsp(SYSBUS_SVC_PLD *payload);
+
+void SysMonitor_UpdateLinklayerLog(const LINKLOG *log);
+void SysMonitor_UpdatePhysicalLayerLog(const PHYLOG *log);
+void SysMonitor_UpdateHardwareStatus(const HWSTATE *state);
+void SysMonitor_GetLinklayerLog(LINKLOG *log);
+void SysMonitor_GetPhysicalLayerLog(PHYLOG *log);
+void SysMonitor_GetHardwareStatus(HWSTATE *state);
+
 #endif //__SYSTEMBUS_H_
 
 /** @} SystemBus*/

src/systembus/systembus_uart.c

@@ -21,7 +21,6 @@
  * @{
  */
 
-
 #include <stdlib.h>
 #include <string.h>
 #include <stdint.h>
@@ -34,10 +33,10 @@
  * @{
  */
 // Control and status register
-#define MODULE_VERSION 0
-#define UART_STATUS 4
-#define UART_SEND_CMD 8
-#define UART_RECV_CNT 12
+#define MODULE_VERSION 0x00000000U
+#define UART_STATUS 0x0000004U
+#define UART_SEND_CMD 0x00000008U
+#define UART_RECV_CNT 0x0000000CU
 
 // Status code
 #define UART_STATUS_TX_BUSY 0x00010000
@@ -48,6 +47,10 @@
 #define UART_RXBUFF_OFFSET 2048
 #define UART_RXBUFF_MAX 1024
 
+#if (UART_TXBUFF_MAX < UART_FRM_MAX || UART_RXBUFF_MAX < UART_FRM_MAX)
+#error "UART_FRM_MAX exceeds the maximum value."
+#endif
+
 // Frame Data offsets
 #define FRAME_HEAD_LOW 0x5A
 #define FRAME_HEAD_HIGH 0x54
@@ -62,16 +65,6 @@
 #define FRAME_OVERHEAD_LEN 7 // CheckSum, Dummy and DataLen
 /** @} SystemBus_UART_Driver_Constants*/
 
-/*****************************************************************************/
-/**
- * @brief   Instance initial
- *
- * @param   instPtr     A pointer to frame uart instance structure.
- * @param   config    Base address of frame uart, refer to "xparameters.h"
- *
- * @return  None.
- *
- ******************************************************************************/
 int SysbusUart_Init(SYSBUS_UART **instPtr, SYSBUS_UART_CONFIG *config)
 {
 	ASSERT(instPtr != NULL);
@@ -85,23 +78,12 @@ int SysbusUart_Init(SYSBUS_UART **instPtr, SYSBUS_UART_CONFIG *config)
 	return SUCCESS;
 }
 
-/*****************************************************************************/
-/**
- * @brief   Send a system bus frame.
- *
- * @param   instPtr	A pointer to SYSBUS_UART instance structure.
- * @param   buff	A pointer to send data buffer
- * @param   dLen	A integer indicate the send data buffer length in byte.
- *
- * @return
- *
- ******************************************************************************/
 int SysbusUart_Send(SYSBUS_UART *instPtr, SYSBUS_UART_FRAME *frame)
 {
 	ASSERT(instPtr != NULL);
 	ASSERT(frame != NULL);
-	uint8_t dLen, checkSum;
-	uint8_t sendLen;
+	uint8_t checkSum;
+	uint16_t dLen, sendLen;
 	uint8_t *sendBuff;
 	if (frame->len > UART_TXBUFF_MAX || frame->len == 0)
 	{
@@ -146,29 +128,21 @@ int SysbusUart_Send(SYSBUS_UART *instPtr, SYSBUS_UART_FRAME *frame)
 		free(sendBuff);
 		return FAILURE;
 	}
-	memcpy((void *)(instPtr->config.baseAddr + UART_TXBUFF_OFFSET), sendBuff, (sendLen + sizeof(uint32_t) - 1) / sizeof(uint32_t) * sizeof(uint32_t));
+	memcpy((void *)(instPtr->config.baseAddr + UART_TXBUFF_OFFSET), sendBuff,
+			NORMALIZE_SIZE((sendLen + sizeof(uint32_t) - 1) / sizeof(uint32_t) * sizeof(uint32_t)));
 	free(sendBuff);
 	// Start Sending
 	SYSTEMBUS_UART_mWriteReg(instPtr->config.baseAddr, UART_SEND_CMD, sendLen);
 	return SUCCESS;
 }
 
-/*****************************************************************************/
-/**
- * @brief   Get last system bus frame.
- *
- * @param   instPtr     A pointer to SYSBUS_UART instance structure.
- * @param   buff    A pointer to receive data buffer.
- *
- * @return
- *
- ******************************************************************************/
 int SysbusUart_Recv(SYSBUS_UART *instPtr, SYSBUS_UART_FRAME *frame)
 {
 	ASSERT(instPtr != NULL);
 	ASSERT(frame != NULL);
 
-	uint8_t dLen, dWLen, plLen, checkSum, checkSumCal;
+	uint16_t dLen, dWLen, plLen;
+	uint8_t checkSum, checkSumCal;
 	uint8_t *plBuff, *dBuff;
 	dLen = SYSTEMBUS_UART_mReadReg(instPtr->config.baseAddr, UART_RECV_CNT);
 	if (dLen == 0 || dLen > UART_TXBUFF_MAX)
@@ -182,7 +156,8 @@ int SysbusUart_Recv(SYSBUS_UART *instPtr, SYSBUS_UART_FRAME *frame)
 	{
 		return ENOMEM;
 	}
-	memcpy(dBuff, (void *)(instPtr->config.baseAddr + UART_RXBUFF_OFFSET), sizeof(uint32_t) * dWLen);
+	memcpy(dBuff, (void *)(instPtr->config.baseAddr + UART_RXBUFF_OFFSET),
+			NORMALIZE_SIZE(sizeof(uint32_t) * dWLen));
 	plBuff = dBuff + FRAME_HEAD_LEN;
 	checkSumCal = 0;
 	checkSum = plBuff[dLen + FRAME_DUMMY_LEN];
@@ -209,16 +184,6 @@ int SysbusUart_Recv(SYSBUS_UART *instPtr, SYSBUS_UART_FRAME *frame)
 	return SUCCESS;
 }
 
-/*****************************************************************************/
-/**
- * @brief   Get rx channel status.
- *
- * @param   instPtr     A pointer to SYSBUS_UART instance structure.
- *
- * @return  true - SYSBUS_UART rx channel is busy.
- *          false - SYSBUS_UART rx channel is idle.
- *
- ******************************************************************************/
 bool SysbusUart_IsRxBusy(SYSBUS_UART *instPtr)
 {
 	ASSERT(instPtr != NULL);
@@ -235,16 +200,6 @@ bool SysbusUart_IsRxBusy(SYSBUS_UART *instPtr)
 	}
 }
 
-/*****************************************************************************/
-/**
- * @brief   Get tx channel status.
- *
- * @param   instPtr     A pointer to SYSBUS_UART instance structure.
- *
- * @return  true - SYSBUS_UART tx channel is busy.
- *          false - SYSBUS_UART tx channel is idle.
- *
- ******************************************************************************/
 bool SysbusUart_IsTxBusy(SYSBUS_UART *instPtr)
 {
 	ASSERT(instPtr != NULL);

src/systembus/systembus_uart.h

@@ -27,6 +27,9 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include "util.h"
+/************************** Constant Definitions *****************************/
+#define UART_FRM_MAX 1024 // max length of uart frame
+#define UART_DAT_MAX 1000 // max length of data chunk (part of uart frame)
 /**************************** Type Definitions *****************************/
 /**
  *
@@ -96,23 +99,71 @@ typedef struct
 	uint16_t len;
 	uint8_t checkSum;
 	uint8_t isValid;
-	uint8_t data[256];
+	uint8_t data[UART_FRM_MAX];
 } SYSBUS_UART_FRAME;
 
 /************************** Function Prototypes ******************************/
-// Instance initial
+
+/*****************************************************************************/
+/**
+ * @brief   Instance initial
+ *
+ * @param   instPtr     A pointer to frame uart instance structure.
+ * @param   config    Base address of frame uart, refer to "xparameters.h"
+ *
+ * @return  None.
+ *
+ ******************************************************************************/
 int SysbusUart_Init(SYSBUS_UART **instPtr, SYSBUS_UART_CONFIG *config);
 
-// Send a system bus frame.
+
+/*****************************************************************************/
+/**
+ * @brief   Send a system bus frame.
+ *
+ * @param   instPtr	A pointer to SYSBUS_UART instance structure.
+ * @param   buff	A pointer to send data buffer
+ * @param   dLen	A integer indicate the send data buffer length in byte.
+ *
+ * @return
+ *
+ ******************************************************************************/
 int SysbusUart_Send(SYSBUS_UART *instPtr, SYSBUS_UART_FRAME *frame);
 
-// Get last system bus frame.
+/*****************************************************************************/
+/**
+ * @brief   Get last system bus frame.
+ *
+ * @param   instPtr     A pointer to SYSBUS_UART instance structure.
+ * @param   buff    A pointer to receive data buffer.
+ *
+ * @return
+ *
+ ******************************************************************************/
 int SysbusUart_Recv(SYSBUS_UART *instPtr, SYSBUS_UART_FRAME *frame);
 
-// Get system bus rx channel status.
+/*****************************************************************************/
+/**
+ * @brief   Get rx channel status.
+ *
+ * @param   instPtr     A pointer to SYSBUS_UART instance structure.
+ *
+ * @return  true - SYSBUS_UART rx channel is busy.
+ *          false - SYSBUS_UART rx channel is idle.
+ *
+ ******************************************************************************/
 bool SysbusUart_IsRxBusy(SYSBUS_UART *instPtr);
 
-// Get system bus tx channel status.
+/*****************************************************************************/
+/**
+ * @brief   Get tx channel status.
+ *
+ * @param   instPtr     A pointer to SYSBUS_UART instance structure.
+ *
+ * @return  true - SYSBUS_UART tx channel is busy.
+ *          false - SYSBUS_UART tx channel is idle.
+ *
+ ******************************************************************************/
 bool SysbusUart_IsTxBusy(SYSBUS_UART *instPtr);
 
 #endif // SYSTEMBUS_UART_H