32 Commits
Author SHA1 Message Date
josh b42316dd84 fix: 修复RFSoC Timer不正常运行的问题; 暂时修改Z7的FPGA温度回读 2025-09-01 15:45:45 +08:00
josh 3caea65695 feat: 更新图片上位机,修改按钮布局和文字,增加自检回读
图片传输功能由于缺少buffer,会导致缺或多数据,造成图片显示异常;自检回读大概率会卡死导致程序退出
2025-08-28 10:33:19 +08:00
josh b3fa034558 feat: 更换棒状全向天线,物理层重新对各挡位进行测试,让各挡位达到相近的动态 2025-08-28 10:31:03 +08:00
josh 75cf7feedc feat: 增加有效业务收发链路层计数,调整自检回令 2025-08-26 15:26:09 +08:00
josh 1ae8360ae8 feat: 增加不同帧类型的发送功率控制,修改AD9361增益 2025-08-25 16:04:43 +08:00
josh 9e4fb6ffb5 fix: 修改时隙表编号,配置时隙表时同时修改初始建网时隙表;修改自检回令 2025-08-21 16:30:50 +08:00
josh 7d3624e946 feat: 图片上位机修改第二张图片的字节数,适配现有PL UART buffer 2025-08-21 14:19:44 +08:00
josh 75d6651258 fix: 修复PS上传数据长度不足的问题;图片上位机修改控制字的大小端,增加目标节点选择 2025-08-20 17:00:12 +08:00
josh cb9dc0d934 feat: 新增图片传输上位机 2025-08-20 10:30:39 +08:00
josh e56afc4a78 fix: 修复消息队列未初始化的问题,简易上位机新增指定节点数据发送 2025-08-20 10:30:19 +08:00
josh 3a90bc329b feat: 增加上位机消息发送队列 2025-08-19 10:23:00 +08:00
josh 76b49097c1 feat: 按照演示验证修改,完成演示验证 2025-08-12 16:52:00 +08:00
josh 9c24f66aae feat: 移除sysmon文件, 合并至sysbus 2025-06-24 16:53:40 +08:00
josh 044345f597 fix: 修复comtool caption错误 2025-06-24 10:20:58 +08:00
josh 6b9a2c8cc4 fix: 修改UART上传帧长, 修改节点配置主节点ID识别 2025-06-24 10:02:07 +08:00
josh d3d45fbfb0 fix: 修改数据接收上传逻辑, comtool增加数据发送测试 2025-06-23 19:52:02 +08:00
josh f9591a8c95 fix: 修复遥测数据偏移量 2025-06-23 17:35:06 +08:00
josh c0b239e028 fix: 修改comtool插件
修复错误的checksum, 修复遥测数据偏移量
2025-06-23 17:26:10 +08:00
josh 5679de641c fix: 修复数据读取逻辑,增加入队拷贝拷贝 2025-06-23 16:04:01 +08:00
josh 58a909673a fix: 修改路由表,指定接收节点; 修改总线部分的错误 2025-06-23 00:22:33 +08:00
josh 5a91eaad72 fix: 撤销submodule错误的commit 2025-06-22 12:57:19 +08:00
josh 74219c3cbe feat: 更新auto build和配置文件 2025-06-20 18:42:03 +08:00
josh d138381578 feat: 更新硬件包络, 更新9528配置 2025-06-20 18:06:12 +08:00
josh 8a273739c3 feat: 更新时隙表, 避免业务帧连续接收导致的物理层复位; 更新跳频图案 2025-06-19 16:17:55 +08:00
josh 4932c9c6c7 doc & fix: 增加comtool plugin, 修改上传遥测长度问题 2025-06-16 16:08:05 +08:00
josh c468bd9ca1 feat: 完成上位机控制逻辑修改
仅在业务阶段传输上位机数据, 上位机下发数据入队, 待发送时隙进行发送, 收到数据自动上传
2025-06-13 17:22:11 +08:00
josh 711e006b91 fix: 增加9528锁定回读函数定义 2025-06-13 16:44:49 +08:00
josh cf8023cfee doc: 更新上位机协议, 修改业务帧长 2025-06-13 16:19:23 +08:00
josh 1442386e44 feat: 增加UART buff的长度 2025-06-12 15:33:19 +08:00
josh 787103f36d doc: 更新上位机协议, 帧头帧尾与PS统一 2025-06-12 09:51:55 +08:00
josh 5abe9e347f feat: 增加时隙表个数, 用于支持上位机配置切换 2025-06-11 10:31:58 +08:00
josh ba7e46356f doc: 更新上位机协议, 增加数据长度 2025-06-10 15:36:47 +08:00
37 changed files with 7075 additions and 2925 deletions
+3 -3
View File
@@ -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
+5 -4
View File
@@ -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"]
}
+4 -4
View File
@@ -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"]
}
+217
View File
@@ -0,0 +1,217 @@
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[codz]
*$py.class
# C extensions
*.so
# Distribution / packaging
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
share/python-wheels/
*.egg-info/
.installed.cfg
*.egg
MANIFEST
# PyInstaller
# Usually these files are written by a python script from a template
# before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec
# Installer logs
pip-log.txt
pip-delete-this-directory.txt
# Unit test / coverage reports
htmlcov/
.tox/
.nox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
*.py.cover
.hypothesis/
.pytest_cache/
cover/
# Translations
*.mo
*.pot
# Django stuff:
*.log
local_settings.py
db.sqlite3
db.sqlite3-journal
# Flask stuff:
instance/
.webassets-cache
# Scrapy stuff:
.scrapy
# Sphinx documentation
docs/_build/
# PyBuilder
.pybuilder/
target/
# Jupyter Notebook
.ipynb_checkpoints
# IPython
profile_default/
ipython_config.py
# pyenv
# For a library or package, you might want to ignore these files since the code is
# intended to run in multiple environments; otherwise, check them in:
# .python-version
# pipenv
# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
# However, in case of collaboration, if having platform-specific dependencies or dependencies
# having no cross-platform support, pipenv may install dependencies that don't work, or not
# install all needed dependencies.
#Pipfile.lock
# UV
# Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
# This is especially recommended for binary packages to ensure reproducibility, and is more
# commonly ignored for libraries.
#uv.lock
# poetry
# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
# This is especially recommended for binary packages to ensure reproducibility, and is more
# commonly ignored for libraries.
# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
#poetry.lock
#poetry.toml
# pdm
# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
# pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
# https://pdm-project.org/en/latest/usage/project/#working-with-version-control
#pdm.lock
#pdm.toml
.pdm-python
.pdm-build/
# pixi
# Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
#pixi.lock
# Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
# in the .venv directory. It is recommended not to include this directory in version control.
.pixi
# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
__pypackages__/
# Celery stuff
celerybeat-schedule
celerybeat.pid
# Redis
*.rdb
*.aof
*.pid
# RabbitMQ
mnesia/
rabbitmq/
rabbitmq-data/
# ActiveMQ
activemq-data/
# SageMath parsed files
*.sage.py
# Environments
.env
.envrc
.venv
env/
venv/
ENV/
env.bak/
venv.bak/
# Spyder project settings
.spyderproject
.spyproject
# Rope project settings
.ropeproject
# mkdocs documentation
/site
# mypy
.mypy_cache/
.dmypy.json
dmypy.json
# Pyre type checker
.pyre/
# pytype static type analyzer
.pytype/
# Cython debug symbols
cython_debug/
# PyCharm
# JetBrains specific template is maintained in a separate JetBrains.gitignore that can
# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
# and can be added to the global gitignore or merged into this file. For a more nuclear
# option (not recommended) you can uncomment the following to ignore the entire idea folder.
#.idea/
# Abstra
# Abstra is an AI-powered process automation framework.
# Ignore directories containing user credentials, local state, and settings.
# Learn more at https://abstra.io/docs
.abstra/
# Visual Studio Code
# Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore
# that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
# and can be added to the global gitignore or merged into this file. However, if you prefer,
# you could uncomment the following to ignore the entire vscode folder
# .vscode/
# Ruff stuff:
.ruff_cache/
# PyPI configuration file
.pypirc
# Marimo
marimo/_static/
marimo/_lsp/
__marimo__/
# Streamlit
.streamlit/secrets.toml
+99 -31
View File
@@ -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,29 +85,29 @@
| -------- | ------------- | ---------------- |
| 指令 | 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` 表示失锁 |
| 时钟芯片锁定状态 | 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 | 温度值,有符号数 |
@@ -104,36 +124,81 @@
### Echo 测试
Echo 测试中节点将 PC 下发的数据直接回传,不做其他处理。
Echo 测试中节点将 PC 下发的数据直接回传,不做其他处理。Echo 测试数据的 Payload 格式如下,顺序存储,长度可变。
| 字段名 | 字节数 (Byte) | 说明 |
| -------- | ------------- | ---------------------- |
| 数据长度 | 2 | 数据字节数 |
| 数据 | ≤950 | 长度由数据长度字段决定 |
### 节点配置指令
节点配置指令下发的 Payload 格式如下,顺序存储,共 19 字节:
节点配置指令下发的 Payload 格式如下,顺序存储,共 4 字节:
| 字段名 | 字节数 (Byte) | 说明 |
| ---------- | ------------- | ----------------------------------------------------------- |
| -------------------- | ------------- | ---------------------------------------------------------- |
| 节点使能 | 1 | `0xAA`: 启用<br />`0x55`: 停用 |
| 节点角色 | 1 | `0x11`: 簇首<br />`0x00`: 成员 |
| 节点 ID | 1 | `0x01`: 簇首<br />`0x02`~`0x0A`: 成员 |
| 业务速率 | 1 | `0x22`: 128 kbps<br />`0x33`: 256 kbps<br />`0x44`: 2 Mbps |
| 时隙表编号 | 1 | 编号值,0~2 |
| 时隙表编号(可扩展) | 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 |
+476
View File
@@ -0,0 +1,476 @@
'''
@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": "数据发送测试(节点01)",
"icon": "fa5.play-circle",
"data": (
"5A 54 E4 EE 01 00 00 00 01 28 00 "
"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": "数据发送测试(节点02)",
"icon": "fa5.play-circle",
"data": (
"5A 54 E4 EE 02 00 00 00 02 28 00 "
"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 0A 31 5A FE"
)
},
{
"caption": "数据发送测试(节点03)",
"icon": "fa5.play-circle",
"data": (
"5A 54 E4 EE 03 00 00 00 03 28 00 "
"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 0C 31 5A FE"
)
},
{
"caption": "装订 - 【主 - 0x01】128 kbps,时隙表 1",
"icon": "fa5.play-circle",
"data": "5A 54 E3 EE AA 01 22 01 00 9F 06 5A FE"
},
{
"caption": "装订 - 【主 - 0x01】512 kbps,时隙表 2",
"icon": "fa5.play-circle",
"data": "5A 54 E3 EE AA 01 33 02 00 B1 06 5A FE"
},
{
"caption": "装订 - 【主 - 0x01】2 Mbps,时隙表 3",
"icon": "fa5.play-circle",
"data": "5A 54 E3 EE AA 01 44 03 00 C3 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,时隙表 1",
"icon": "fa5.play-circle",
"data": "5A 54 E3 EE AA 02 22 01 00 A0 06 5A FE"
},
{
"caption": "装订 - 【从 - 0x02】512 kbps,时隙表 2",
"icon": "fa5.play-circle",
"data": "5A 54 E3 EE AA 02 33 02 00 B2 06 5A FE"
},
{
"caption": "装订 - 【从 - 0x02】2M bps,时隙表 3",
"icon": "fa5.play-circle",
"data": "5A 54 E3 EE AA 02 44 03 00 C4 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,时隙表 1",
"icon": "fa5.play-circle",
"data": "5A 54 E3 EE AA 03 22 01 00 A1 06 5A FE"
},
{
"caption": "装订 - 【从 - 0x03】512 kbps,时隙表 2",
"icon": "fa5.play-circle",
"data": "5A 54 E3 EE AA 03 33 02 00 B3 06 5A FE"
},
{
"caption": "装订 - 【从 - 0x03】2 Mbps,时隙表 3",
"icon": "fa5.play-circle",
"data": "5A 54 E3 EE AA 03 44 03 00 C5 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)
+562
View File
@@ -0,0 +1,562 @@
# from PyQt5.QtWidgets import (QWidget, QVBoxLayout, QLabel, QSlider, QLineEdit, QGridLayout, QPushButton, QCheckBox, QHBoxLayout, QInputDialog)
# from PyQt5.QtCore import pyqtSignal
# from PyQt5.QtGui import QDoubleValidator
import os
from PyQt5.QtWidgets import (QWidget, QVBoxLayout, QLabel, QSlider, QLineEdit,
QGridLayout, QPushButton, QCheckBox, QHBoxLayout, QInputDialog, QComboBox, QFileDialog)
from PyQt5.QtCore import pyqtSignal, Qt, QTimer
from PyQt5.QtGui import QDoubleValidator, QPixmap
try:
from i18n import _
import utils_ui
import utils
from widgets import EditRemarDialog
except Exception:
from COMTool.i18n import _
from COMTool import utils_ui
from COMTool import utils
from COMTool.widgets import EditRemarDialog
# from .graph_widget_metasenselite import Graph_MetaSenseLite
from .graph_widgets_base import Graph_Widget_Base
import pyqtgraph as pg
from struct import unpack, pack
import time
class Graph_Image(Graph_Widget_Base):
id = "image"
updateSignal = pyqtSignal(bytes)
startTimeoutSignal = pyqtSignal()
stopTimeoutSignal = pyqtSignal()
def __init__(self, parent=None, hintSignal=lambda type, title, msg: None,
rmCallback=lambda widget: None, send=lambda x: None, config=None):
# 初始化配置,默认缩放倍数为10
default = {"scale_factor": 10}
if config:
default.update(config)
super().__init__(parent, hintSignal, rmCallback, send, default, default)
self.image_data = bytearray()
# 从配置获取缩放倍数
self.scale_factor = self.config.get("scale_factor", 10)
layout = QVBoxLayout()
self.setLayout(layout)
self.imageLabel = QLabel("[ Waiting for image... ]")
self.imageLabel.setAlignment(Qt.AlignCenter)
layout.addWidget(self.imageLabel)
self.clearBtn = QPushButton("Clear Image")
self.clearBtn.clicked.connect(self.clear)
layout.addWidget(self.clearBtn)
self.updateSignal.connect(self.update_image)
self.timeoutTimer = QTimer(self)
self.timeoutTimer.setInterval(2000) # 2 seconds timeout
self.timeoutTimer.timeout.connect(self.clear_buffer)
self.startTimeoutSignal.connect(lambda: self.timeoutTimer.start())
self.stopTimeoutSignal.emit()
def clear(self):
self.image_data.clear()
self.imageLabel.clear()
self.imageLabel.setText("[ Cleared ]")
self.stopTimeoutSignal.emit()
def clear_buffer(self):
self.image_data.clear()
self.imageLabel.setText("[ Timeout: buffer cleared ]")
self.stopTimeoutSignal.emit()
def onData(self, data: bytes):
self.stopTimeoutSignal.emit() # Stop any running timer when data is received
self.image_data.extend(data)
# Check for common image signatures
if self._is_complete_jpeg(self.image_data) or \
self._is_complete_png(self.image_data) or \
self._is_complete_bmp(self.image_data):
self.updateSignal.emit(bytes(self.image_data))
self.image_data.clear()
else:
self.startTimeoutSignal.emit() # Restart timer only if not complete
def _is_complete_jpeg(self, data):
return data[:2] == b'\xFF\xD8' and data[-2:] == b'\xFF\xD9'
def _is_complete_png(self, data):
return data[:8] == b'\x89PNG\r\n\x1a\n' and b'IEND' in data[-20:]
def _is_complete_bmp(self, data):
return data[:2] == b'BM' and len(data) >= int.from_bytes(data[2:6], 'little')
def update_image(self, img_bytes: bytes):
pixmap = QPixmap()
if pixmap.loadFromData(img_bytes):
# 使用配置的缩放倍数进行缩放
scaled_width = pixmap.width() * self.scale_factor
scaled_height = pixmap.height() * self.scale_factor
scaled = pixmap.scaled(
scaled_width,
scaled_height,
Qt.KeepAspectRatio,
Qt.SmoothTransformation
)
self.imageLabel.setPixmap(scaled)
else:
self.imageLabel.setText("[ Failed to decode image ]")
class Graph_Plot(Graph_Widget_Base):
updateSignal = pyqtSignal(dict)
id = "plot"
def __init__(self, parent=None, hintSignal=lambda type, title, msg: None, rmCallback=lambda widget: None, send=lambda x: None, config=None):
default = {
"xRange": 10,
"xRangeEnable": True,
"header": "\\xAA\\xCC\\xEE\\xBB",
"binary_protocol": False,
}
super().__init__(parent, hintSignal=hintSignal, rmCallback=rmCallback,
send=send, config=config, defaultConfig=default)
self.headerBytes = utils.str_to_bytes(
self.config["header"], escape=True, encoding="utf-8")
self.layout = QGridLayout()
self.setLayout(self.layout)
self.plotWin = pg.GraphicsLayoutWidget()
self.plotWin.setMinimumHeight(200)
self.default_x = 0;
pg.setConfigOptions(antialias=True)
rmBtn = QPushButton(_("Remove"))
clearBtn = QPushButton(_("Clear"))
rangeLabel = QLabel(_("Range:"))
rangeConf = QLineEdit(str(self.config["xRange"]))
rangeEnable = QCheckBox(_("Enable"))
rangeEnable.setChecked(self.config["xRangeEnable"])
self.binary_protocol = QCheckBox(_("Binary Protocol"))
headerLabel = QLabel(_("Header:"))
headerConf = QLineEdit(self.config["header"])
self.headerBtn = QPushButton(_("Set"))
hint = _("Protocol: header + 1Byte name length + name + 8Bytes x(double) + 8Bytes y(double) + 1Byte sum\n"
"Protocol example code see help")
headerConf.setToolTip(hint)
self.binary_widgets = [headerLabel, headerConf, self.headerBtn]
self.binary_protocol.setToolTip(_('Check this if you want to use binary protocol, or use ASCII protocol(e.g. "$data1,10.0,200.0\\n"), more see help button on the top of window'))
self.show_binary_protocol_widgets(self.config["binary_protocol"])
headerLabel.setToolTip(hint)
self.headerBtn.setToolTip(hint)
validator = QDoubleValidator()
rangeConf.setValidator(validator)
self.layout.addWidget(self.plotWin, 0, 0, 1, 3)
self.layout.addWidget(rmBtn, 1, 0, 1, 1)
self.layout.addWidget(clearBtn, 1, 2, 1, 1)
self.layout.addWidget(rangeLabel, 2, 0, 1, 1)
self.layout.addWidget(rangeConf, 2, 1, 1, 1)
self.layout.addWidget(rangeEnable, 2, 2, 1, 1)
self.layout.addWidget(self.binary_protocol, 3, 0, 1, 1)
self.layout.addWidget(headerLabel, 4, 0, 1, 1)
self.layout.addWidget(headerConf, 4, 1, 1, 1)
self.layout.addWidget(self.headerBtn, 4, 2, 1, 1)
self.resize(600, 400)
self.p = self.plotWin.addPlot(colspan=2)
# self.p.setLabel('bottom', 'x', '')
self.p.addLegend()
self.p.setXRange(0, self.config["xRange"])
self.updateSignal.connect(self.update)
self.curves = {}
self.rawData = b''
self.data = {}
self.builtinColors = [
"#BD4B4B",
"#3BB273",
"#FFFFFA",
"#307473",
"#3C6997",
"#746D75",
"#228CDB",
"#824C71",
"#7768AE",
"#DC6BAD",
"#607d8b",
"#F18701",
"#912F40",
"#414288",
"#ED4D6E",
"#FFD29D",
"#B56576",
"#503B31",
"#93E1D8",
"#596157",
]
self.notUsedColors = self.builtinColors.copy()
self.colors = {
}
rangeConf.textChanged.connect(self.setRange)
rangeEnable.clicked.connect(
lambda: self.setEnableRange(rangeEnable.isChecked()))
self.headerBtn.clicked.connect(
lambda: self.setHeader(headerConf.text()))
rmBtn.clicked.connect(self.remove)
headerConf.textChanged.connect(self.headerChanged)
clearBtn.clicked.connect(self.clear)
self.binary_protocol.clicked.connect(self.en_binary_protocol)
def remove(self):
self.rmCallback(self)
def en_binary_protocol(self):
self.rawData = b''
self.config["binary_protocol"] = self.binary_protocol.isChecked()
self.show_binary_protocol_widgets(self.config["binary_protocol"])
def show_binary_protocol_widgets(self, show=True):
for w in self.binary_widgets:
w.setVisible(show)
def clear(self):
self.data = {}
self.curves = {}
self.notUsedColors = self.builtinColors.copy()
self.colors = {}
self.p.clear()
def setRange(self, text):
if text:
self.config["xRange"] = float(text)
def setEnableRange(self, en):
self.config["xRangeEnable"] = en
def headerChanged(self, text):
if self.config["header"] != text:
self.headerBtn.setText(_("Set") + " *")
else:
self.headerBtn.setText(_("Set"))
def setHeader(self, text):
if text:
try:
textBytes = utils.str_to_bytes(
text, escape=True, encoding="utf-8")
self.config["header"] = text
self.headerBytes = textBytes
self.headerBtn.setText(_("Set"))
except Exception:
self.hintSignal.emit("error", _("Error"), _("Format error"))
def decodeData(self, data: bytes):
'''
@data bytes, protocol:
| header(4B) | line name len(1B) | line name | x(8B) | y(8B) | sum(1B) |
| AA CC EE BB | 1~255 | roll | double | double | uint8 |
@return haveFrame, dict {
"name": {
"x": [],
"y": []
}
}
'''
# append data
self.rawData += data
# find header
header = self.headerBytes
idx = self.rawData.find(header)
if idx < 0:
return False, self.data
self.rawData = self.rawData[idx:]
# check data length
nameLen = unpack("B", self.rawData[len(header): len(header) + 1])[0]
frameLen = len(header) + nameLen + 18 # 5 + nameLen + 16 + 1
if len(self.rawData) < frameLen:
return False, self.data
# get data
frame = self.rawData[:frameLen]
self.rawData = self.rawData[frameLen:]
_sum = frame[-1]
# check sum
if _sum != sum(frame[:frameLen - 1]) % 256:
return True, self.data
name = frame[len(header) + 1: len(header) +
1 + nameLen].decode("utf-8")
x = unpack("d", frame[-17:-9])[0]
y = unpack("d", frame[-9:-1])[0]
if not name in self.data:
self.data[name] = {
"x": [x],
"y": [y]
}
else:
self.data[name]["x"].append(x)
self.data[name]["y"].append(y)
return True, self.data
def decodeDataAscii(self, data: bytes):
'''
@data bytes, protocol:
$[line name],[x],[y]<,checksum>\n
or $[line name],[y]
"$" means start of frame, "," means separator,
checksum is optional, checksum is sum of all bytes in frame except ",checksum".
e.g.
"$roll,2.0\n"
"$roll,1.0,2.0\n"
"$pitch,1.0,2.0\r\n"
"$pitch,1.0,2.0,179\n" , the 179 = sum(ord(c) for c in "$pitch,1.0,2.0") % 256
@return haveFrame, dict {
"name": {
"x": [],
"y": []
}
}
'''
# append data
self.rawData += data
# find header
header = b"$"
end = b"\n"
idx = self.rawData.find(header)
if idx < 0:
return False, self.data
self.rawData = self.rawData[idx:]
# find \n
idx = self.rawData.find(end)
if idx < 0:
return False, self.data
# get data
frame = self.rawData[1:idx] # pitch,1.0,2.0 pitch,1.0,2.0,179
self.rawData = self.rawData[idx + 1:]
items = frame.split(b",")
if len(items) != 2 and len(items) != 3 and len(items) != 4:
print("-- format error, frame item len(%s, should 3 or 4) error: %s" % (len(items), frame))
return False, self.data
try:
if len(items) == 2:
x = float(self.default_x)
y = float(items[1])
self.default_x += 1
else:
x = float(items[1])
y = float(items[2])
except Exception:
print("-- x or y format error, frame: %s" % frame)
return False, self.data
# checksum
if len(items) == 4:
try:
_sum = int(items[3])
except Exception:
print("-- checksum format error({} not int), frame: {}".format(items[3], frame))
return False, self.data
# get last , index
idx = frame.rfind(b",")
if sum(header + frame[:idx]) % 256 != _sum:
print("-- checksum error")
return False, self.data
name = items[0].decode("utf-8")
if not name in self.data:
self.data[name] = {
"x": [x],
"y": [y]
}
else:
self.data[name]["x"].append(x)
self.data[name]["y"].append(y)
return True, self.data
def pickColor(self, name: str):
if name in self.colors:
return self.colors[name]
else:
if not self.notUsedColors:
self.notUsedColors = self.builtinColors.copy()
color = self.notUsedColors.pop(0)
self.colors[name] = color
return color
def update(self, data: dict):
for k, v in data.items():
if not k in self.curves:
print("add curve:", k)
color = self.pickColor(k)
self.colors[k] = color
self.curves[k] = self.p.plot(pen=pg.mkPen(color=color, width=2),
name=k,)
# symbolBrush=color, symbolPen='w', symbol='o', symbolSize=1)
if self.config["xRangeEnable"] and self.config["xRange"] > 0:
self.p.setXRange(
v["x"][-1] - self.config["xRange"], v["x"][-1])
self.curves[k].setData(x=v["x"], y=v["y"])
def onData(self, data: bytes):
while 1:
haveFrame, allData = self.decodeData(data) if self.config["binary_protocol"] else self.decodeDataAscii(data)
if not haveFrame:
break
data = b''
self.updateSignal.emit(allData)
class Graph_Button(Graph_Widget_Base):
class Button(QWidget):
def __init__(self, rmCallback, addCallback, clickCallback, changeCallback,
value=("", "hello", "hello", "fa.circle", [])):
super().__init__()
if not value[0]:
self.id = str(int(time.time() * 1000))
else:
self.id = value[0]
self.rmCallback = rmCallback
self.changeCallback = changeCallback
self.setProperty("class", "graphBtn")
layout = QHBoxLayout()
layoutSetting = QVBoxLayout()
self.setLayout(layout)
self.button = QPushButton(value[2])
self.button.setProperty("class", "bigBtn")
self.value = value[2]
self.icon = value[3]
self.shortcut = value[4]
layout.addLayout(layoutSetting)
layout.addWidget(self.button)
self.addBtn = QPushButton()
self.rmBtn = QPushButton()
self.editBtn = QPushButton()
self.addBtn.setProperty("class", "smallBtn3")
self.rmBtn.setProperty("class", "smallBtn3")
self.editBtn.setProperty("class", "smallBtn3")
utils_ui.setButtonIcon(self.addBtn, "fa.plus")
utils_ui.setButtonIcon(self.rmBtn, "fa.minus")
utils_ui.setButtonIcon(self.editBtn, "fa.edit")
if self.icon:
utils_ui.setButtonIcon(self.button, self.icon)
if self.shortcut:
tip = self.getShortcutTip()
self.button.setToolTip(tip)
layoutSetting.addStretch()
layoutSetting.addWidget(self.rmBtn)
layoutSetting.addWidget(self.addBtn)
layoutSetting.addWidget(self.editBtn)
self.rmBtn.clicked.connect(self.onRm)
self.addBtn.clicked.connect(lambda: addCallback(self))
self.editBtn.clicked.connect(self.editButton)
self.button.clicked.connect(lambda: clickCallback(
self, utils.str_to_bytes(self.value, escape=True, encoding="utf-8")))
def getInfo(self):
return [self.id, self.button.text(), self.value, self.icon, self.shortcut]
def onRm(self):
utils_ui.clearButtonIcon(self.addBtn)
utils_ui.clearButtonIcon(self.rmBtn)
utils_ui.clearButtonIcon(self.editBtn)
utils_ui.clearButtonIcon(self.button)
self.rmCallback(self)
def editButton(self):
ok, remark, value, icon, shortcut = EditRemarDialog(
self.button.text(), self.icon, shortcut=self.shortcut, value=self.value).exec()
if ok:
self.value = value
self.icon = icon
self.shortcut = shortcut
self.button.setText(remark)
if self.shortcut:
tip = self.getShortcutTip()
self.button.setToolTip(tip)
utils_ui.setButtonIcon(self.button, icon)
self.changeCallback(self)
def getShortcutTip(self):
return _("Shortcut") + ": " + "+".join((name for v, name in self.shortcut))
id = "button"
def __init__(self, parent=None, hintSignal=lambda type, title, msg: None, rmCallback=lambda widget: None, send=lambda x: None, config=None):
default = {
"items": []
}
super().__init__(parent, hintSignal, rmCallback, send, config, default)
self.layout = QHBoxLayout()
self.setLayout(self.layout)
if not self.config["items"]:
button = Graph_Button.Button(
self.onRm, self.onAdd, self.onClick, self.onChange)
self.layout.addWidget(button)
self.buttons = [button]
self.config["items"] = [button.getInfo()]
else:
self.buttons = []
for item in self.config["items"]:
button = Graph_Button.Button(
self.onRm, self.onAdd, self.onClick, self.onChange, value=item)
self.layout.addWidget(button)
self.buttons.append(button)
self.pressedKeys = []
def onRm(self, widget):
'''
@widget Graph_Button.Button
'''
item = widget.getInfo()
for item_ in self.config["items"]:
if item_[0] == item[0]: # id
self.config["items"].remove(item_)
break
self.buttons.remove(widget)
widget.setParent(None)
if not self.buttons:
self.rmCallback(self)
def onAdd(self, widget):
'''
@widget Graph_Button.Button
'''
button = Graph_Button.Button(
self.onRm, self.onAdd, self.onClick, self.onChange)
self.layout.addWidget(button)
self.buttons.append(button)
self.config["items"].append(button.getInfo())
def onClick(self, widget, data: bytes):
self.send(data)
def onChange(self, widget):
self.config["items"][self.buttons.index(widget)] = widget.getInfo()
def onKeyPressEvent(self, event):
key = event.key()
self.pressedKeys.append(key)
for uid, name, value, icon, shortcut in self.config["items"]:
if not shortcut:
continue
if len(shortcut) == len(self.pressedKeys):
same = True
for i in range(len(shortcut)):
if shortcut[i][0] != self.pressedKeys[i]:
same = False
break
if same:
value = utils.str_to_bytes(
value, escape=True, encoding="utf-8")
self.send(value)
def onKeyReleaseEvent(self, event):
key = event.key()
if key in self.pressedKeys:
self.pressedKeys.remove(key)
graphWidgets = {
Graph_Plot.id: Graph_Plot,
Graph_Button.id: Graph_Button,
Graph_Image.id: Graph_Image
# Graph_DragTof.id: Graph_DragTof,
# Graph_MetaSenseLite.id: Graph_MetaSenseLite,
}
+898
View File
@@ -0,0 +1,898 @@
'''
@brief This is an example plugin, can receive and send data
@author
@date
@license LGPL-3.0
'''
from PyQt5.QtWidgets import QWidget, QVBoxLayout, QGridLayout,QHBoxLayout, QTextEdit, QPushButton, QLabel, QScrollArea, QSplitter
from PyQt5.QtCore import Qt, pyqtSignal
from PyQt5.QtGui import QFont, QTextCursor
from struct import Struct
try:
from PyQt5.QtWidgets import QFrame
import utils_ui
from plugins.base import Plugin_Base
from conn import ConnectionStatus
from i18n import _
from widgets import statusBar
from plugins.graph_widgets import graphWidgets
from PyQt5.QtWidgets import QPushButton, QMenu
from PyQt5.QtWidgets import QComboBox
from PyQt5 import QtCore
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
from COMTool.plugins.graph_widgets import graphWidgets
class Plugin(Plugin_Base):
id = "hsjl_timer"
name = _("hsjl_timer")
showReceiveDataSignal = pyqtSignal(str)
# 图片1的字节数据(已存在,提取为常量)
IMAGE1_DATA = [
0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x06, 0x00, 0x00, 0x00, 0x1F, 0xF3, 0xFF,
0x61, 0x00, 0x00, 0x00, 0x01, 0x73, 0x52, 0x47, 0x42, 0x00, 0xAE, 0xCE, 0x1C, 0xE9, 0x00, 0x00,
0x00, 0x75, 0x49, 0x44, 0x41, 0x54, 0x38, 0x4F, 0x63, 0x64, 0xA0, 0x10, 0x30, 0x52, 0xA8, 0x9F,
0x61, 0xD4, 0x00, 0x06, 0xEC, 0x61, 0x20, 0xD0, 0xFE, 0xDA, 0x81, 0x91, 0x85, 0xF9, 0xCD, 0xFB,
0x52, 0xA1, 0x2B, 0xA0, 0x40, 0x06, 0xF1, 0x41, 0xF4, 0x87, 0x4A, 0xD1, 0x03, 0xE8, 0x81, 0x8E,
0x35, 0x10, 0xF9, 0x3A, 0x5F, 0xD7, 0x33, 0xFE, 0xFF, 0x1F, 0xFF, 0x9F, 0xE1, 0x7F, 0x26, 0xE3,
0x7F, 0x46, 0x3E, 0x06, 0x46, 0xC6, 0x55, 0x8C, 0xFF, 0x19, 0x1C, 0x89, 0x36, 0x00, 0x64, 0x0B,
0xC4, 0x10, 0x86, 0x52, 0x06, 0x06, 0x06, 0x6E, 0x86, 0xFF, 0xFF, 0xC3, 0x3E, 0x56, 0x8A, 0xAD,
0xC6, 0x16, 0xE5, 0x78, 0xA3, 0x11, 0x6C, 0xC8, 0xBF, 0xFF, 0xD7, 0x70, 0x69, 0x06, 0x19, 0x38,
0x9A, 0x0E, 0x06, 0x43, 0x18, 0x00, 0x00, 0x4E, 0x62, 0x24, 0x11, 0xDE, 0x82, 0x35, 0xD8, 0x00,
0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82
]
# 图片2的字节数据(新添加)
IMAGE2_DATA = [
0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52,
0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x05, 0x08, 0x06, 0x00, 0x00, 0x00, 0x7C, 0x64, 0x7D,
0x68, 0x00, 0x00, 0x00, 0x01, 0x73, 0x52, 0x47, 0x42, 0x00, 0xAE, 0xCE, 0x1C, 0xE9, 0x00, 0x00,
0x00, 0x04, 0x67, 0x41, 0x4D, 0x41, 0x00, 0x00, 0xB1, 0x8F, 0x0B, 0xFC, 0x61, 0x05, 0x00, 0x00,
0x00, 0x09, 0x70, 0x48, 0x59, 0x73, 0x00, 0x00, 0x12, 0x74, 0x00, 0x00, 0x12, 0x74, 0x01, 0xDE,
0x66, 0x1F, 0x78, 0x00, 0x00, 0x00, 0x14, 0x49, 0x44, 0x41, 0x54, 0x18, 0x57, 0x63, 0x50, 0x54,
0x54, 0xF9, 0x4F, 0x0C, 0x1E, 0xFC, 0x0A, 0x55, 0xFE, 0x03, 0x00, 0xAC, 0x06, 0x45, 0xBB, 0xD3,
0x7A, 0x66, 0x86, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82
]
# 在类初始化时添加定时器相关变量(onInit方法中)
def onInit(self, config):
self.image_index = 0 # 图片索引:0-图片1,1-图片2
self.cycle_count = 0 # 循环次数计数
self.send_timer = QtCore.QTimer() # 新增:定时器
self.send_timer.setInterval(1000) # 间隔1秒
self.send_timer.timeout.connect(self.send_next_image) # 绑定定时发送函数
default = {
"version": 1,
"customSendItems": [
{
"caption": "自检项",
"icon": "fa5.play-circle",
"data": "5A 54 E1 EE 00 CF 02 5A FE"
#"data": "5A 54 E1 EE 01 00 00 00 01 15 00 55 00 05 55 57 58 80 00 00 00 00 00 00 00\n\
#00 00 00 01 00 00 00 00 75 17 5A FE "
},
{
"caption": "图片传输",
"icon": "fa5.play-circle",
"data": "5A 54 E4 EE 00 00 00 01 02 00 BB 89 50 4E 47 0D 0A 1A 0A 00 00 00 0D 49 48 44 52 00 00 00 10 00 00 \n\
00 10 08 06 00 00 00 1F F3 FF 61 00 00 00 01 73 52 47 42 00 AE CE 1C E9 00 00 00 75 49 \n\
44 41 54 38 4F 63 64 A0 10 30 52 A8 9F 61 D4 00 06 EC 61 20 D0 FE DA 81 91 85 F9 CD FB \n\
52 A1 2B A0 40 06 F1 41 F4 87 4A D1 03 E8 81 8E 35 10 F9 3A 5F D7 33 FE FF 1F FF 9F E1 \n\
7F 26 E3 7F 46 3E 06 46 C6 55 8C FF 19 1C 89 36 00 64 0B C4 10 86 52 06 06 06 6E 86 FF \n\
FF C3 3E 56 8A AD C6 16 E5 78 A3 11 6C C8 BF FF D7 70 69 06 19 38 9A 0E 06 43 18 00 00 \n\
4E 62 24 11 DE 82 35 D8 00 00 00 00 49 45 4E 44 AE 42 60 82 00 76 C4 5A FE"
},
{
"caption": "配置发送",
"icon": "fa5.play-circle",
"data": "5A 54 E3 EE AA 03 22 00 00 A0 06 5A FE"
},
]
}
self.config = config
for k in default:
if k not in self.config:
self.config[k] = default[k]
self.config["customSendItems"] = default["customSendItems"]
print("初始化的customSendItems:", self.config["customSendItems"])
def createToggleButton(self):
toggleBtn = QPushButton("开关: Off")
menu = QMenu(toggleBtn)
actionOn = menu.addAction("On")
actionOff = menu.addAction("Off")
def setOn():
toggleBtn.setText("开关: On")
print("开关设为 On")
def setOff():
toggleBtn.setText("开关: Off")
print("开关设为 Off")
actionOn.triggered.connect(setOn)
actionOff.triggered.connect(setOff)
toggleBtn.setMenu(menu)
return toggleBtn
def createIdButton(self):
# 定义ID映射:原始ID -> 显示文本(带标识)
id_display_map = {
"01": "01(主)",
"02": "02(从)",
"03": "03(从)"
}
default_id = "01" # 原始ID默认值
# 按钮显示带标识的文本
toggleBtn = QPushButton(f"id: {id_display_map[default_id]}")
# 存储原始ID(关键:组帧时用这个值)
toggleBtn.setProperty("originalId", default_id)
menu = QMenu(toggleBtn)
def setId(original_id):
# 更新显示文本(带标识)
toggleBtn.setText(f"id: {id_display_map[original_id]}")
# 更新存储的原始ID
toggleBtn.setProperty("originalId", original_id)
print(f"id设为 {original_id}") # 确认原始ID正确
# 菜单显示带标识的文本,但传递原始ID
for original_id, display_text in id_display_map.items():
menu.addAction(display_text).triggered.connect(
lambda checked, id=original_id: setId(id)
)
toggleBtn.setMenu(menu)
return toggleBtn
def createtoIdButton(self):
# 目的节点ID同理处理
id_display_map = {
"01": "01(主)",
"02": "02(从)",
"03": "03(从)"
}
default_id = "01"
toggleBtn = QPushButton(f"目的节点id: {id_display_map[default_id]}")
toggleBtn.setProperty("originalId", default_id) # 存储原始ID
menu = QMenu(toggleBtn)
def setId(original_id):
toggleBtn.setText(f"目的节点id: {id_display_map[original_id]}")
toggleBtn.setProperty("originalId", original_id)
print(f"目的节点id设为 {original_id}")
for original_id, display_text in id_display_map.items():
menu.addAction(display_text).triggered.connect(
lambda checked, id=original_id: setId(id)
)
toggleBtn.setMenu(menu)
return toggleBtn
def createSlotButton(self):
slotBtn = QPushButton("时隙表: 01") # 默认选中01
menu = QMenu(slotBtn)
slotOptions = ["01", "02", "03"]
def setSlot(text):
slotBtn.setText(f"时隙表: {text}")
print(f"时隙表设为 {text}")
for opt in slotOptions:
menu.addAction(opt).triggered.connect(lambda checked, t=opt: setSlot(t))
slotBtn.setMenu(menu)
return slotBtn
def createRateButton(self):
rateBtn = QPushButton("速率: 128kpbs") # 默认选中01
menu = QMenu(rateBtn)
rateOptions = ["128kpbs", "512kpbs", "2Mbps"]
def setRate(text):
rateBtn.setText(f"速率: {text}")
print(f"速率设为 {text}")
for opt in rateOptions:
menu.addAction(opt).triggered.connect(lambda checked, t=opt: setRate(t))
rateBtn.setMenu(menu)
return rateBtn
def buildBindCommand(self, switch_text, id_text, rate_text, slot_text):
"""
switch_text: "开关: On" 或 "开关: Off"
id_text: 形如 "id: 00", 只取后两位字符串
rate_text: "速率: 01" 对应 1/2/3
slot_text: "时隙表: 01" 对应 1/2/3
返回拼接好的指令字符串,如 "5A 54 E3 EE AA 01 22 01 00 ?? ?? 5A FE"
"""
# 头部固定
frame = [0x5A, 0x54, 0xE3, 0xEE]
# 开关字段:On -> 0xAA,Off -> 0x55
if switch_text.endswith("On"):
frame.append(0xAA)
else:
frame.append(0x55)
# ID字段,转为整数
try:
# 直接获取存储的原始ID(如"01")
original_id = self.idButton.property("originalId")
id_val = int(original_id, 16) # 转为16进制整数
except:
id_val = 0x00 # 异常时默认值
frame.append(id_val)
# 速率字段对应映射(参考原来速率的0x22等)
rate_map = {"128kpbs": 0x22, "512kpbs": 0x33, "2Mbps": 0x44}
rate_key = rate_text.split(":")[1].strip()
rate_val = rate_map.get(rate_key, 0x22)
frame.append(rate_val)
# 时隙表,直接转为整数
try:
slot_val = int(slot_text.split(":")[1].strip())
except:
slot_val = 0x00
frame.append(slot_val)
# 后续固定填充和校验(填充字节+校验和+06 5A FE)
frame.append(0x00) # 填充字节
# 校验和计算(从第3字节开始到最后填充前)
checksum = sum(frame[2:]) & 0xFF
frame.append(checksum)
# 结尾
frame.extend([0x06, 0x5A, 0xFE])
# 转成空格分隔的大写16进制字符串
return " ".join(f"{b:02X}" for b in frame)
def buildimageCommand(self, switch_text, toid_text, rate_text, slot_text, image_index=0):
# 头部固定
frame = [0x5A, 0x54, 0xE4, 0xEE]
if image_index == 0:#两个图片的序号不同
frame.append(0x01)
else:
frame.append(0x02)
frame.extend([0x00, 0x00, 0x00])
# ID字段,转为整数
try:
original_toid = self.toidButton.property("originalId")
id_val = int(original_toid, 16)
except:
id_val = 0x01 # 异常时默认值
frame.append(id_val)
# 根据索引选择图片数据
if image_index == 0:
image_data = self.IMAGE1_DATA
else:
image_data = self.IMAGE2_DATA
# 计算图片数据长度(2字节表示,这里使用小端模式)
data_length = len(image_data)
# 拆分长度为高8位和低8位
high_byte = (data_length >> 8) & 0xFF # 高8位
low_byte = data_length & 0xFF # 低8位
frame.extend([low_byte, high_byte]) # 小端模式:低位字节在前,高位字节在后
# 根据索引选择图片数据
if image_index == 0:
frame.extend(self.IMAGE1_DATA)
else:
frame.extend(self.IMAGE2_DATA)
frame.append(0x00) # 填充字节
# 校验和计算(从第3字节开始到最后填充前)
checksum = sum(frame[2:]) & 0xFF
frame.append(checksum)
# 计算数据段长度:从第三个字节(索引2)到dummy byte(当前frame的最后一个字节)
# 长度 = 总字节数 - 前两个字节(因为前两个是帧头,不算数据段)
data_segment_length = len(frame) -4 # len(frame)此时是:2(头) + 数据段内容长度 + 1(dummy)
# 替换固定值0xC4为计算出的长度,再添加后续固定字节
frame.extend([data_segment_length, 0x5A, 0xFE])
# 转成空格分隔的大写16进制字符串
return " ".join(f"{b:02X}" for b in frame)
def send_next_image(self):
if self.cycle_count < 5: # 循环5次
# 读取按钮状态
switch_text = self.toggleButton.text()
id_text = self.idButton.text()
slot_text = self.slotButton.text()
rate_text = self.rateButton.text()
toid_text = self.toidButton.text()
cmd_str = self.buildimageCommand(
switch_text, toid_text, rate_text, slot_text,
self.image_index # 传入当前图片索引
)
print(f"第{self.cycle_count + 1}次发送,图片{self.image_index + 1}: {cmd_str}")
# 实际发送数据
data_bytes = self.parseSendData(
cmd_str,
encoding=self.configGlobal["encoding"],
isHexStr=True
)
if data_bytes:
self.send(data_bytes, callback=self.onSent)
# 切换图片索引(0<->1)
self.image_index = 1 - self.image_index
self.cycle_count += 1
else:
# 循环结束,重置状态
self.send_timer.stop()
self.cycle_count = 0
self.image_index = 0
# 重新启用按钮
self.image_send_btn.setEnabled(True)
print("循环发送完成")
def onWidgetMain(self, parent):
self.mainWidget = QSplitter(Qt.Vertical)
imageContainer = QSplitter(Qt.Horizontal)
self.widgets = []
for i in range(2):
if "image" in graphWidgets:
imageWidgetClass = graphWidgets["image"]
imageWidget = imageWidgetClass(
hintSignal=self.hintSignal,
rmCallback=lambda widget: None,
send=self.sendData,
config={}
)
self.widgets.append(imageWidget)
frame = QFrame()
frame.setFrameShape(QFrame.StyledPanel)
frame.setFrameShadow(QFrame.Raised)
frame.setStyleSheet("QFrame { border: 1px solid #999; border-radius: 6px; margin: 4px; }")
layout = QVBoxLayout()
layout.setContentsMargins(6, 6, 6, 6)
layout.addWidget(imageWidget)
frame.setLayout(layout)
imageContainer.addWidget(frame)
else:
placeholder = QLabel("No graph widget configured")
placeholder.setAlignment(Qt.AlignCenter)
imageContainer.addWidget(placeholder)
self.mainWidget.addWidget(imageContainer)
self.customSendScroll = QScrollArea()
self.customSendScroll.setMinimumHeight(20)
self.customSendScroll.setWidgetResizable(True)
self.customSendScroll.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.customSendScroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
sendItemsWrapper = QWidget()
self.customSendScroll.setWidget(sendItemsWrapper)
sendItemsOuterWrapper = QWidget()
sendItemsOuterWrapper.setProperty("class", "scrollbar2")
layout0 = QVBoxLayout()
layout0.setContentsMargins(0, 8, 0, 0)
sendItemsOuterWrapper.setLayout(layout0)
layout0.addWidget(self.customSendScroll)
sendItemsLayoutWrapper = QVBoxLayout()
sendItemsLayoutWrapper.setContentsMargins(0, 0, 0, 0)
sendItemsWrapper.setLayout(sendItemsLayoutWrapper)
self.customItems = QWidget()
self.customSendItemsLayout = QGridLayout()
self.customSendItemsLayout.setContentsMargins(8, 4, 8, 4)
self.customItems.setLayout(self.customSendItemsLayout)
sendItemsLayoutWrapper.addWidget(self.customItems)
sendItemsLayoutWrapper.addStretch(0)
self.mainWidget.addWidget(sendItemsOuterWrapper)
# 网络状态标签初始化
self.networkStatusLabel = QLabel("节点状态: 未知")
self.networkStatusLabel.setAlignment(Qt.AlignLeft)
self.networkStatusLabel.setFont(QFont("Arial", 10))
self.networkPhaseLabel = QLabel("天线温度: 未知")
self.networkPhaseLabel.setAlignment(Qt.AlignLeft)
self.networkPhaseLabel.setFont(QFont("Arial", 10))
self.networktemLabel = QLabel("电压状态: 未知")
self.networktemLabel.setAlignment(Qt.AlignLeft)
self.networktemLabel.setFont(QFont("Arial", 10))
self.networkvoltageLabel = QLabel("fgpa温度: 未知")
self.networkvoltageLabel.setAlignment(Qt.AlignLeft)
self.networkvoltageLabel.setFont(QFont("Arial", 10))
# 设置主窗口比例
self.mainWidget.setStretchFactor(0, 6) # 图像区域
self.mainWidget.setStretchFactor(1, 4) # 自定义发送区域
return self.mainWidget
def clearLayout(self, layout):
while layout.count():
item = layout.takeAt(0)
widget = item.widget()
if widget:
widget.setParent(None)
def createSendItemWidget(self, item):
caption = item["caption"]
itemWidget = QWidget()
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
itemWidget.setLayout(layout)
send = QPushButton("")
label = QLabel(caption)
icon = item.get("icon", "fa.send")
utils_ui.setButtonIcon(send, icon)
send.setProperty("class", "smallBtn")
def sendCustomData():
self.sendCustomItem(item)
send.clicked.connect(sendCustomData)
layout.addWidget(label)
layout.addWidget(send)
return itemWidget
def onUiInitDone(self):
# 清空旧布局
self.clearLayout(self.customSendItemsLayout)
# 创建“开关”、“ID”、“时隙表”、“速率”按钮,供“总控”使用
self.toggleButton = self.createToggleButton()
self.customSendItemsLayout.addWidget(self.toggleButton, 1, 0, 1, 2)
self.idButton = self.createIdButton()
self.customSendItemsLayout.addWidget(self.idButton, 0, 1)
self.slotButton = self.createSlotButton()
self.customSendItemsLayout.addWidget(self.slotButton, 0, 2)
self.rateButton = self.createRateButton()
self.customSendItemsLayout.addWidget(self.rateButton, 0, 0)
self.toidButton = self.createtoIdButton()
self.customSendItemsLayout.addWidget(self.toidButton, 0, 3)
# 第一行固定插入“自检”、“图片传输”、“总控”
for item in self.config["customSendItems"]:
if item["caption"] == "自检项":
print("找到自检项,准备添加到(0,0)") # 新增
w = self.createSendItemWidget(item)
self.customSendItemsLayout.addWidget(w, 3, 0, 1, 2)
elif item["caption"] == "图片传输":
totalControlWidget = QWidget()
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
totalControlWidget.setLayout(layout)
sendBtn = QPushButton("")
self.image_send_btn = sendBtn
label = QLabel("图片传输")
utils_ui.setButtonIcon(sendBtn, item.get("icon", "fa.send"))
sendBtn.setProperty("class", "smallBtn")
# 初始化定时器(确保只初始化一次)
self.send_timer = QtCore.QTimer()
def start_image_cycle():
# 禁用按钮防止重复触发
sendBtn.setEnabled(False)
# 重置计数和索引
self.cycle_count = 0 # 总循环次数(每次循环包含图片1+图片2)
self.image_index = 0 # 当前图片索引(0:图片1,1:图片2)
# 新增:根据当前速率设置定时器间隔
# 1. 定义速率与间隔的映射关系(单位:毫秒)
rate_interval_map = {
"128kpbs": 1500, # 128kpbs对应1.5秒
"512kpbs": 1000, # 256kpbs对应1秒
"2Mbps": 500 # 2Mbps对应0.5秒
}
# 2. 获取当前选中的速率
rate_text = self.rateButton.text() # 格式为"速率: xxx"
rate_key = rate_text.split(":")[1].strip() # 提取"128kpbs"等关键部分
# 3. 获取对应的间隔时间(默认1秒)
interval = rate_interval_map.get(rate_key, 1000)
# 4. 启动定时器(使用动态计算的间隔)
self.send_timer.start(interval)
# 定义循环发送逻辑
def send_image_cycle():
# 读取按钮状态
switch_text = self.toggleButton.text()
id_text = self.idButton.text()
slot_text = self.slotButton.text()
rate_text = self.rateButton.text()
toid_text = self.toidButton.text()
# 构建当前图片指令
cmd_str = self.buildimageCommand(
switch_text, toid_text, rate_text, slot_text, self.image_index
)
print(f"第{self.cycle_count + 1}次循环,图片{self.image_index + 1}: {cmd_str}")
# 发送数据
data_bytes = self.parseSendData(
cmd_str,
encoding=self.configGlobal["encoding"],
isHexStr=True
)
if data_bytes:
self.send(data_bytes, callback=self.onSent)
# 切换图片索引(0<->1)
self.image_index = 1 - self.image_index
# 当图片索引回到0时,代表完成一次完整循环(图片1+图片2)
if self.image_index == 0:
self.cycle_count += 1
# 达到5次循环则停止
if self.cycle_count >= 5:
self.send_timer.stop()
sendBtn.setEnabled(True) # 恢复按钮可用
print("循环发送完成")
# 绑定定时器触发事件
self.send_timer.timeout.connect(send_image_cycle)
# 绑定按钮点击事件(启动循环)
sendBtn.clicked.connect(start_image_cycle)
layout.addWidget(label)
layout.addWidget(sendBtn)
self.customSendItemsLayout.addWidget(totalControlWidget, 3, 2, 1, 2 )
elif item["caption"] == "配置发送":
totalControlWidget = QWidget()
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
totalControlWidget.setLayout(layout)
sendBtn = QPushButton("")
label = QLabel("配置发送")
utils_ui.setButtonIcon(sendBtn, item.get("icon", "fa.send"))
sendBtn.setProperty("class", "smallBtn")
def sendTotalControl():
# 读取4个按钮当前文本
switch_text = self.toggleButton.text()
id_text = self.idButton.text()
slot_text = self.slotButton.text()
rate_text = self.rateButton.text()
# 动态构造指令字符串S
cmd_str = self.buildBindCommand(switch_text, id_text, rate_text, slot_text)
print(f"配置发送: {cmd_str}")
data_bytes = self.parseSendData(cmd_str,
encoding=self.configGlobal["encoding"],
isHexStr=True)
if data_bytes:
self.send(data_bytes, callback=self.onSent)
sendBtn.clicked.connect(sendTotalControl)
layout.addWidget(label)
layout.addWidget(sendBtn)
self.customSendItemsLayout.addWidget(totalControlWidget, 1, 2, 1, 2)
# 第三行放4个状态标签
self.customSendItemsLayout.addWidget(self.networkStatusLabel, 2, 0)
self.customSendItemsLayout.addWidget(self.networkPhaseLabel, 2, 1)
self.customSendItemsLayout.addWidget(self.networkvoltageLabel, 2, 2)
self.customSendItemsLayout.addWidget(self.networktemLabel, 2, 3)
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)
count = self.customSendItemsLayout.count()
row = count // 4 # 每 4 个换行
col = count % 4
self.customSendItemsLayout.addWidget(itemWidget,row,col)
if not load:
self.config["customSendItems"].append(item)
return item
def onReceived(self, data: bytes):
print('>')
print(data)
self.statusBar.addRx(len(data)) # 确保self在此处有定义(类成员)
# 新增:判断数据类型并获取二进制帧数据
binary_data = None
try:
# 尝试解码为十六进制字符串(处理第一种格式)
hex_str = data.decode('utf-8')
# 清理空格和换行
cleaned_hex = hex_str.replace(' ', '').replace('\n', '').replace('\r', '')
# 验证是否为有效的十六进制字符
if all(c in '0123456789ABCDEFabcdef' for c in cleaned_hex):
binary_data = bytes.fromhex(cleaned_hex)
print(f"转换后的二进制数据长度: {len(binary_data)} 字节")
else:
# 不是纯十六进制字符串,视为原始二进制数据
binary_data = data
except UnicodeDecodeError:
# 解码失败,说明是原始二进制数据(处理第二种格式)
binary_data = data
print(f"直接使用原始二进制数据,长度: {len(binary_data)} 字节")
except ValueError as e:
print(f"十六进制转换失败: {e}")
return
if not binary_data:
print("无有效二进制数据")
return
# 第二步:对二进制帧数据解析指令
try:
# 帧头为0x5A54(即b'ZT'),前2字节为帧头,第3字节为cmd_id
if len(binary_data) >= 3 and binary_data[:2] == b'\x5A\x54':
cmd_id = binary_data[2]
print(f"收到指令: cmd_id=0x{cmd_id:02X}")
if cmd_id == 0xE5: # 图像测试回令
result = self.evalimageTestRsp(binary_data)
self.showReceiveDataSignal.emit(result)
return
elif cmd_id == 0xE1: # 自检回令
result = self.evalSelfTestRsp(binary_data)
self.showReceiveDataSignal.emit(result)
return
else:
print("未匹配帧头(5A54),进入PNG解析逻辑")
except Exception as e:
print(f"指令解析失败: {e}")
# 第三步:PNG解析逻辑
if not hasattr(self, "png_buffer"):
self.png_buffer = bytearray()
self.png_buffer.extend(binary_data) # 使用处理后的二进制数据累积
png_start = self.png_buffer.find(b'\x89PNG\r\n\x1a\n')
print(f"png_start: {png_start}")
if png_start != -1:
png_candidate = self.png_buffer[png_start:]
iend_pos = png_candidate.rfind(b'IEND\xae\x42\x60\x82')
if iend_pos != -1:
complete_png = png_candidate[:iend_pos + 8]
for widget in self.widgets:
widget.onData(complete_png)
self.png_buffer.clear()
else:
pass
else:
# 超过一定长度仍未找到PNG头则清空,避免内存溢出
if len(self.png_buffer) > 1024 * 1024: # 1MB阈值
self.png_buffer.clear()
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 evalSelfTestRsp(self, data: bytes):
print('“”“”“”“”“”“”“”“”“”“”“”“')
try:
# 1. 先解析头部获取数据长度和图片类型标识
header_struct = Struct("<2s B B") # 前11字节结构
header_data = header_struct.unpack(data[:4])
frame_head, cmd_id, node_type= header_data
print(data)
print(header_data)
img_flag = data[7:8] # 第八个字节
print('m')
# 3. 动态构建完整结构体
struct_format = f"<2s B B BBBBbbb 2B 2B 2B BBbBB 3s B B B 2s"
full_struct = Struct(struct_format)
print('km')
# 计算结构体要求的总长度
required_len = 30 # 头部11 + 数据段data_len + 尾部5
print(f"预期长度: {required_len}, 实际数据长度: {len(data)}")
payload = full_struct.unpack(data)
print('lm')
except Exception as e:
print('x')
return f"\n### evalselfTestRsp:: Failed to unpack data (data length {len(data)} byte).\n错误信息: {str(e)}"
ret = "----------- 自检回令 -----------\n"
ret += f"节点编号: 0x{payload[-2]:02X}\n"
ret += "节点状态: "
if payload[3] == 0xAA:
ret += f"正常 (0x{payload[3]:02X})\n"
network_status='正常'
elif payload[6] == 0x55:
ret += f"异常 (0x{payload[3]:02X})\n"
network_status='异常'
else:
ret += f"【未知错误】(0x{payload[3]:02X})\n"
network_status='未知错误'
hwOffset = 4
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"
print(payload[3])
ret += f"天线-2 工作 PLL: {(payload[hwOffset+7] >> 15) & 0x01:>1d}\n"
ret += f"天线-2 工作频率: {(payload[hwOffset+7] & 0x7FFF)+3700:>4d}\n"
print(payload[3])
ret += f"天线-3 工作 PLL: {(payload[hwOffset+8] >> 15) & 0x01:>1d}\n"
ret += f"天线-3 工作频率: {(payload[hwOffset+8] & 0x7FFF)+3700:>4d}\n"
print(payload[3])
ret += f"天线 PLL 锁定状态: {bin(payload[hwOffset+9])[2:].zfill(8)}\n"
print(payload[3])
ret += f"天线工作模式: {bin(payload[hwOffset+10])[2:].zfill(8)}\n"
ret += f"天线温度: {payload[hwOffset+11]:>4d}\n"
print(payload[3])
ret += "--------------------------------\n"
print(payload[3])
print(network_status)
phase=payload[14]
temp=payload[9]
voltage=payload[4]
self.networkStatusLabel.setText(f"节点状态: {network_status}")
self.networkPhaseLabel.setText(f"天线温度: {phase}")
self.networkvoltageLabel.setText(f"电压状态: {voltage}")
self.networktemLabel.setText(f"fgpa温度: {temp}")
return ret + '\n' + self.printFrame(data)
def evalimageTestRsp(self, data: bytes):
print('“”“”“”“”“”“”“”“”“”“”“”“')
try:
# 1. 先解析头部获取数据长度和图片类型标识
header_struct = Struct("<2s B B I B H") # 前11字节结构
header_data = header_struct.unpack(data[:11])
frame_head, cmd_id, node_type, data_id, from_id, data_len = header_data
print(data)
print(header_data)
print(data_len)
# 2. 获取第八个字节的图片类型标识(01/02)
img_flag = data[7:8] # 第八个字节
print('m')
# 3. 动态构建完整结构体
struct_format = f"<2s B B I B H {data_len}s B B B 2s"
full_struct = Struct(struct_format)
print('km')
# 计算结构体要求的总长度
required_len = 11 + data_len + 5 # 头部11 + 数据段data_len + 尾部5
print(f"预期长度: {required_len}, 实际数据长度: {len(data)}")
payload = full_struct.unpack(data)
print('lm')
except Exception as e:
print('x')
return f"\n### evalimageTestRsp:: Failed to unpack data (data length {len(data)} byte).\n错误信息: {str(e)}"
ret = "----------- 图像测试回令 -----------\n"
# 字段索引对应(保留原始变量名)
frame_head = payload[0] # bytes: 2 字节帧头
cmd_id = payload[1] # int: 1 字节指令
node_type = payload[2] # int: 1 字节节点类型
data_id = payload[3] # int: 4 字节数据 ID
from_id = payload[4] # int: 1 字节源节点 ID
data_len = payload[5] # int: 2 字节数据长度
image_data = payload[6] # bytes: 动态长度
padding = payload[7] # int: 1 字节填充
checksum = payload[8] # int: 1 字节校验和
data_len2 = payload[9] # int: 1 字节数据段长度
frame_tail = payload[10] # bytes: 2 字节帧尾
# 格式化输出(保留原始输出格式)
ret += f"帧头: {frame_head.hex().upper()} (ascii: {frame_head.decode(errors='ignore')})\n"
ret += f"指令: 0x{cmd_id:02X}\n"
ret += f"节点类型: 0x{node_type:02X}\n"
ret += f"数据 ID: 0x{data_id:08X}\n"
ret += f"源节点 ID: {from_id}\n"
ret += f"数据长度字段: {data_len} 字节\n"
ret += f"数据段实际长度: {len(image_data)} 字节\n"
ret += f"填充字节: 0x{padding:02X}\n"
ret += f"校验和: 0x{checksum:02X}\n"
ret += f"数据段长度: {data_len2} (十六进制: 0x{data_len2:02X})\n"
ret += f"帧尾: {frame_tail.hex().upper()}\n"
print('&&&&&')
# 图像显示逻辑(添加缩放倍数控制)
# 1. 手动设置缩放倍数(可根据需要修改,例如放大2倍)
# 图像显示逻辑(修正后)
if from_id == 0x01 or from_id == 0x02:
# 图像通道 A → 左侧图像控件
if len(self.widgets) >= 1 and isinstance(self.widgets[0], graphWidgets["image"]):
# 仅传递图像数据,缩放倍数已在控件初始化时通过config设置
self.widgets[0].onData(image_data)
else:
self.showReceiveDataSignal.emit("\n### No valid image widget found (A1)\n")
elif from_id == 0x03:
# 图像通道 B → 右侧图像控件
if len(self.widgets) >= 2 and isinstance(self.widgets[1], graphWidgets["image"]):
# 仅传递图像数据
self.widgets[1].onData(image_data)
else:
self.showReceiveDataSignal.emit("\n### No valid image widget found (A2)\n")
print(from_id)
print('+')
ret += "------------------------------------\n"
return ret + '\n' + self.printFrame(data)
print(from_id)
print('+')
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)
Binary file not shown.
File diff suppressed because it is too large Load Diff
Binary file not shown.
Binary file not shown.
Binary file not shown.
File diff suppressed because it is too large Load Diff
+1 -1
Submodule scripts updated: 00960b6b8f...d13f6cb8b3
+2 -2
View File
@@ -1535,10 +1535,10 @@ uint32_t ad9361_reg_config(struct ad9361_reg_dev *dev){
status = ad9361_reg_write(dev, 0x0105, 0x3A); // ADC Large Overload Threshold
status = ad9361_reg_write(dev, 0x0107, 0x2B); // Small LMT Overload Threshold
status = ad9361_reg_write(dev, 0x0108, 0x31); // Large LMT Overload Threshold
status = ad9361_reg_write(dev, 0x0109, 0x00); // Rx1 Full/LMT Gain Index
status = ad9361_reg_write(dev, 0x0109, 0x28); // Rx1 Full/LMT Gain Index
status = ad9361_reg_write(dev, 0x010A, 0x58); // Rx1 LPF Gain Index
status = ad9361_reg_write(dev, 0x010B, 0x00); // Rx1 Digital Gain Index
status = ad9361_reg_write(dev, 0x010C, 0x00); // Rx2 Full/LMT Gain Index
status = ad9361_reg_write(dev, 0x010C, 0x28); // Rx2 Full/LMT Gain Index
status = ad9361_reg_write(dev, 0x010D, 0x18); // Rx2 LPF Gain Index
status = ad9361_reg_write(dev, 0x010E, 0x00); // Rx2 Digital Gain Index
status = ad9361_reg_write(dev, 0x0114, 0x30); // Low Power Threshold
+4 -4
View File
@@ -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
}
};
+6 -6
View File
@@ -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
@@ -259,10 +259,10 @@ int32_t Hardware_Init(void)
// Status = ad9361_reg_read(ad9361_1_reg_inst, 0x0002, &rd_back);
// Status = ad9361_reg_read(ad9361_2_reg_inst, 0x0002, &rd_back);
Status = ad9361_reg_write(ad9361_1_reg_inst, 0x0109, 0x00); // Rx Gain
Status = ad9361_reg_write(ad9361_1_reg_inst, 0x010C, 0x00); // Rx Gain
Status = ad9361_reg_write(ad9361_2_reg_inst, 0x0109, 0x00); // Rx Gain
Status = ad9361_reg_write(ad9361_2_reg_inst, 0x010C, 0x00); // Rx Gain
// Status = ad9361_reg_write(ad9361_1_reg_inst, 0x0109, 0x00); // Rx Gain
// Status = ad9361_reg_write(ad9361_1_reg_inst, 0x010C, 0x00); // Rx Gain
// Status = ad9361_reg_write(ad9361_2_reg_inst, 0x0109, 0x00); // Rx Gain
// Status = ad9361_reg_write(ad9361_2_reg_inst, 0x010C, 0x00); // Rx Gain
#endif
#ifdef AD9653
@@ -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;
+1
View File
@@ -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);
+48 -20
View File
@@ -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"
@@ -78,8 +77,10 @@ struct callback_desc apptimer_callback_desc = {
// .myType = L2_NODE_HEAD,
// .clustId = 1U,
// .myId = 1U,
// .headId = 1U,
// .netScale = 10U,
// .headId = L2_HEAD_ID,
// .netScale = L2_NET_SCALE,
// .initTable = initRoutTable,
// .normalTable = normalRoutTable1,
// .serviceRate = L2_SVC_512K,
// .phyInstPtr = NULL, // physical layer reference
// .tmcInstPtr = NULL
@@ -89,8 +90,10 @@ L2_CONFIG linkConfig = {
.myType = L2_NODE_MEMBER,
.clustId = 1U,
.myId = 2U,
.headId = 1U,
.netScale = 10U,
.headId = L2_HEAD_ID,
.netScale = L2_NET_SCALE,
.initTable = initRoutTable,
.normalTable = normalRoutTable1,
.serviceRate = L2_SVC_512K,
.phyInstPtr = NULL, // physical layer reference
.tmcInstPtr = NULL
@@ -124,14 +127,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 = 16U,
.recvQueueMax = 16U
};
/*********************** 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;
@@ -194,6 +202,7 @@ int32_t SetupInterruptSystem(struct irq_ctrl_desc *descPtr)
XScuGic_CPUWriteReg((XScuGic *)(xil_dev->instance), XSCUGIC_EOI_OFFSET, intrState);
/* Initialize physical layer interrupt. */
// Set interrupt trigger level
Status = irq_trigger_level_set(descPtr, PHY_INTR_ID, IRQ_EDGE_RISING);
if (Status != SUCCESS)
{
@@ -216,6 +225,7 @@ int32_t SetupInterruptSystem(struct irq_ctrl_desc *descPtr)
}
/* Initialize linklayer layer interrupt. */
// Set interrupt trigger level
Status = irq_trigger_level_set(descPtr, PERIODIC_5MS_INTR_ID, IRQ_EDGE_RISING);
if (Status != SUCCESS)
{
@@ -238,17 +248,18 @@ int32_t SetupInterruptSystem(struct irq_ctrl_desc *descPtr)
}
/* Initialize system bus interrupt. */
// Set interrupt trigger level
Status = irq_trigger_level_set(descPtr, SYSBUS_TX_INTR_ID, IRQ_EDGE_RISING);
if (Status != SUCCESS)
{
DBG_ERROR("PHY_INTR trigger level set FAILED, ErrorCode: %" PRId32 ".\n", Status);
DBG_ERROR("SYSBUS_TX_INTR trigger level set FAILED, ErrorCode: %" PRId32 ".\n", Status);
return Status;
}
// Set interrupt priority
Status = irq_set_priority(descPtr, SYSBUS_TX_INTR_ID, 0x10);
if (Status != SUCCESS)
{
DBG_ERROR("PHY_INTR priority level set FAILED, ErrorCode: %" PRId32 ".\n", Status);
DBG_ERROR("SYSBUS_TX_INTR priority level set FAILED, ErrorCode: %" PRId32 ".\n", Status);
return Status;
}
@@ -256,20 +267,22 @@ int32_t SetupInterruptSystem(struct irq_ctrl_desc *descPtr)
Status = irq_register_callback(descPtr, SYSBUS_TX_INTR_ID, &sysbus_tx_callback_desc);
if (Status != SUCCESS)
{
DBG_ERROR("PHY_INTR register callback FAILED, ErrorCode: %" PRId32 ".\n", Status);
DBG_ERROR("SYSBUS_TX_INTR register callback FAILED, ErrorCode: %" PRId32 ".\n", Status);
return Status;
}
// Set interrupt trigger level
Status = irq_trigger_level_set(descPtr, SYSBUS_RX_INTR_ID, IRQ_EDGE_RISING);
if (Status != SUCCESS)
{
DBG_ERROR("PHY_INTR trigger level set FAILED, ErrorCode: %" PRId32 ".\n", Status);
DBG_ERROR("SYSBUS_RX_INTR trigger level set FAILED, ErrorCode: %" PRId32 ".\n", Status);
return Status;
}
// Set interrupt priority
Status = irq_set_priority(descPtr, SYSBUS_RX_INTR_ID, 0x18);
if (Status != SUCCESS)
{
DBG_ERROR("PHY_INTR priority level set FAILED, ErrorCode: %" PRId32 ".\n", Status);
DBG_ERROR("SYSBUS_RX_INTR priority level set FAILED, ErrorCode: %" PRId32 ".\n", Status);
return Status;
}
@@ -277,7 +290,7 @@ int32_t SetupInterruptSystem(struct irq_ctrl_desc *descPtr)
Status = irq_register_callback(descPtr, SYSBUS_RX_INTR_ID, &sysbus_rx_callback_desc);
if (Status != SUCCESS)
{
DBG_ERROR("PHY_INTR register callback FAILED, ErrorCode: %" PRId32 ".\n", Status);
DBG_ERROR("SYSBUS_RX_INTR register callback FAILED, ErrorCode: %" PRId32 ".\n", Status);
return Status;
}
@@ -286,7 +299,7 @@ int32_t SetupInterruptSystem(struct irq_ctrl_desc *descPtr)
Status = irq_register_callback(descPtr, APPTIMER_INTR_ID, &apptimer_callback_desc);
if (Status != SUCCESS)
{
DBG_ERROR("PHY_INTR register callback FAILED, ErrorCode: %" PRId32 ".\n", Status);
DBG_ERROR("APPTIMER_INTR register callback FAILED, ErrorCode: %" PRId32 ".\n", Status);
return Status;
}
@@ -414,9 +427,24 @@ void AppTimer_IntrHandler(void *context)
{
Phy_UpdateLogging(phyInstPtr);
}
/*
* Read the new Control/Status Register content.
*/
uint32_t ControlStatusReg;
ControlStatusReg = XTmrCtr_ReadReg(((XTmrCtr *)xdesc->instance)->BaseAddress,
0, XTC_TCSR_OFFSET);
/*
* Acknowledge the interrupt by clearing the
* interrupt bit in the timer control status
* register, this is done after calling the
* handler so the application could call
* IsExpired, the interrupt is cleared by
* writing a 1 to the interrupt bit of the
* register without changing any of the other
* bits
*/
XTmrCtr_WriteReg(((XTmrCtr *)xdesc->instance)->BaseAddress, 0,
XTC_TCSR_OFFSET, XTC_CSR_INT_OCCURED_MASK);
XTC_TCSR_OFFSET, ControlStatusReg | XTC_CSR_INT_OCCURED_MASK);
}
#else
#error No timer implementation!
@@ -448,7 +476,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");
@@ -538,7 +566,7 @@ int main(void)
}
// Start System Monitor logging.
timer_start(logTmPtr);
Status = timer_start(logTmPtr);
DBG_PRINT("Physical started...\n");
Phy_Start(phyInstPtr);
@@ -555,7 +583,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)
+9 -10
View File
@@ -22,14 +22,13 @@
#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"
#include "circ_queue.h"
#include "../time_ctrl/time_ctrl.h"
#ifndef EMULATION
#include "../config/app_config.h"
#include "../../config/app_config.h"
#endif
/************************** Constant Definitions *****************************/
#define NET_START_TIME_INFTY UINT32_MAX
@@ -602,8 +601,8 @@ int32_t Linklayer_Init(L2_INST **instPtr, const L2_CONFIG *config)
(*instPtr)->tor.last = L2_TOR_SUSPEND;
(*instPtr)->tor.curr = L2_TOR_SUSPEND;
(*instPtr)->tor.next = L2_TOR_SUSPEND;
(*instPtr)->rtneConfig.rtneTable = initTable;
(*instPtr)->rtneConfig.rtnePrd = ARRAY_SIZE(initTable);
(*instPtr)->rtneConfig.rtneTable = (*instPtr)->config.initTable;
(*instPtr)->rtneConfig.rtnePrd = ARRAY_SIZE(initRoutTable);
(*instPtr)->mainState = L2_INIT_STATE;
(*instPtr)->nextState = L2_INIT_STATE;
(*instPtr)->myInfo.nodeId = config->myId;
@@ -699,8 +698,8 @@ int32_t Linklayer_Reconfig(L2_INST *instPtr, const L2_CONFIG *config)
instPtr->tor.last = L2_TOR_SUSPEND;
instPtr->tor.curr = L2_TOR_SUSPEND;
instPtr->tor.next = L2_TOR_SUSPEND;
instPtr->rtneConfig.rtneTable = initTable;
instPtr->rtneConfig.rtnePrd = ARRAY_SIZE(initTable);
instPtr->rtneConfig.rtneTable = instPtr->config.initTable;
instPtr->rtneConfig.rtnePrd = ARRAY_SIZE(initRoutTable);
instPtr->mainState = L2_INIT_STATE;
instPtr->nextState = L2_INIT_STATE;
instPtr->myInfo.nodeId = config->myId;
@@ -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 = instPtr->config.initTable;
instPtr->rtneConfig.rtnePrd = ARRAY_SIZE(initRoutTable);
}
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 = instPtr->config.normalTable;
instPtr->rtneConfig.rtnePrd = ARRAY_SIZE(normalRoutTable1);
}
else
{
+12 -5
View File
@@ -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)))
@@ -44,6 +45,8 @@ typedef struct
uint8_t headId; ///< head node id
uint8_t netScale; ///< net scale
L2_SVC_RATE serviceRate; ///< service data rate
L2_RTNE_TABLE_ENTRY **initTable;
L2_RTNE_TABLE_ENTRY **normalTable;
PHY_INST *phyInstPtr; ///< pointer to system physical layer instance
TMC_INST *tmcInstPtr; ///< pointer to system timer controller layer instance
} L2_CONFIG;
@@ -92,8 +95,10 @@ typedef struct
int64_t timeDev; ///< last time deviation estimation result
uint32_t reconnectCnt; ///< reconnect trial count
PAYLOAD rxLog;
PAYLOAD txLog;
uint32_t txValidMsgCnt; ///< non-default tx message count
uint32_t rxValidMsgCnt; ///< non-default rx message count
L2_MSG_RECORD rxLog;
L2_MSG_RECORD txLog;
} L2_LOG;
/**
@@ -128,8 +133,10 @@ typedef struct
} L2_INST;
/************************** 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 *initRoutTable[L2_INIT_RTNE_PERIOD];
extern L2_RTNE_TABLE_ENTRY *normalRoutTable1[L2_INIT_RTNE_PERIOD];
extern L2_RTNE_TABLE_ENTRY *normalRoutTable2[L2_INIT_RTNE_PERIOD];
extern L2_RTNE_TABLE_ENTRY *normalRoutTable3[L2_INIT_RTNE_PERIOD];
/************************** Function Prototypes ******************************/
/**
* @defgroup LinkLayer_Main
+5 -3
View File
@@ -25,7 +25,7 @@
#include "geometry/quaternion.h"
#include "../phy_layer/phy_layer.h"
#ifndef EMULATION
#include "../config/app_config.h"
#include "../../config/app_config.h"
#endif
/************************** Constant Definitions *****************************/
/**
@@ -36,7 +36,10 @@
#define L2_BROADCAST_ID1 0xF1 // broadcast
#define L2_BROADCAST_ID2 0xF2
#define L2_BROADCAST_ID3 0xF4
#define L2_NONE_ID 0
#define L2_UNICAST_ID 0xF0
#define L2_NONE_ID 0U
#define L2_HEAD_ID 1U
#define L2_NET_SCALE 10U
// Routine configure
#define L2_INIT_RTNE_PERIOD 1
@@ -206,7 +209,6 @@ typedef struct
uint8_t dst; ///< destination node ID
} L2_RTNE_TABLE_ENTRY;
/**
* @struct L2_SCAN_FSM
* @brief Linklayer scan process FSM instance
+30 -15
View File
@@ -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*/
+618 -55
View File
@@ -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] =
L2_RTNE_TABLE_ENTRY *initRoutTable[L2_INIT_RTNE_PERIOD] =
{
innerScanSubT
tab10Mng10Svc
};
L2_RTNE_TABLE_ENTRY *normalTable[L2_NORMAL_RTNE_PERIOD] =
L2_RTNE_TABLE_ENTRY *normalRoutTable1[L2_INIT_RTNE_PERIOD] =
{
innerScanSubT
tab10Mng10Svc
};
L2_RTNE_TABLE_ENTRY *normalRoutTable2[L2_INIT_RTNE_PERIOD] =
{
tab10Mng3Svc
};
L2_RTNE_TABLE_ENTRY *normalRoutTable3[L2_INIT_RTNE_PERIOD] =
{
tab3Mng3Svc
};
/** @} RoutineTable*/
+61 -32
View File
@@ -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,26 @@ 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);
free(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 +276,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 maxDataLen = L2_PAYLOAD_LEN_ACK;
// Update node status.
uint8_t nodeId = message->common.src;
@@ -310,13 +326,26 @@ 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
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);
free(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 +519,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 +552,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:
+137 -35
View File
@@ -29,7 +29,7 @@
#include "common.h"
#include "circ_queue.h"
#ifndef EMULATION
#include "../config/app_config.h"
#include "../../config/app_config.h"
#endif
/************************** Constant Definitions *****************************/
/***************** Macros (Inline Functions) Definitions *********************/
@@ -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,37 @@ 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, dstId);
if(sendPayload == NULL)
{
message->common.dst = L2_NONE_ID;
message->dataId = DATA_ID_NONE;
message->dataLen = 0;
memset(message->data, 0xAA, maxDataLen);
}
else
{
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);
// logging
instPtr->log.txValidMsgCnt++;
}
}
else
{
message->common.dst = L2_NONE_ID;
message->dataId = DATA_ID_NONE;
message->dataLen = 0;
memset(message->data, 0xAA, maxDataLen);
}
// Append CRC
@@ -214,8 +240,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 +267,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 +278,26 @@ 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, dstId);
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->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);
// logging
instPtr->log.txValidMsgCnt++;
}
// Append CRC
@@ -270,9 +311,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 +338,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 +350,25 @@ 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, dstId);
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->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);
// logging
instPtr->log.txValidMsgCnt++;
}
// Append CRC
@@ -327,9 +382,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 +492,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 +531,27 @@ 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);
free(recvPayload);
// logging
instPtr->log.rxValidMsgCnt++;
}
// 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 +583,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 +622,27 @@ 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);
free(recvPayload);
// logging
instPtr->log.rxValidMsgCnt++;
}
// 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 +674,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 +713,27 @@ 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);
free(recvPayload);
// logging
instPtr->log.rxValidMsgCnt++;
}
// 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 +865,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 +899,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 +933,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:
+216 -156
View File
@@ -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, 10U, 10U,
10U, 10U, 10U, 10U, 10U, 10U, 10U, 10U,
10U, 10U, 10U, 10U, 10U, 10U, 10U, 10U,
10U, 10U, 10U, 10U, 10U, 10U, 10U, 10U,
10U, 10U, 10U, 10U, 10U, 10U,
};
/** @} 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;
+52 -7
View File
@@ -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];
@@ -696,6 +696,7 @@ int32_t Phy_SetupNextSlot(PHY_INST *instPtr, PHY_TOR_TYPE txrxMode,
ASSERT(instPtr != NULL);
int32_t Status;
uint32_t phyModeCtrl, hopNum;
uint16_t txMultifactor; // physical layer tx power digital attenuation
const uint8_t *hopPattern;
// Implement a ping-pong flow, offset always is 0 or half of buffer depth.
instPtr->antConfigOffset = (L1_ANTCONFIG_MAX_LEN >> 1) - instPtr->antConfigOffset;
@@ -717,34 +718,71 @@ int32_t Phy_SetupNextSlot(PHY_INST *instPtr, PHY_TOR_TYPE txrxMode,
}
switch (frameType)
{
#ifdef HSJL_GE
case L1_FRAME_ADV_24MS:
phyModeCtrl |= PHY_MODE_CTRL_FRAME_ADV_24MS;
hopNum = L1_FRAME_ADV_24MS_HOPS;
hopPattern = hopPattern_ADV_24MS;
txMultifactor = 0x1f00; // -12dB
break;
case L1_FRAME_ACK_8MS:
phyModeCtrl |= PHY_MODE_CTRL_FRAME_ACK_8MS;
hopNum = L1_FRAME_ACK_8MS_HOPS;
hopPattern = hopPattern_ACK_8MS;
txMultifactor = 0x1f00; // -12dB
break;
case L1_FRAME_128KBPS_4MS:
phyModeCtrl |= PHY_MODE_CTRL_FRAME_128KBPS_4MS;
hopNum = L1_FRAME_128KBPS_4MS_HOPS;
hopPattern = hopPattern_128KBPS_4MS;
txMultifactor = 0x2000; // -15dB
break;
case L1_FRAME_512KBPS_4MS:
phyModeCtrl |= PHY_MODE_CTRL_FRAME_512KBPS_4MS;
hopNum = L1_FRAME_512KBPS_4MS_HOPS;
hopPattern = hopPattern_512KBPS_4MS;
txMultifactor = 0x2000; // -12dB
break;
case L1_FRAME_2MBPS_4MS:
phyModeCtrl |= PHY_MODE_CTRL_FRAME_2MBPS_4MS;
hopNum = L1_FRAME_2MBPS_4MS_HOPS;
hopPattern = hopPattern_2MBPS_4MS;
txMultifactor = 0x7000; // -6dB, baseline
break;
#else
case L1_FRAME_ADV_24MS:
phyModeCtrl |= PHY_MODE_CTRL_FRAME_ADV_24MS;
hopNum = L1_FRAME_ADV_24MS_HOPS;
hopPattern = hopPattern_ADV_24MS;
txMultifactor = 0x0A00; // -12dB
break;
case L1_FRAME_ACK_8MS:
phyModeCtrl |= PHY_MODE_CTRL_FRAME_ACK_8MS;
hopNum = L1_FRAME_ACK_8MS_HOPS;
hopPattern = hopPattern_ACK_8MS;
txMultifactor = 0x0A00; // -12dB
break;
case L1_FRAME_128KBPS_4MS:
phyModeCtrl |= PHY_MODE_CTRL_FRAME_128KBPS_4MS;
hopNum = L1_FRAME_128KBPS_4MS_HOPS;
hopPattern = hopPattern_128KBPS_4MS;
txMultifactor = 0x0F00; // -15dB
break;
case L1_FRAME_512KBPS_4MS:
phyModeCtrl |= PHY_MODE_CTRL_FRAME_512KBPS_4MS;
hopNum = L1_FRAME_512KBPS_4MS_HOPS;
hopPattern = hopPattern_512KBPS_4MS;
txMultifactor = 0x1000; // -12dB
break;
case L1_FRAME_2MBPS_4MS:
phyModeCtrl |= PHY_MODE_CTRL_FRAME_2MBPS_4MS;
hopNum = L1_FRAME_2MBPS_4MS_HOPS;
hopPattern = hopPattern_2MBPS_4MS;
txMultifactor = 0x2000; // -6dB, baseline
break;
#endif
default:
return EPARAM;
break;
}
// Set frame configs
@@ -794,6 +832,9 @@ int32_t Phy_SetupNextSlot(PHY_INST *instPtr, PHY_TOR_TYPE txrxMode,
}
}
// Set tx multifactor
PhyWrite(instPtr, TX_MULFAC, txMultifactor);
// Trigger physical configuration.
// Indicate physical layer that all the configurations were done.
PhyWrite(instPtr, SLOT_CMD, SLOT_CMD_KEY);
@@ -1026,9 +1067,10 @@ void Phy_RefreshHwSate(PHY_INST *instPtr)
instPtr->hwSate.spFpgaTemp = (evalData > TEMPERATURE_MAX)
? INT8_MAX
: ((evalData < TEMPERATURE_MIN) ? INT8_MIN : (int8_t)round(evalData / TEMPERATURE_LSB));
// FIXME: XADC range needs further refine
instPtr->hwSate.spFpgaVolt = (VOLT_PS_OK | VOLT_PSAUX_OK | VOLT_DDR_OK | VOLT_PL_OK | VOLT_PLAUX_OK | VOLT_BRAM_OK);
instPtr->hwSate.isSpOk = (instPtr->hwSate.spFpgaVolt == (VOLT_PS_OK | VOLT_PSAUX_OK | VOLT_DDR_OK | VOLT_PL_OK | VOLT_PLAUX_OK | VOLT_BRAM_OK))
&& (instPtr->hwSate.spClkState == (CLK_SP_PLL1_LOCK | CLK_SP_PLL2_LOCK))
&& (instPtr->hwSate.spAdLockState == (CLK_AD0_BBPLL_LOCK | CLK_AD0_RFPLL_LOCK | CLK_AD1_BBPLL_LOCK | CLK_AD1_RFPLL_LOCK));
&& (instPtr->hwSate.spClkState == (CLK_SP_PLL1_LOCK | CLK_SP_PLL2_LOCK));
#else
double evalData;
instPtr->hwSate.isSpOk = true;
@@ -1106,9 +1148,12 @@ void Phy_RefreshHwSate(PHY_INST *instPtr)
// -- Update FPGA Chip temperature, unit 1 deg
rawData = XAdcPs_GetAdcData(&(instPtr->hwXadc), XADCPS_CH_TEMP);
evalData = XAdcPs_RawToTemperature(rawData);
instPtr->hwSate.spFpgaTemp = (evalData > TEMPERATURE_MAX)
? INT8_MAX
: ((evalData < TEMPERATURE_MIN) ? INT8_MIN : (int8_t)round(evalData / TEMPERATURE_LSB));
// instPtr->hwSate.spFpgaTemp = (evalData > TEMPERATURE_MAX)
// ? INT8_MAX
// : ((evalData < TEMPERATURE_MIN) ? INT8_MIN : (int8_t)round(evalData / TEMPERATURE_LSB));
// FIXME: XADC readback is required
instPtr->hwSate.spFpgaTemp = ((instPtr->hwSate.spAdTemp_0 - 5) + (instPtr->hwSate.spAdTemp_1 - 7)) / 2;
instPtr->hwSate.spFpgaVolt = (VOLT_PS_OK | VOLT_PSAUX_OK | VOLT_DDR_OK | VOLT_PL_OK | VOLT_PLAUX_OK | VOLT_BRAM_OK);
instPtr->hwSate.isSpOk = (instPtr->hwSate.spFpgaVolt == (VOLT_PS_OK | VOLT_PSAUX_OK | VOLT_DDR_OK | VOLT_PL_OK | VOLT_PLAUX_OK | VOLT_BRAM_OK))
&& (instPtr->hwSate.spClkState == (CLK_SP_PLL1_LOCK | CLK_SP_PLL2_LOCK))
&& (instPtr->hwSate.spAdLockState == (CLK_AD0_BBPLL_LOCK | CLK_AD0_RFPLL_LOCK | CLK_AD1_BBPLL_LOCK | CLK_AD1_RFPLL_LOCK));
+2 -2
View File
@@ -24,14 +24,14 @@
#include "common.h"
#ifndef EMULATION
#include "xbram.h"
#include "../config/app_config.h"
#include "../../config/app_config.h"
#ifdef HSJL_GE // Zynq MPSoC (Zynq UltraScale+)
#include "xsysmon.h"
#else
#include "xadcps.h"
#endif
#endif
#include "../../system_monitor.h"
#include "../../systembus/systembus.h"
#include "../../time_ctrl/time_ctrl.h"
/************************** Constant Definitions *****************************/
/**
+9 -1
View File
@@ -207,7 +207,7 @@
/**
* Register: TM_TARGET_L
*/
#define TM_TARGET_L 0x00000064U
#define TM_TARGET_L 0x00000034U
#define TM_TARGET_L_SHIFT 0
#define TM_TARGET_L_WIDTH 32
#define TM_TARGET_L_MASK 0xFFFFFFFFU
@@ -260,6 +260,14 @@
#define ANT_SELECT_INDEX_WIDTH 32
#define ANT_SELECT_INDEX_MASK 0xFFFFFFFFU
/**
* Register: TX_MULFAC
*/
#define TX_MULFAC 0x00000048U
#define TX_MULFAC_SHIFT 0
#define TX_MULFAC_WIDTH 16
#define TX_MULFAC_MASK 0x0000FFFFU
/**
* Register: ANT_STATUS_1
*/
-408
View File
@@ -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*/
-249
View File
@@ -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_
/** @} */
+576 -294
View File
File diff suppressed because it is too large Load Diff
+256 -2
View File
@@ -23,9 +23,84 @@
#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)
#ifdef HSJL_GE
// Xilinx Recommended
#define IS_PS_VALID(x) (x <= 0.892 && x >= 0.808)
#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 <= 0.892 && x >= 0.808)
#define IS_PLAUX_VALID(x) (x <= 1.89 && x >= 1.71)
#define IS_BRAM_VALID(x) (x <= 0.892 && x >= 0.808)
#else
// 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)
#endif
#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 +114,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 __attribute__((packed))
{
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 +282,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 +310,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, uint8_t dstId);
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*/
+16 -61
View File
@@ -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);
+57 -6
View File
@@ -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