Squashed commit of the following:

commit 85d81374d12d0d3a2dda9fdebbb4538818424f67
Author: lch <1216608174@qq.com>
Date:   Wed Apr 15 14:14:59 2026 +0800

    报错修复

commit 0cffa7efcddd9d2682f12365887f583a95eac607
Author: lch <1216608174@qq.com>
Date:   Wed Apr 15 10:31:08 2026 +0800

    修复 : 维护工具带ms对时的时候ms没有进行处理的问题，修改秒脉冲修正逻辑判断;

commit 7440d076fe6de08805f7118b6e87f3e0eedd1563
Author: lch <1216608174@qq.com>
Date:   Wed Apr 15 10:16:07 2026 +0800

    修复 : 修复默认网关后全部网口的ip新建监听失败的问题;

commit 716f87395e6411be0c531feb17fad5086e0f9c7d
Author: lch <1216608174@qq.com>
Date:   Wed Apr 15 10:13:06 2026 +0800

    合并 : 录波修正处理，6000端口开启后即可进行录波修正;

commit 975b7b314432789119e189fcfa539fd850381bbb
Author: lch <1216608174@qq.com>
Date:   Tue Apr 14 17:37:20 2026 +0800

    增加 : 增加ppl_tbl.csv到备份打包列表中;

commit 32e6c624a1497aaa26a2959a467c75b2f45358e7
Author: lch <1216608174@qq.com>
Date:   Tue Apr 14 17:36:18 2026 +0800

    修复 : eth2，eth3 对应外部网口2和就地模块网口，接入模拟主站或者维护工具时打印界面会一直重复打印获取链接状态失败的提示;

commit 980a352bc5ffc11fc664b98be321eaef8212e9c7
Author: lch <1216608174@qq.com>
Date:   Tue Apr 14 17:09:19 2026 +0800

    增加 : 装置参数->规约参数->"104应答间隔"，"104响应文件确认"定值和相关逻辑处理;

commit fed9163018e7b2505b9e074811e3460a6a05afc6
Author: lch <1216608174@qq.com>
Date:   Tue Apr 14 16:43:08 2026 +0800

    增加 : 规约参数；

commit 7644446d19af1735292afbf1cf2074d7b91eb001
Author: lch <1216608174@qq.com>
Date:   Tue Apr 14 16:04:38 2026 +0800

    增加 : 零漂参数；

commit 8f225564730f44331b7adfabbef5d0f9ac804e4b
Author: lch <fantasylch@foxmail.com>
Date:   Fri Apr 10 14:35:58 2026 +0800

    Squashed commit of the following:

    commit dc6fd6d19d1488ab758c2981fa5469436caa8e15
    Author: lxb <915013849@qq.com>
    Date:   Thu Apr 2 17:52:34 2026 +0800

        1、增加：版本信息数据读取接口
        2、增加：首页设备信息页数据接口
        3、优化：首页UI支持自定义坐标

    commit 6161a10ba6bd7c6a43abd51edfbe119d35c7f215
    Author: lxb <915013849@qq.com>
    Date:   Mon Mar 30 17:03:32 2026 +0800

        1、优化：首页增加定时刷新机制

    commit 28b1605d59b49b8a84e00a3069cec6f746b3d333
    Author: lxb <915013849@qq.com>
    Date:   Mon Mar 30 14:47:02 2026 +0800

        1、增加：读取开关次数并更新到数组中

    commit 229178da5d38297816bbf9a6881ed04032c40967
    Merge: 5e9a1e9 3b69681
    Author: lxb <915013849@qq.com>
    Date:   Mon Mar 30 13:16:16 2026 +0800

        Merge commit '3b69681e737786e232571e31f96b0a83a468d5e1' into dev_with_ui

    commit 5e9a1e9f61227d65b669f5a5ab0f06885860ab48
    Author: lxb <915013849@qq.com>
    Date:   Fri Mar 27 18:04:45 2026 +0800

        1、优化：重构首页代码架构
        2、解决：解决实时数据相关bug

    commit e37c956379b2d72b06fd74e7564469c10f814b06
    Author: lxb <915013849@qq.com>
    Date:   Thu Mar 26 11:37:56 2026 +0800

        1、优化：字体库新增特殊符号，解决定值相关字体出现缺失问题

    commit 7179561601f5908efb6c9155785c8f003ccb8ac4
    Author: lxb <915013849@qq.com>
    Date:   Wed Mar 25 17:39:17 2026 +0800

        1、增加：实时数据模块，遥信遥测选项增加刷新数据现场

    commit a92a44814ba2db90167ae54984832c23bba5e3d5
    Author: lxb <915013849@qq.com>
    Date:   Tue Mar 24 16:30:05 2026 +0800

        1、优化：菜单页进入子菜单逻辑优化，使用数组映射

    commit f17b4f7a5d90449f973af6bd141547102391aa78
    Author: lxb <915013849@qq.com>
    Date:   Mon Mar 23 10:49:06 2026 +0800

        1、优化：重构版本信息页面，实现UI与原始数据分离

    commit b25ec034936ecbf7f983e57e7243811a3febbce9
    Author: lxb <915013849@qq.com>
    Date:   Fri Mar 20 11:20:48 2026 +0800

        1、增加：实现soe数据文件和遥控记录文件采集、实现文件检测、倒序显示，调整遥控信息显示
        2、优化：定值记录增加文件修改检测、倒序显示

    commit 49536e3469215dc179996b74c897d032054300cb
    Author: lxb <915013849@qq.com>
    Date:   Thu Mar 19 10:33:39 2026 +0800

        1.增加：上传UI图片资源以及日志相关示例文件

    commit 1a45c1dc9f3768b1e745e798fed89c806d7b0586
    Author: lxb <915013849@qq.com>
    Date:   Wed Mar 18 08:48:04 2026 +0800

        1.增加：完善定值记录读取接口，调整UI显示模板

    commit c72824914275e5194b5fd5d06ea9d62b97eb53e3
    Author: lxb <915013849@qq.com>
    Date:   Tue Mar 17 10:02:55 2026 +0800

        1.优化：重构菜单页，MVVM 架构改造

    commit e73727253c282104d7e59e36755f43c91af3a72b
    Author: lxb <915013849@qq.com>
    Date:   Mon Mar 16 15:27:13 2026 +0800

        1.增加：合入运行时间与板卡状态信息

    commit 873ac7cedf23387c1a270070931a4fdc7b6ceac6
    Merge: 1d25ccf 7e341eb
    Author: lxb <915013849@qq.com>
    Date:   Mon Mar 16 13:22:05 2026 +0800

        Merge commit '7e341eb3160d621f3da850cce4cab1fbfd6582ea' into dev_with_ui

    commit 1d25ccfcf8f5ad0d1275093cb1cf1bec18c3d3ac
    Author: lxb <915013849@qq.com>
    Date:   Fri Mar 13 20:34:39 2026 +0800

        1.优化：合并历史数据结构体，删除冗余代码

    commit a7e3bb52a801d4c07097e5c0dd920f94a319c0f0
    Author: lxb <915013849@qq.com>
    Date:   Fri Mar 13 15:22:51 2026 +0800

        1.优化：SOE、遥控、定值记录界面设置两条记录一页

    commit fd2d1c92e25db1850d5dae7a016ec73429b4cf40
    Author: lxb <915013849@qq.com>
    Date:   Thu Mar 12 15:33:54 2026 +0800

        1.增加：历史报告模块相关UI和按键逻辑

    commit 3588f552bd8ef276c8f6c0b6b134b0828f344b5b
    Author: lxb <915013849@qq.com>
    Date:   Wed Mar 11 08:48:57 2026 +0800

        解决：自定义bool类型，避免与底层的bool类型出现重定义问题

    commit fcf5b1e5a6fca3d9fa43b5df06805951ac23fff3
    Author: lxb <915013849@qq.com>
    Date:   Tue Mar 10 14:43:49 2026 +0800

        优化：密码修改增加提示确认框

    commit 5d63aebfb4d0437b10e79d21e7889c247062dea0
    Author: lxb <915013849@qq.com>
    Date:   Tue Mar 10 09:05:21 2026 +0800

        修改：解决编译错误问题，优化代码

    commit f81445a57a81fdf559afb448c23f870501ba20a7
    Author: lxb <915013849@qq.com>
    Date:   Mon Mar 9 18:12:34 2026 +0800

        1.增加：合入系统设置相关功能（参考Maintain.h功能）

    commit 1e8e73cc607e608fad802de84761ed2b1d3cfce3
    Author: lxb <915013849@qq.com>
    Date:   Mon Mar 9 09:09:55 2026 +0800

        1.优化：data_debugset简化代码，减少冗余重复

    commit e7a58d7ddad8d6bc4ce1f515966ab45548f6ee8c
    Author: lxb <915013849@qq.com>
    Date:   Fri Mar 6 16:38:45 2026 +0800

        1.优化：出厂调试数据层

    commit 3da8a730a29568a14be011dcfb99376348e01924
    Author: lxb <915013849@qq.com>
    Date:   Thu Mar 5 11:35:07 2026 +0800

        1.优化：增强确认对话框组件，支持动态标题和内容配置；
        2.优化：适配系数校准场景显示"系统设置-确定是否一键校准"提示。

    commit ebf5987813e81357ca40a789e777fbb37d597d2b
    Author: lxb <915013849@qq.com>
    Date:   Thu Mar 5 10:28:19 2026 +0800

        优化：时间输入框UI调整

    commit c5adb813e2a7fcc0d9a83c5898adbd72b6075744
    Author: lxb <915013849@qq.com>
    Date:   Wed Mar 4 18:09:41 2026 +0800

        1.优化：出厂调试--系统设置界面设置框实现，优化显示逻辑
        2.增加：实现系统时间设置组件框

    commit 0026dd6419e3511c6c7aa12ea2cfcc654a555ebb
    Author: lxb <915013849@qq.com>
    Date:   Wed Mar 4 11:17:59 2026 +0800

        1.增加：完成出厂调试界面相关代码和按键处理

    commit 9636090c8058db5512b770c68ef26c513d767376
    Author: lxb <915013849@qq.com>
    Date:   Tue Mar 3 13:37:51 2026 +0800

        1.优化：DO开出前四个开关增加遥控预置

    commit da9099039835c91f36927a3b286ed92926a49982
    Author: lxb <915013849@qq.com>
    Date:   Mon Mar 2 08:50:08 2026 +0800

        1.增加：DO控制相关接口
        2.优化：完善遥测数据零漂处理

    commit 6d980e236426293fb797a76aac0ea286f6006bbf
    Merge: 1121fee 6c02a77
    Author: lxb <915013849@qq.com>
    Date:   Fri Feb 27 08:59:03 2026 +0800

        Merge commit '6c02a7783edfe7ab658cca8733c7093e51f7d578' into dev_with_ui

    commit 1121feef0ef5a65244adb47e0539ea4734fadd69
    Author: lxb <915013849@qq.com>
    Date:   Fri Feb 27 08:53:19 2026 +0800

        1.增加：开出遥控界面实现弹出设置框

    commit 21c923ff9f4bd5187934daacd2dec8ee9c1a3090
    Author: lxb <915013849@qq.com>
    Date:   Thu Feb 26 16:08:40 2026 +0800

        1.优化：实时数据里开出控制增加密码校验功能才可进入

    commit 12debf4c6b64ac7b0e76144fa76bf3f84351b132
    Author: lxb <915013849@qq.com>
    Date:   Thu Feb 26 09:31:28 2026 +0800

        增加：遥测遥控数据获取更新

    commit e50ccbab26f72ea21fed971a2a02d01c65d320b8
    Author: lxb <915013849@qq.com>
    Date:   Mon Feb 9 11:19:54 2026 +0800

        1.优化：将图片资源从/opt 移到 /app目录下
        2.解决合并冲突

    commit 24884948b3cce4357f754eb78b279162aea6116e
    Merge: aa4e0f3 e61a117
    Author: lxb <915013849@qq.com>
    Date:   Mon Feb 9 10:37:19 2026 +0800

        Merge commit 'e61a117f08753ccee8c40b974262e9baf82a6532' into dev_with_ui

    commit aa4e0f3b8f0e2b2762526599366403430f17dda9
    Author: lxb <915013849@qq.com>
    Date:   Mon Feb 9 10:31:41 2026 +0800

        1.优化：UI图片资源读取从/opt 修改成  /app目录

    commit bc8e6d8733a4c85f1af7794e0a9d4122a401e41f
    Author: lxb <915013849@qq.com>
    Date:   Mon Feb 9 10:02:46 2026 +0800

        1.增加：data层增加实时数据相关文件和函数

    commit 9b48b61c1cfc8d943bd02006cf302c2fe98476e1
    Author: lxb <915013849@qq.com>
    Date:   Fri Feb 6 13:39:57 2026 +0800

        1.优化：增加软压板前四个选项为互斥选项
        2.优化：软压板“不停电传动”为只读，不可修改并设置

    commit 9e5c9c368c9e2d9cd143d1ce624864c2cff0e9d5
    Author: lxb <915013849@qq.com>
    Date:   Fri Feb 6 10:17:31 2026 +0800

        1、增加：只有投入才可查看相关设置，否则提示“软压板未投入”

    commit ad4cd55ce5f38ac6458206e228eae8b02760bb1a
    Author: lxb <915013849@qq.com>
    Date:   Thu Feb 5 15:32:09 2026 +0800

        1.优化：完成装置参数里IP地址设置后保存功能

    commit a75b94a3e17ea5b574dcf002d64b0270ed4679f0
    Author: lxb <915013849@qq.com>
    Date:   Thu Feb 5 09:27:46 2026 +0800

        1.增加：增加IP设置组件，可供弹出设置对应IP地址
        2.优化：装置参数完善弹出设置功能

    commit 2fffdb46bd4469aac3c14940695064edb3a6279b
    Author: lxb <915013849@qq.com>
    Date:   Tue Feb 3 18:20:23 2026 +0800

        1.增加：data_manager增加保存定值到菜单和系统

    commit 3c8d0c705e84678fed438aa0296b3cae27bddbcb
    Author: lxb <915013849@qq.com>
    Date:   Mon Feb 2 14:51:49 2026 +0800

        1.增加：实现保存参数确认框组件，完善UI和点击事件

    commit 860eb083dbb64f0a8bad920f6025b4d03545ccab
    Author: lxb <915013849@qq.com>
    Date:   Fri Jan 30 16:35:11 2026 +0800

        1.优化：重构ui_comp_set_vale_list，使用配置结构体方式创建UI

    commit 192cd87eebf34bdd95090b55a06483acd46f9dd3
    Author: lxb <915013849@qq.com>
    Date:   Thu Jan 29 14:48:35 2026 +0800

        1、增加：获取系统定值数据到UI菜单内

    commit 6ff41b64c42305274fefc13b30a8d2cbd8089731
    Author: lxb <915013849@qq.com>
    Date:   Wed Jan 28 10:26:56 2026 +0800

        1.优化：app_set_show点击事件逻辑优化

    commit 3b93d2e36a0237f4d6fde96b2bb1ccbdc8a8e49b
    Author: lxb <915013849@qq.com>
    Date:   Wed Jan 28 09:54:22 2026 +0800

        1.优化：增加data_usr，data_set改为data_sys，区分普通用户和管理员对应数据
        2.优化：解决数据获取错误问题
        3.优化：优化装置参数界面相关逻辑与UI

    commit 2e00e611e50dd458f09c4d028bcd80bf229a627a
    Author: lxb <915013849@qq.com>
    Date:   Tue Jan 27 09:35:54 2026 +0800

        1.增加：增加定值查看界面相关代码
        2.增加：定值整定界面不同密码展示不同数据
        3.增加：增加data_usr类，用户存储普通用户数据

    commit a0ac8fe32476c65dd0a5ccee1d247dd8225070bc
    Merge: 85716b2 632b8ce
    Author: lxb <915013849@qq.com>
    Date:   Fri Jan 23 17:12:41 2026 +0800

        Merge commit '632b8ceb2334943d65fbbad3c32d622cef76ca86' into dev_with_ui

    commit 85716b2f5f973cbdc87e20a4123c9fa6e305cee0
    Author: lxb <915013849@qq.com>
    Date:   Fri Jan 23 17:09:15 2026 +0800

        01.增加：增加data_set进行获取set.c数据
        02.增加：完成定值整定，定值查看界面UI数据展示

    commit 41f643f41b28e4bd4ab5026bd0689af014605da5
    Merge: b5d776a b2303b3
    Author: lxb <915013849@qq.com>
    Date:   Tue Jan 13 17:59:04 2026 +0800

        Merge commit 'b2303b337d9880f55c0a739f1e1a2e943a93ecb3' into dev_with_ui

    commit b5d776afead4685c3f4ad5f7254840aa963739e4
    Author: lxb <915013849@qq.com>
    Date:   Tue Jan 13 13:30:32 2026 +0800

        增加：切换分支合入UI模块，主程序Makefile合并编译UI模块静态库

commit 3b69681e737786e232571e31f96b0a83a468d5e1
Author: lch <1216608174@qq.com>
Date:   Wed Mar 25 10:33:00 2026 +0800

    增加 : 装置控制开关动作计数统计；

commit e6637ee55f6e1b78c677dd98c75ec68bdd21e902
Author: lch <1216608174@qq.com>
Date:   Mon Mar 23 17:03:16 2026 +0800

     修改 : 联络模式合到故障没有置位遥信的问题；

commit ac09738c811d6e598b09432746db1063d71de0da
Author: lch <1216608174@qq.com>
Date:   Fri Mar 20 14:19:05 2026 +0800

    修改 : 默认定值范围；

commit ae531d8cd7b7e9f94e240c4cb13df355e3f7c776
Author: lch <1216608174@qq.com>
Date:   Fri Mar 20 14:06:28 2026 +0800

    修改 : FA零压投退定值选项；

commit 95e8008db0df28f4cb9bf6a0aa60aa5827f9b47d
Author: lch <1216608174@qq.com>
Date:   Thu Mar 19 16:56:22 2026 +0800

    修改 : FA分段模式闭锁之后的各种解锁逻辑和解锁延时；

commit abb7684c64884b9f78b2957fb4cac64d17534539
Author: lch <1216608174@qq.com>
Date:   Wed Mar 18 14:57:38 2026 +0800

    增加 : FA分段模式过流不满足延时的Y闭锁逻辑；

commit 7e341eb3160d621f3da850cce4cab1fbfd6582ea
Author: lch <1216608174@qq.com>
Date:   Thu Mar 12 15:47:21 2026 +0800

    修改默认定值；

commit 69f1c712d66a203ec8abecd3a665c425534dcb1c
Author: lch <1216608174@qq.com>
Date:   Thu Mar 12 13:44:45 2026 +0800

    增加 : 程序运行时间统计；

commit 674c6aef7e591b5eb84a536e2e213399cc5abb1d
Author: lch <1216608174@qq.com>
Date:   Wed Mar 11 15:47:30 2026 +0800

    增加 : 读取gpio状态驱动；
    增加 : 读取板卡状态文件；

commit 05ed6dce050b227e249efb4ac275f1109e2a2c5c
Author: lch <1216608174@qq.com>
Date:   Tue Mar 10 14:31:36 2026 +0800

    修改 : 关联功能模式异常遥信点号；

commit 5ed1dfe1da3c88295b8a5d59d7618dae40ca9323
Author: lch <1216608174@qq.com>
Date:   Tue Mar 10 14:06:27 2026 +0800

    增加 : 线路断线告警功能逻辑；
    修改 : 调整soe位置，增加备用点号；

commit 38cc42372471de01b44b320c68157acf38999cde
Author: lch <1216608174@qq.com>
Date:   Thu Mar 5 13:46:41 2026 +0800

    修改 : 不停电传动逻辑；

commit 044a2f9141a3d0dbfd578d025c13519664f58105
Author: lch <1216608174@qq.com>
Date:   Mon Mar 2 15:41:19 2026 +0800

    修改 : 控制回路断线告警功能；

commit 0c9c6b59ee3529f2fd7d860a55a3419da6acc3f6
Author: lch <1216608174@qq.com>
Date:   Thu Feb 26 15:25:12 2026 +0800

    修改 : 同期功能异常问题；

commit 6c02a7783edfe7ab658cca8733c7093e51f7d578
Author: lch <1216608174@qq.com>
Date:   Wed Feb 25 15:31:07 2026 +0800

    增加 : 零序PT参数；

commit 568c32e5dc63da5914a6584ef68ec88f1ae75603
Author: lch <1216608174@qq.com>
Date:   Wed Feb 25 15:09:46 2026 +0800

    修改 : 保护合分闸遥控提示；

commit 16c328aeecee4b88df1d3ce845f0886d896a57d1
Author: lch <1216608174@qq.com>
Date:   Mon Feb 9 11:42:37 2026 +0800

    修改 : 设置线程名称；

commit e61a117f08753ccee8c40b974262e9baf82a6532
Author: lxb <915013849@qq.com>
Date:   Fri Feb 6 13:39:57 2026 +0800

    1.优化：增加软压板前四个选项为互斥选项
    2.优化：软压板“不停电传动”为只读，不可修改并设置

    (cherry picked from commit 9b48b61c1cfc8d943bd02006cf302c2fe98476e1)

commit b208f3e73ed9075f4717fe0e40a59c6335d1c097
Author: lxb <915013849@qq.com>
Date:   Fri Feb 6 10:17:31 2026 +0800

    1、增加：只有投入才可查看相关设置，否则提示“软压板未投入”

    (cherry picked from commit 9e5c9c368c9e2d9cd143d1ce624864c2cff0e9d5)

commit bae33f9358a9266031b073bcbdf0aa35857a3609
Author: lxb <915013849@qq.com>
Date:   Thu Feb 5 15:32:09 2026 +0800

    1.优化：完成装置参数里IP地址设置后保存功能

    (cherry picked from commit ad4cd55ce5f38ac6458206e228eae8b02760bb1a)

commit c3adc334195f1179e25bfcd12048cf3874db01dc
Author: lxb <915013849@qq.com>
Date:   Thu Feb 5 09:27:46 2026 +0800

    1.增加：增加IP设置组件，可供弹出设置对应IP地址
    2.优化：装置参数完善弹出设置功能

    (cherry picked from commit a75b94a3e17ea5b574dcf002d64b0270ed4679f0)

commit 09393729a27962915eb9dcc0d67b2b8b6faccb73
Author: lxb <915013849@qq.com>
Date:   Tue Feb 3 18:20:23 2026 +0800

    1.增加：data_manager增加保存定值到菜单和系统

    (cherry picked from commit 2fffdb46bd4469aac3c14940695064edb3a6279b)

commit 558bb4cf030c4f3aaf03024d4423fdd950ee182c
Author: lxb <915013849@qq.com>
Date:   Mon Feb 2 14:51:49 2026 +0800

    1.增加：实现保存参数确认框组件，完善UI和点击事件

    (cherry picked from commit 3c8d0c705e84678fed438aa0296b3cae27bddbcb)

commit b899ca068fddf37707953bee2abf3aa794dbf90c
Author: lxb <915013849@qq.com>
Date:   Fri Jan 30 16:35:11 2026 +0800

    1.优化：重构ui_comp_set_vale_list，使用配置结构体方式创建UI

    (cherry picked from commit 860eb083dbb64f0a8bad920f6025b4d03545ccab)

commit 10b9f41576d0fb9ad8e20f1e73a2433fbf276678
Author: lxb <915013849@qq.com>
Date:   Thu Jan 29 14:48:35 2026 +0800

    1、增加：获取系统定值数据到UI菜单内

    (cherry picked from commit 192cd87eebf34bdd95090b55a06483acd46f9dd3)

commit 389748f1a177f77fd0e2fb71a03df03bd1a642c7
Author: lxb <915013849@qq.com>
Date:   Wed Jan 28 10:26:56 2026 +0800

    1.优化：app_set_show点击事件逻辑优化

    (cherry picked from commit 6ff41b64c42305274fefc13b30a8d2cbd8089731)

commit 05fd1076b8978b429509bfffbadace9f2d8e8f30
Author: lxb <915013849@qq.com>
Date:   Wed Jan 28 09:54:22 2026 +0800

    1.优化：增加data_usr，data_set改为data_sys，区分普通用户和管理员对应数据
    2.优化：解决数据获取错误问题
    3.优化：优化装置参数界面相关逻辑与UI

    (cherry picked from commit 3b93d2e36a0237f4d6fde96b2bb1ccbdc8a8e49b)

commit d4bd36969f3149ec4037afed7efc9a985114a446
Author: lxb <915013849@qq.com>
Date:   Tue Jan 27 09:35:54 2026 +0800

    1.增加：增加定值查看界面相关代码
    2.增加：定值整定界面不同密码展示不同数据
    3.增加：增加data_usr类，用户存储普通用户数据

    (cherry picked from commit 2e00e611e50dd458f09c4d028bcd80bf229a627a)

commit eea794716b75b3bd671e0df7171590468c4bac4a
Author: lxb <915013849@qq.com>
Date:   Fri Jan 23 17:09:15 2026 +0800

    01.增加：增加data_set进行获取set.c数据
    02.增加：完成定值整定，定值查看界面UI数据展示

    (cherry picked from commit 85716b2f5f973cbdc87e20a4123c9fa6e305cee0)

commit 6004fe4dbc77678a5492fc8166e1f1bdb1a58361
Author: lxb <915013849@qq.com>
Date:   Tue Jan 13 13:30:32 2026 +0800

    增加：切换分支合入UI模块，主程序Makefile合并编译UI模块静态库

    (cherry picked from commit b5d776afead4685c3f4ad5f7254840aa963739e4)

commit b35d08047c1e8f2803a0452213aab27b7b4a494a
Author: lch <1216608174@qq.com>
Date:   Fri Feb 6 17:22:24 2026 +0800

    修改 : 合并遥信索引为双字节的代码；

commit 70316e51a0239362289f7bb94790c0eca4736382
Author: lch <1216608174@qq.com>
Date:   Tue Jan 27 10:59:04 2026 +0800

    修改 : 通信异常遥信点初始化置位，避免频繁刷新日志；

commit 3bfbd5788b1cc38c640e59f0e6bd20c68b362bc9
Author: lch <1216608174@qq.com>
Date:   Tue Jan 27 10:38:33 2026 +0800

    修改 : 线路断线判定方式显示错误问题；

commit 1360f40422aa5db198b91bc82079078f191a2175
Author: lch <1216608174@qq.com>
Date:   Tue Jan 27 10:35:47 2026 +0800

    修改 : 电池活化功能只有在管理机模式下才开放；

commit 632b8ceb2334943d65fbbad3c32d622cef76ca86
Author: lch <1216608174@qq.com>
Date:   Wed Jan 21 13:45:06 2026 +0800

    修改 : 合并可配置遥调功能；

commit c12fe7426983b63d74db9c983cfc4dbc408ad310
Author: lch <1216608174@qq.com>
Date:   Tue Jan 20 14:57:08 2026 +0800

    修改 : 解列功能，增加解列充电、放电；

commit dbeaa8fa22dd35c5b7298adf2aa84fd72707a975
Author: lch <1216608174@qq.com>
Date:   Thu Jan 15 14:44:29 2026 +0800

    修改 : 非电量数据溢出问题；

.gitignore

@@ -8,3 +8,5 @@ dtu/dtu_main_t536/compile_commands.json
 /dtu/dtu_main_t536/*.o
 /dtu/dtu_main_t536/dtu_t536
 .vscode
+build
+.claude

CLAUDE.md

@@ -0,0 +1,131 @@
+# CLAUDE.md
+
+本文档为 Claude Code (claude.ai/code) 提供本代码仓库的工作指导。
+
+## 项目概述
+
+本项目是面向配电自动化的 DTU（数据传输单元）嵌入式软件，目标平台为伏羲 T536（ARM Cortex-A55, aarch64）。使用 Xenomai 实时框架，UI 采用 LVGL。
+
+## 构建系统
+
+### 构建命令
+
+项目使用基于 Makefile 的自定义构建系统，配合 shell 脚本：
+
+```bash
+# 进入构建脚本目录
+cd dtu/dtu_main_t536/sh/t536
+
+# 构建广东 2020 标准版本（默认配置）
+./mybuild_for_gw_public_t536 NanWang GD_AREA_ECZD_2020 DCPU_FUXI DMACHINE_NULL
+
+# 标准 DTU 5.0 版本的替代构建脚本
+./mybuild_for_std_dtu5.0
+```
+
+构建参数：
+- `$1`：输出目录名称（例如："NanWang"）
+- `$2`：区域宏定义（例如：`GD_AREA_ECZD_2020`）
+- `$3`：CPU 类型（例如：`DCPU_FUXI`）
+- `$4`：机器类型（例如：`DMACHINE_NULL`）
+
+### 交叉编译
+
+- 编译器：`aarch64-none-linux-gnu-gcc`
+- 目标平台：ARM Cortex-A55
+- 输出文件：`dtu_t536` 可执行文件（作为内核模块链接）
+
+### 构建输出
+
+构建生成以下文件：
+- `dtu/dtu_main_t536/dtu_t536`：主可执行文件
+- `dtu/dtu_main_t536/ko/<app_dir>/`：包含 CRC 校验二进制文件的输出目录
+
+## 项目结构
+
+### 主要目录
+
+- `dtu/dtu_main_t536/app/`：主应用程序源代码
+  - 核心模块：保护逻辑、通信协议、UI 等
+  - `main.c`：应用程序入口点
+  - `head.h`：包含所有模块头文件的主头文件
+- `app_public/`：共享/公共代码库
+  - `fuxi_public/`：平台抽象层
+    - `rt_lite/`：实时操作系统抽象
+    - `fuxi_bsp/`：板级支持包（ADC、GPIO、UART 等）
+    - `bsp_share/`：共享 BSP 工具函数
+  - `gps/`：GPS 模块
+  - `sys_api/`：系统 API
+  - `bluetooth/`：蓝牙支持
+  - `wavelib/`：波形记录库
+  - `xdljd/`：小电流接地逻辑
+- `xenomai/`：Xenomai 实时框架头文件和库
+- `build/`：CMake 构建目录（用于生成 compile_commands.json）
+
+### 关键架构组件
+
+1. **实时层**：基于 Xenomai，通过 `rt_lite` 抽象提供实时套接字、文件、FIFO
+2. **BSP 层**：硬件抽象，包括 ADC (AD7616)、GPIO、UART、CAN、I2C、RTC
+3. **协议栈**：IEC101、IEC104、Modbus、IEC61850/GOOSE
+4. **保护逻辑**：开关保护、重合闸、FA（馈线自动化）
+5. **UI 层**：基于 LVGL 的本地显示界面
+
+### 配置系统
+
+配置定义在 `dtu/dtu_main_t536/app/defineSys.h`：
+- 区域特定宏（例如：广东 2020 标准使用 `GD_AREA_ECZD_2020`）
+- 保护功能、通信协议的特性开关
+- 硬件特定配置
+
+关键配置宏：
+- `CPU_FUXI`：目标 CPU 类型
+- `GD_AREA_*`：区域/客户特定需求
+- `SWITCH_NUM_MAX`：最大支持开关数
+- `CFG_LINK_104_NUM`：IEC104 链路数量
+- `CFG_LINK_101_NUM`：IEC101 链路数量
+
+## 开发指南
+
+### 文件组织
+
+- 应用程序逻辑：`dtu/dtu_main_t536/app/*.c`
+- UI 代码：`dtu/dtu_main_t536/app/ui/`
+- BSP 代码：`app_public/fuxi_public/fuxi_bsp/source/`
+- 公共头文件：`app_public/fuxi_public/fuxi_bsp/include/`
+
+### 常见任务
+
+**添加新源文件：**
+1. 将 `.c` 文件添加到相应目录
+2. 更新 `dtu/dtu_main_t536/sh/t536/Makefile` 中的 OBJS 列表
+3. 如需要，添加对应的头文件
+
+**修改构建配置：**
+- 编辑 `dtu/dtu_main_t536/app/defineSys.h` 设置特性开关
+- 编辑 `dtu/dtu_main_t536/sh/t536/` 中的构建脚本设置编译选项
+
+**构建调试：**
+```bash
+# 启用详细构建输出
+make v=1
+
+# 生成 compile_commands.json 用于 IDE 支持
+# （使用 bear：bear -- make -j6）
+```
+
+### 重要文件路径
+
+- 主入口：`dtu/dtu_main_t536/app/main.c`
+- 应用配置：`dtu/dtu_main_t536/app/Appconfig.c`
+- 系统定义：`dtu/dtu_main_t536/app/defineSys.h`
+- BSP 配置：`app_public/fuxi_public/fuxi_bsp/include/bspconfig.h`
+- 构建脚本：`dtu/dtu_main_t536/sh/t536/mybuild_for_gw_public_t536`
+- Makefile：`dtu/dtu_main_t536/sh/t536/Makefile`
+
+### 硬件环境
+
+- 平台：伏羲 T536（ARM Cortex-A55）
+- ADC：AD7616（16 通道）
+- IO 扩展：CH423S
+- 温湿度传感器：AHT20
+- 实时操作系统：Xenomai（Cobalt 内核）

README.md

@@ -89,4 +89,59 @@
 13. 修改 : 遥测配置了故障电流之后一直突发的问题；
 14. 修改 : 自动复归复归遥测上送的故障电流；
 15. 修改 : 一些默认点表的额定值为1，避免配置转发的时候导致极值文件因系数错误无法初始化；
-16. 增加 : 录波开入防抖投退；
+16. 增加 : 录波开入防抖投退；
+17. 修改 : 非电量数据溢出问题；
+
+# 202601(19-25)
+01. 修改 : 解列功能，增加解列充电、放电；
+02. 修改 : 合并可配置遥调功能；
+
+# 202601(26-31)
+01. 修改 : 电池活化功能只有在管理机模式下才开放；
+02. 修改 : 线路断线判定方式显示错误问题；
+03. 修改 : 通信异常遥信点初始化置位，避免频繁刷新日志；
+
+# 202602(02-08)
+01. 修改 : 合并遥信索引为双字节的代码；
+
+# 202602(09-10)
+01. 修改 : 设置线程名称；
+
+# 202602(24-28)
+01. 修改 : 保护合分闸遥控提示；
+02. 增加 : 零序PT参数；
+03. 修改 : 同期功能异常问题；
+
+# 202603(02-08)
+01. 修改 : 控制回路断线告警功能；
+02. 增加 : 遥信点号，修改位置；
+03. 修改 : 遥控点号位置；
+04. 修改 : 不停电传动逻辑；
+
+# 202603(09-15)
+01. 增加 : 线路断线告警功能逻辑；
+02. 修改 : 调整soe位置，增加备用点号；
+03. 修改 : 关联功能模式异常遥信点号；
+04. 增加 : 读取gpio状态驱动；
+05. 增加 : 读取板卡状态文件；
+06. 增加 : 程序运行时间统计；
+
+# 202603(16-22)
+01. 增加 : FA分段模式过流不满足延时的Y闭锁逻辑；
+02. 修改 : FA分段模式闭锁之后的各种解锁逻辑和解锁延时；
+03. 修改 : FA零压投退定值选项；
+04. 修改 : 默认定值范围；
+
+# 202603(23-29)
+01. 修改 : 联络模式合到故障没满足延时没有闭锁和置位遥信的问题；
+02. 增加 : 装置控制开关动作计数统计；
+
+# 202604(13-19)
+01. 增加 : 零漂参数；
+02. 增加 : 规约参数；
+03. 增加 : 装置参数->规约参数->"104应答间隔"，"104响应文件确认"定值和相关逻辑处理;
+04. 修复 : eth2，eth3 对应外部网口2和就地模块网口，接入模拟主站或者维护工具时打印界面会一直重复打印获取链接状态失败的提示;
+05. 增加 : 增加ppl_tbl.csv到备份打包列表中;
+06. 合并 : 录波修正处理，6000端口开启后即可进行录波修正;
+07. 修复 : 修复默认网关后全部网口的ip新建监听失败的问题;
+08. 修复 : 维护工具带ms对时的时候ms没有进行处理的问题，修改秒脉冲修正逻辑判断;

app_public/fuxi_public/fuxi_bsp/include/bsp_boardcheck.h

@@ -0,0 +1,79 @@
+/**
+ * @file           bsp_boardcheck.h
+ * @brief          
+ * @author         plyang
+ * @version        1.0
+ * @date           20230427
+ * 
+ * @copyright Copyright (c) 2026 by OLE, All Rights Reserved.
+ * 
+ * @par ????:
+ * <table>
+ * <tr><th>Date        <th>Version         <th>Author          <th>Description
+ * <tr><td>20230427    <td>2.0             <td>test            <td>??
+ * </table>
+ */
+
+#ifndef __BSP_BOARDCHECK_H
+#define __BSP_BOARDCHECK_H
+
+/**
+ * @brief
+ *
+ */
+typedef struct
+{
+    uint8_t board_state; // ????
+    uint8_t board_up;    // ??????
+    uint8_t board_down;  // ????????
+    uint32_t time;       // ????
+    uint32_t setTime;    // ????
+
+} t_bsp_boardcheck;
+
+/**
+ * @defgroup board_check  BOARD CHECK
+ * ????
+ * @{
+ */
+
+typedef enum
+{
+    BOARD_DI = 0, /**<???*/
+    BOARD_AC,     /**<???*/
+    BOARD_DO,     /**<???*/
+    // BOARD_KEY,    /**<???*/
+    BOAED_NUM
+} te_board_check;
+
+/**
+ * @brief ??????
+ *
+ * @return int
+ * @remark ?????? (50-200ms)
+ */
+extern int bsp_board_check(void);
+
+/**
+ * @brief ????????
+ *
+ * @param n ???? [0-3][BOARD_DI~BOARD_DO]
+ * @return int ?????1 ?????0
+ */
+extern int bap_get_board_state(uint8_t n);
+
+extern int bapbcio_get_board_state(uint8_t n);
+
+/**
+ * @brief ???????
+ *
+ * @return int ????
+ */
+extern int bsp_board_init(void);
+
+#endif
+
+/**
+ * @}
+ *
+ */

app_public/fuxi_public/fuxi_bsp/include/bspconfig.h

@@ -37,7 +37,7 @@
 #define EQU_DB_YX_NUM			32	// 数据总线长度
 
 //----------------------------- 线路开关  ---------------------------
-#define SWITCH_NUM_MAX			1  // 6  // 开关数量，本装置实际支持的开关数，不包含级联部分。
+#define SWITCH_NUM_MAX			1  // 开关数量，本装置实际支持的开关数，不包含级联部分。
 #define SWITCH_NUM_EXT			31 // 扩展开关数量，后面部分供级联用。
 #define SWITCH_NUM_EXT_PUB		32 // 扩展开关数量加公共部分，后面部分供级联用。此值不能超过32
 

app_public/fuxi_public/fuxi_bsp/include/debug_print.h

@@ -35,17 +35,17 @@
 #define dp_info_h_s(fmt, args...) \
     printf(DP_COLOR_WATHET "[INFO] " DP_COLOR_NONE fmt "\r\n", ##args)
 #define dp_info_h_c(fmt, args...) \
-    printf(DP_COLOR_WATHET "[INFO][%30s : %5d] " DP_COLOR_NONE fmt "\r\n", __func__, __LINE__, ##args)
+    printf(DP_COLOR_WATHET "[INFO][%24s : %5d] " DP_COLOR_NONE fmt "\r\n", __func__, __LINE__, ##args)
 
 #define dp_info_n_s(fmt, args...) \
     printf(DP_COLOR_WATHET "[INFO] " DP_COLOR_NONE DP_COLOR_BLUE fmt DP_COLOR_NONE "\r\n", ##args)
 #define dp_info_n_c(fmt, args...) \
-    printf(DP_COLOR_WATHET "[INFO][%30s : %5d] " DP_COLOR_NONE DP_COLOR_BLUE fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
+    printf(DP_COLOR_WATHET "[INFO][%24s : %5d] " DP_COLOR_NONE DP_COLOR_BLUE fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
 
 #define dp_info_a_s(fmt, args...) \
     printf(DP_COLOR_WATHET "[INFO] " fmt DP_COLOR_NONE "\r\n", ##args)
 #define dp_info_a_c(fmt, args...) \
-    printf(DP_COLOR_WATHET "[INFO][%30s : %5d] " fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
+    printf(DP_COLOR_WATHET "[INFO][%24s : %5d] " fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
 
 /* 错误提示 nt整行不带[tag] h只有[tag]显示红色 n[tag]显示为红色内容为蓝色 a[tag]整行为红色 */
 #define dp_err_nt(fmt, args...) \
@@ -54,17 +54,17 @@
 #define dp_err_h_s(fmt, args...) \
     printf(DP_COLOR_RED "[ERR] " DP_COLOR_NONE fmt "\r\n", ##args)
 #define dp_err_h_c(fmt, args...) \
-    printf(DP_COLOR_RED "[ERR][%30s : %5d] " DP_COLOR_NONE fmt "\r\n", __func__, __LINE__, ##args)
+    printf(DP_COLOR_RED "[ERR][%25s : %5d] " DP_COLOR_NONE fmt "\r\n", __func__, __LINE__, ##args)
     
 #define dp_err_n_s(fmt, args...) \
     printf(DP_COLOR_RED "[ERR] " DP_COLOR_NONE DP_COLOR_BLUE fmt DP_COLOR_NONE "\r\n", ##args)
 #define dp_err_n_c(fmt, args...) \
-    printf(DP_COLOR_RED "[ERR][%30s : %5d] " DP_COLOR_NONE DP_COLOR_BLUE fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
+    printf(DP_COLOR_RED "[ERR][%25s : %5d] " DP_COLOR_NONE DP_COLOR_BLUE fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
     
 #define dp_err_a_s(fmt, args...) \
     printf(DP_COLOR_RED "[ERR] " fmt DP_COLOR_NONE "\r\n", ##args)
 #define dp_err_a_c(fmt, args...) \
-    printf(DP_COLOR_RED "[ERR][%30s : %5d] " fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
+    printf(DP_COLOR_RED "[ERR][%25s : %5d] " fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
 
 
 #define dp_info_nt_rt(fmt, args...) \
@@ -74,7 +74,7 @@
 #define dp_err_n_s_rt(fmt, args...) \
     rt_printf(DP_COLOR_RED "[ERR] " DP_COLOR_NONE DP_COLOR_BLUE fmt DP_COLOR_NONE "\r\n", ##args)
 #define dp_err_n_c_rt(fmt, args...) \
-    rt_printf(DP_COLOR_RED "[ERR][%30s : %5d] " DP_COLOR_NONE DP_COLOR_BLUE fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
+    rt_printf(DP_COLOR_RED "[ERR][%25s : %5d] " DP_COLOR_NONE DP_COLOR_BLUE fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
 
     
 #define dp_info_nt_pk(fmt, args...) \
@@ -82,7 +82,7 @@
 #define dp_err_n_s_pk(fmt, args...) \
     printk(DP_COLOR_RED "[ERR] " DP_COLOR_NONE DP_COLOR_BLUE fmt DP_COLOR_NONE "\r\n", ##args)
 #define dp_err_n_c_pk(fmt, args...) \
-    printk(DP_COLOR_RED "[ERR][%30s : %5d] " DP_COLOR_NONE DP_COLOR_BLUE fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
+    printk(DP_COLOR_RED "[ERR][%25s : %5d] " DP_COLOR_NONE DP_COLOR_BLUE fmt DP_COLOR_NONE "\r\n", __func__, __LINE__, ##args)
 
 /***** 头文件 *****/
 

app_public/fuxi_public/fuxi_bsp/include/equ.h

@@ -133,6 +133,7 @@ struct equ_config
 
 struct equ_config_di
 {
+#if !defined IECTABLE_NEWTOOL_OLE
     u8 slot;                   // 板卡槽位地址
     u8 index;                  // DI硬件地址,从0开始
     u8 type;                   // DI类型
@@ -141,6 +142,16 @@ struct equ_config_di
     u8 is_Inverse;             // 是否取反
     s8 name[EQU_CFG_NAME_LEN]; // DI名称
     u8 reserved[3];
+#else
+    u8 slot;                   // 板卡槽位地址
+    u8 index;                  // DI硬件地址,从0开始
+    u16 type;                  // DI类型 工具开入量配置解析用的是和遥信一样的资源表 20230213
+    u32 filter_time;           // DI防抖滤波时间 类型加了1个字节导致这4个字节对不齐了，和归属调换一下位置 20230213
+    u8 owner;                  // 归属：开关1~开关12、公共
+    u8 is_Inverse;             // 是否取反
+    s8 name[EQU_CFG_NAME_LEN]; // DI名称
+    u8 reserved[2];
+#endif
 };
 
 struct equ_config_do

app_public/fuxi_public/fuxi_bsp/include/freq.h

@@ -21,7 +21,7 @@
  */
 int freq_init(void);
 int freq_exit(void);
-
+int freq_get_shm_data(void);
 float freq_get(unsigned int index);
 
 int freq_stat_reset(void);

app_public/fuxi_public/fuxi_bsp/include/gpio.h

@@ -33,9 +33,10 @@ enum
 // sunxi 20220413 added
 enum
 {
-    // KOUT_EN0,
-    // KOUT_EN1, //辅助板上的单片机控
-    GPIO_NUM_OTHER,
+    GPIO_INT_M1 = DO_NUM,
+    GPIO_INT_M3,
+    GPIO_INT_M4,
+    GPIO_NUM_TOTAL,
 };
 
 /*------------------------------ 外部函数 -------------------------------------
@@ -59,6 +60,8 @@ unsigned short gpio_di_fj(void);
 #endif
 int gpio_kout_do(int on, unsigned int kout);
 
+extern int gpioio_get_gpio_status(uint8_t _uc_idx);
+
 #endif
 /*------------------------------ 文件结束 -------------------------------------
  */

app_public/fuxi_public/fuxi_bsp/include/my_rtc.h

@@ -79,4 +79,6 @@ int timespec_to_rtc(struct timespec ts, struct rtc_time_t *p_rtc, int is_round);
 
 int rtc_test(void);
 
+void check_rtc_write(void);
+
 #endif // _MY_RTC_H

app_public/fuxi_public/fuxi_bsp/source/ad7616.c

@@ -55,8 +55,9 @@ struct timespec ts_adc_dots[CFG_ADC_DOTS_PER_CHANNEL]; // 时
 // 128点录波，32点计算
 // 注意此buf由于是DMA类型，不能在实时中断中使用，只能在线程中使用。
 // s16 g_adc_dots_rec[CFG_ADC_DOTS_PER_CHANNEL*4][CFG_ADC_CHANNEL];
-s16 (*g_adc_dots_rec)[CFG_ADC_CHANNEL];
-u32 g_adc_dots_rec_dma;
+
+s16 (*g_adc_dots_rec)[CFG_ADC_CHANNEL]; // 录波使用
+u32 g_adc_dots_rec_dma;                 // 计算使用
 
 // 直流量测量采样点BUF
 u16 g_adc_dots_dc[CFG_ADC_CHANNEL_DC][CFG_ADC_DOTS_PER_CHANNEL];
@@ -442,8 +443,6 @@ int adc_isr(int mod)
         if (!recv_init)
         {
             recv_init = 1;
-            // 开机时裸核还没有把遥信送上下，这里重新初始化plc_init
-            //  plc_init();		TODO EWen
         }
 
         // 标准化DTU遥信已经经过开入子板处理防抖

app_public/fuxi_public/fuxi_bsp/source/bsp.c

@@ -27,7 +27,7 @@ struct init_t g_bsp_init_func[] =
         {bsp_ustimer_init, ERR_CODE_INIT_SOFTWARE}, // 初始化内核USTIMER
         {ustimer_init, ERR_CODE_INIT_SOFTWARE},     // 初始化USTIMER
         {gps_init, ERR_CODE_INIT_SOFTWARE},         // 初始化GPS
-#if (0)                                             /* TODO 没有挂载设备 暂时屏蔽 */
+#if (0) /* TODO 没有挂载设备 暂时屏蔽 */
         {pps_init, ERR_CODE_INIT_SOFTWARE},         // 初始化PPS
 #endif
         // {shm_init,ERR_CODE_INIT_SOFTWARE},	//初始化shm

app_public/fuxi_public/fuxi_bsp/source/bsp_boardcheck.c

@@ -0,0 +1,176 @@
+/**
+ * @file           bsp_boardcheck.h
+ * @brief          
+ * @author         plyang
+ * @version        1.0
+ * @date           20230427
+ * 
+ * @copyright Copyright (c) 2026 by OLE, All Rights Reserved.
+ * 
+ * @par 修改日志:
+ * <table>
+ * <tr><th>Date        <th>Version         <th>Author          <th>Description
+ * <tr><td>20230427    <td>2.0             <td>test            <td>内容
+ * </table>
+ */
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "bsp_boardcheck.h"
+#include "gpio.h"
+#include "debug_print.h"
+
+#define BOARD_MAX           BOAED_NUM
+#define BOARD_CHECK_TIME    100 //(单位ms)
+
+static t_bsp_boardcheck m_board[BOARD_MAX];
+static char *board_name[BOARD_MAX] = {"DI ", "AC ", "DO "};
+
+static int bsp_read_board(uint8_t n)
+{
+    uint8_t ret = 0xff;
+
+    switch (n)
+    {
+    case BOARD_DI:
+        ret = gpioio_get_gpio_status(GPIO_INT_M1); /*M1-DI*/
+        break;
+
+    case BOARD_AC:
+        ret = gpioio_get_gpio_status(GPIO_INT_M3); /*M3-ADC*/
+        break;
+
+    case BOARD_DO:
+        ret = gpioio_get_gpio_status(GPIO_INT_M4); /*M4 DO*/
+        break;
+
+    default:
+        ret = 0xff;
+        break;
+    }
+    if (ret < 0)
+    {
+        return 0;
+    }
+    return (int)ret;
+}
+
+static int board_hot_swap_handl(int n)
+{
+    if (m_board[n].board_down && m_board[n].board_up)
+    {
+        m_board[n].time += BOARD_CHECK_TIME;
+        m_board[n].setTime = 2000;
+        if (m_board[n].time > m_board[n].setTime)
+        {
+            m_board[n].board_state = 1;
+            switch (n)
+            {
+            case BOARD_DI:
+                /* DI */
+                break;
+
+            case BOARD_AC:
+                /*  key*/
+                break;
+
+            case BOARD_DO:
+                /*AC  code */
+                break;
+
+            default:
+                break;
+            }
+
+            m_board[n].board_down = 0;
+            m_board[n].time = 0;
+            dp_info_n_c("%s 板卡%d 插入", board_name[n], (n + 1));
+        }
+    }
+    else
+    {
+        m_board[n].time = 0;
+    }
+    return 0;
+}
+
+int bsp_board_check(void)
+{
+    uint8_t i = 0;
+    static uint8_t oldstate[BOARD_MAX] = {0};
+    static uint8_t state[BOARD_MAX] = {0};
+    static uint8_t sflg = 1;
+
+    if (sflg)
+    {
+        sflg = 0;
+        for (i = 0; i < BOARD_MAX; i++)
+        {
+            oldstate[i] = bsp_read_board(i) == 0 ? 1 : 0;
+            state[i] = oldstate[i];
+            m_board[i].board_state = oldstate[i];
+            if (oldstate[i])
+            {
+                m_board[i].board_up = 1;
+                m_board[i].board_down = 0;
+                dp_info_n_c("%s 板卡%d 插入", board_name[i], i + 1);
+            }
+            else
+            {
+                m_board[i].board_down = 1;
+                m_board[i].board_up = 0;
+                dp_info_n_c("%s 板卡%d 拨出", board_name[i], i + 1);
+            }
+        }
+    }
+    else
+    {
+        for (i = 0; i < BOARD_MAX; i++)
+        {
+            state[i] = bsp_read_board(i) == 0 ? 1 : 0;
+            if (state[i] == 1 && oldstate[i] == 0)
+            {
+                oldstate[i] = state[i];
+                m_board[i].board_up = 1;
+                m_board[i].board_state = 1;
+            }
+            else if (state[i] == 0 && oldstate[i] == 1)
+            {
+                oldstate[i] = state[i];
+                m_board[i].board_down = 1;
+                m_board[i].board_up = 0;
+                m_board[i].board_state = 0;
+                dp_info_n_c("%s 板卡%d 拨出", board_name[i], i + 1);
+            }
+
+            board_hot_swap_handl(i);
+        }
+    }
+
+    return 0;
+}
+
+int bap_get_board_state(uint8_t n)
+{
+    uint8_t var = 0;
+
+    if (n > BOARD_MAX)
+    {
+        return -1;
+    }
+
+    var = bsp_read_board(n) == 0 ? 1 : 0;
+
+    return (m_board[n].board_state & var);
+}
+
+int bapbcio_get_board_state(uint8_t n)
+{
+    return (m_board[n].board_state);
+}
+
+int bsp_board_init(void)
+{
+    bsp_board_check();
+}

app_public/fuxi_public/fuxi_bsp/source/dido.c

@@ -477,7 +477,7 @@ void dido_do_poll(void)
     // ¿ª³ö·µ»Ø
     io_do_return();
 
-#if !defined CPU_FUXI
+#if !defined CPU_FUXI // TODO
     // ¿ª³ö·µÐ£
     if (g_board_info[EQU_SLOT_KZ].do_num != 0)
     {
@@ -823,8 +823,8 @@ int get_shm_didata(void)
                     g_di[g_di_slot].ts_t[i][g_di[g_di_slot].ts_i[i].n] = dt;
                     g_di[g_di_slot].ts_v[i][g_di[g_di_slot].ts_i[i].n] = b_on;
                     g_di[g_di_slot].ts_i[i].n++;
-                    smt_di_bk[i].uc_state = smt_di[i].uc_state;
                 }
+                smt_di_bk[i].uc_state = smt_di[i].uc_state;
                 // dp_err_n_c_rt("change smt_di[%02d].uc_state = %d", i, b_on);
                 // dp_err_n_c_rt("dt = %d", dt);
             }

app_public/fuxi_public/fuxi_bsp/source/equ_fuxi.c

@@ -190,6 +190,9 @@ int equ_init_di(void)
             }
         }
     }
+#else
+    g_ui_freq[0] = PUB_AC_UA1;
+    g_ui_freq[1] = PUB_AC_UA2;
 #endif
 
     // ³õʼ»¯¿ªÈëg_di_st½á¹¹

app_public/fuxi_public/fuxi_bsp/source/flexcan.c

@@ -915,8 +915,6 @@ int can_stat_reset(void)
 */
 static int _can_set_reset_mode(struct can_dev *dev)
 {
-    // TODO: ocean
-
     return 1;
 }
 
@@ -934,8 +932,6 @@ static int _can_set_reset_mode(struct can_dev *dev)
 */
 static int _can_set_normal_mode(struct can_dev *dev)
 {
-    // TODO: ocean
-
     return 1;
 }
 

app_public/fuxi_public/fuxi_bsp/source/freq.c

@@ -91,6 +91,46 @@ static int get_shm_f(uint8_t *out_data)
     return ret;
 }
 
+int freq_get_shm_data(void)
+{
+    float freq = 50.0;
+    struct t_shmdata_freq shm_f;
+    int ret = 0;
+
+#ifdef DTIM_FREQ_DEBUG
+    static int start_stat_flag = 0;
+    if (start_stat_flag == 0)
+    {
+        start_stat_flag++;
+        freq_stat_reset();
+    }
+#endif
+
+    // 从共享内存中读取频率到freq
+    // ret = get_shm_f((uint8_t *)&shm_f);
+    ret = shm_packet_read_v2(SHM_ADDR_W_FREQ, sizeof(shm_f), (uint8_t *)&shm_f, sizeof(shm_f));
+
+    if (ret > 0)
+    {
+        for (uint8_t i = 0; i < CFG_FREQ_NUM; i++)
+        {
+            freq = (float)shm_f.us_freq[i] * 0.001f;
+
+#ifdef DTIM_FREQ_DEBUG
+            rt_stat_in(&g_stat_freq[i], rt_round(freq * Q16_BASE));
+#endif
+
+            // 将频率范围限定在45hz到55hz。
+            if (freq >= 44.0 && freq <= 56.0)
+            {
+                g_freqency[i] = freq;
+            }
+        }
+    }
+
+    return ret;
+}
+
 /******************************************************************************
 函数名称：	freq_get
 函数版本：	01.01
@@ -103,6 +143,7 @@ static int get_shm_f(uint8_t *out_data)
 */
 float freq_get(unsigned int index)
 {
+#if !defined CPU_FUXI
     u32 e;
     float freq = 50.0;
     struct t_shmdata_freq shm_f;
@@ -135,6 +176,10 @@ float freq_get(unsigned int index)
     e = _Mul_Div_U(sqrt_32fix(g_ui[g_ui_freq[index]].m2[0]), 256, g_ui[g_ui_freq[index]].m2_factor_k);
     if (e < Q16_BASE * 5)
     {
+        if (g_run_stu.yf)
+        {
+            dp_info_nt_rt("index = %d", index);
+        }
         return 0.0;
     }
 
@@ -143,6 +188,10 @@ float freq_get(unsigned int index)
 
     // 从共享内存中读取频率到freq
     ret = get_shm_f((uint8_t *)&shm_f);
+    if (g_run_stu.yf)
+    {
+        dp_info_nt_rt("ret = %d", ret);
+    }
     // printf("ret=%d, us_updata=%u, us_op=%u, us_op_bk=%u, freq0=%u, freq0=%u, crc=%u\n\n",
     // 	ret, shm_f.us_updata, shm_f.us_op, shm_f.us_op_bk, shm_f.us_freq[0], shm_f.us_freq[1], shm_f.us_crc);
 
@@ -164,6 +213,29 @@ float freq_get(unsigned int index)
     //<=================
 
     return g_freqency[index];
+#else
+    u32 e;
+
+    if (index >= CFG_FREQ_NUM)
+    {
+        return 0.0;
+    }
+
+    if (g_ui_freq[index] == UI_NUM)
+    {
+        return 0.0;
+    }
+
+    // 20160825:测试发现只要能够测到频率，就基本是准的，所以将门槛降低到5v，满足电子互感器
+    // 额定值57.735v的要求。
+    e = _Mul_Div_U(sqrt_32fix(g_ui[g_ui_freq[index]].m2[0]), 256, g_ui[g_ui_freq[index]].m2_factor_k);
+    if (e < Q16_BASE * 5)
+    {
+        return 0.0;
+    }
+
+    return g_freqency[index];
+#endif
 }
 
 int freq_stat_reset(void)

app_public/fuxi_public/fuxi_bsp/source/gpio.c

@@ -20,6 +20,10 @@ B_DO_6		--> GPIOD_07	-->  gpio103
 B_DO_7		--> GPIOD_08	-->  gpio104
 B_DO_8		--> GPIOD_06	-->  gpio102
 
+M1 开入	    --> GPIOI_11	-->  gpio267
+M3 采样     --> GPIOI_10	-->  gpio266
+M4 开出     --> GPIOA_02	-->  gpio2
+
 T536 start ↓↓↓↓↓↓
 RUN_LED			-->  PB7  	-->  gpio39
 ERR_LED			-->  PF4	-->  gpio164
@@ -45,6 +49,11 @@ T536 end
 
 #define GPIO_LOW 0
 
+#define GPIO_INPUT  0
+#define GPIO_OUTPUT 1
+
+#define NEW_GOIO_VERSION    1
+
 /*------------------------------ 全局变量 -------------------------------------
  */
 typedef enum
@@ -60,6 +69,7 @@ extern uint32_t g_yx_buf[2]; // 预
  */
 extern unsigned int change_di_ch(unsigned int di);
 
+#if (0 == NEW_GOIO_VERSION)
 int gpio_val_fd[DO_NUM];
 int gpio_dev_type[DO_NUM] = {
     SYS_GPIO,
@@ -68,6 +78,34 @@ int gpio_dev_type[DO_NUM] = {
 /* 开出gpio */
 const int gpio_val[DO_NUM] = {115, 98, 105, 114, 112, 103, 104, 102, 99, 113};
 
+#else
+
+struct t_goio_cfg
+{
+    int l_pin_num;  // 引脚号
+    int l_pin_fd;   // 句柄
+    int l_pin_type; // 类型 0:系统GPIO, 1:RTDM GPIO
+    int l_pin_dir;  // 方向 GPIO_INPUT 0 输入, GPIO_OUTPUT 1 输出
+};
+
+static struct t_goio_cfg mst_gpio_cfg[GPIO_NUM_TOTAL] = 
+{
+    {115, -1, -1, GPIO_OUTPUT},
+    {98, -1, -1, GPIO_OUTPUT},
+    {105, -1, -1, GPIO_OUTPUT},
+    {114, -1, -1, GPIO_OUTPUT},
+    {112, -1, -1, GPIO_OUTPUT},
+    {103, -1, -1, GPIO_OUTPUT},
+    {104, -1, -1, GPIO_OUTPUT},
+    {102, -1, -1, GPIO_OUTPUT},
+    {99, -1, -1, GPIO_OUTPUT},
+    {113, -1, -1, GPIO_INPUT},
+    {267, -1, -1, GPIO_INPUT},
+    {266, -1, -1, GPIO_INPUT},
+    {2, -1, -1, GPIO_INPUT},
+};
+#endif
+
 // static int gpio_watchdog_val = 0;
 static int gpio_run_led_val = 0;
 
@@ -205,6 +243,30 @@ int sysfs_gpio_set_value(int gpio, int value)
     return fd;
 }
 
+int sysfs_gpio_get_value(int gpio)
+{
+    char path[64];
+    int fd = -1;
+    int value = 0;
+
+    snprintf(path, sizeof(path), "/sys/class/gpio/gpio%d/value", gpio);
+    fd = open(path, O_RDONLY);
+    if (fd < 0)
+    {
+        perror("Failed to open value");
+        return -1;
+    }
+
+    if (read(fd, value, 1) < 0)
+    {
+        perror("Failed to get value");
+        close(fd);
+        return -1;
+    }
+
+    return fd;
+}
+
 int sysfs_gpio_init(int gpio, int direction)
 {
     int ret;
@@ -220,17 +282,33 @@ int sysfs_gpio_init(int gpio, int direction)
         dp_err_n_c("sysfs_gpio_set_direction error");
     }
 
-    return sysfs_gpio_set_value(gpio, GPIO_LOW); // 初始化IO为低电平
+    if (GPIO_INPUT == direction)
+    {
+        return sysfs_gpio_get_value(gpio);
+    }
+    else
+    {
+        return sysfs_gpio_set_value(gpio, GPIO_LOW); // 初始化IO为低电平
+    }
 }
 
 int is_rtdm_device(int fd)
 {
+#if (0 == NEW_GOIO_VERSION)
     if (gpio_dev_type[fd] > SYS_GPIO)
         return 1;
     else if (gpio_dev_type[fd] == SYS_GPIO)
         return 0;
     else
         return -1;
+#else
+    if (mst_gpio_cfg[fd].l_pin_type > SYS_GPIO)
+        return 1;
+    else if (mst_gpio_cfg[fd].l_pin_type == SYS_GPIO)
+        return 0;
+    else
+        return -1;
+#endif
 }
 
 int rt_write(int fd, char *buf, int len)
@@ -243,7 +321,6 @@ int rt_write(int fd, char *buf, int len)
     }
     if (is_rtdm_device(fd) == 1)
     {
-        // Xenomai RTDM设备：需要转换为二进制值
         value = atoi(buf);
         if (value != 0 && value != 1)
         {
@@ -254,70 +331,36 @@ int rt_write(int fd, char *buf, int len)
     }
     else
     {
-        // 常规系统设备：直接传递字符串
         return write(fd, buf, len);
     }
 }
 
-int rt_read(int fd, char *buf, int len)
+int rt_read(int _l_fd, int *_l_state, int len)
 {
-    int ret = 0;
+    int ret = 0, l_val = -1;
 
-    if (is_rtdm_device(fd) == 1)
+    if (is_rtdm_device(_l_fd) == 1)
     {
-        dp_info_n_c("fd = %d", fd);
-        // Xenomai RTDM设备：读取二进制值
-        int value = 0;
-
-        // 从RTDM设备读取二进制状态（通常是4字节的int）
-        ret = read(fd, &value, sizeof(value));
-        dp_info_n_c("ret = %d", ret);
-        if (ret != sizeof(value))
+        ret = read(_l_fd, &l_val, sizeof(l_val));
+        if (ret < 0 || ret != sizeof(l_val))
         {
             dp_err_n_c("Failed to read from RTDM device, ret=%d", ret);
             return -1;
         }
-
-        // 将二进制值转换为字符'0'或'1'
-        if (value == 0)
-        {
-            buf[0] = '0';
-        }
-        else if (value == 1)
-        {
-            buf[0] = '1';
-        }
-        else
-        {
-            dp_err_n_c("Unexpected value from RTDM device: %d", value);
-            return -1;
-        }
-
-        buf[1] = '\0'; // 字符串结束符
-        return 1;      // 读取到的字符数
+        *_l_state = l_val;
     }
     else
     {
-        // 常规系统设备：直接读取字符串
-        ret = read(fd, buf, len);
+        ret = read(_l_fd, &l_val, len);
         dp_err_n_c("ret=%d", ret);
         if (ret < 0)
         {
             dp_err_n_c("Failed to read from regular device");
             return -1;
         }
-
-        buf[ret] = '\0'; // 确保字符串正确结束
-
-        // 移除可能的换行符
-        if (ret > 0 && buf[ret - 1] == '\n')
-        {
-            buf[ret - 1] = '\0';
-            ret--;
-        }
-
-        return ret; // 返回读取的字符数
+        *_l_state = l_val;
     }
+    return ret;
 }
 
 int rtdm_gpio_init(int gpio, int direction)
@@ -326,14 +369,22 @@ int rtdm_gpio_init(int gpio, int direction)
     int fd = -1, ret;
     int value = 1;
     snprintf(path, sizeof(path), "/dev/rtdm/3604000.pinctrl/gpio%d", gpio);
-    fd = open(path, O_RDWR);
+    if (GPIO_INPUT == direction)
+    {
+        fd = open(path, O_RDWR | O_NONBLOCK);
+    }
+    else
+    {
+        fd = open(path, O_RDWR);
+    }
     if (fd < 0)
     {
+        dp_err_n_c("gpio [%d] open error", gpio);
         perror("open");
         return -1;
     }
 
-    if (113 == gpio) /* 预置返校是开入 */
+    if (GPIO_INPUT == direction)
     {
         ret = ioctl(fd, GPIO_RTIOC_DIR_IN, &value);
     }
@@ -343,7 +394,8 @@ int rtdm_gpio_init(int gpio, int direction)
     }
     if (ret < 0)
     {
-        perror("ioctl DIR_OUT");
+        dp_err_n_c("gpio [%d] ioctl error", gpio);
+        perror("gpio ioctl err");
         close(fd);
         return -1;
     }
@@ -353,8 +405,8 @@ int rtdm_gpio_init(int gpio, int direction)
 
 int gpio_init(void)
 {
-#define GPIO_OUTPUT 1
     int i;
+#if (0 == NEW_GOIO_VERSION)
 
     for (i = 0; i < DO_NUM; i++)
     {
@@ -387,6 +439,40 @@ int gpio_init(void)
     }
 
     return 0;
+
+#else
+    
+    for (i = 0; i < GPIO_NUM_TOTAL; i++)
+    {
+        mst_gpio_cfg[i].l_pin_fd = rtdm_gpio_init(mst_gpio_cfg[i].l_pin_num, mst_gpio_cfg[i].l_pin_dir);
+        if (mst_gpio_cfg[i].l_pin_fd < 0)
+        {
+            mst_gpio_cfg[i].l_pin_fd = sysfs_gpio_init(mst_gpio_cfg[i].l_pin_num, mst_gpio_cfg[i].l_pin_dir);
+            if (mst_gpio_cfg[i].l_pin_fd < 0)
+            {
+                dp_err_n_c("mst_gpio_cfg[%d].l_pin_fd error", i);
+                mst_gpio_cfg[i].l_pin_fd = -1;
+                mst_gpio_cfg[i].l_pin_type = -1;
+                return -1;
+            }
+        }
+        else
+        {
+            mst_gpio_cfg[i].l_pin_type = mst_gpio_cfg[i].l_pin_fd; // 保存RTDM设备类型句柄,这里有风险，fd句柄可能为0
+        }
+    }
+
+    msleep(10); // 延时10ms
+
+    kc_kout0_stu = 0;
+
+    for (i = 0; i < (DO_NUM - 1); i++)
+    {
+        rt_write(mst_gpio_cfg[i].l_pin_fd, "1", 2);
+    }
+
+    return 0;
+#endif
 }
 
 int gpio_exit(void)
@@ -395,12 +481,21 @@ int gpio_exit(void)
 
     for (i = 0; i < DO_NUM; i++)
     {
+#if (0 == NEW_GOIO_VERSION)
         if (gpio_val_fd[i] >= 0)
         {
             close(gpio_val_fd[i]);
             gpio_val_fd[i] = -1;
         }
         sysfs_gpio_unexport(gpio_val[i]);
+#else
+        if (mst_gpio_cfg[i].l_pin_fd >= 0)
+        {
+            close(mst_gpio_cfg[i].l_pin_fd);
+            mst_gpio_cfg[i].l_pin_fd = -1;
+        }
+        sysfs_gpio_unexport(mst_gpio_cfg[i].l_pin_num);
+#endif
     }
 
     return 0;
@@ -456,34 +551,31 @@ unsigned short gpio_di_fj(void)
 }
 
 /**
- * @brief          读取预置返校的状态
+ * @brief          读取gpio的状态
  * @author         lch (lch_work@foxmail.com)
  * @version        1.0
- * @date           20251229
+ * @date           20260311
+ * @param[in/out]  {uint8_t} _uc_idx 下标
  * @return         * int
  * @retval         none
- *
+ * 
  * @warning        none
  * @note           none
  */
-int gpioio_get_perset_status(void)
+int gpioio_get_gpio_status(uint8_t _uc_idx)
 {
-    char buf[2] = {0};
-    int ret = 0;
+    int ret, l_io_state = 0;
 
-    if (gpio_val_fd[DO_IN_PRESET] < 0)
-    {
-        dp_err_n_c("gpio_val_fd[DO_IN_PRESET] = %d, not initialized", gpio_val_fd[DO_IN_PRESET]);
+    if (_uc_idx < DO_IN_PRESET || _uc_idx > GPIO_INT_M4)
         return -1;
-    }
 
-    ret = read(gpio_val_fd[DO_IN_PRESET], buf, sizeof(buf));
-    if (ret > 0)
+    ret = rt_read(mst_gpio_cfg[_uc_idx].l_pin_fd, &l_io_state, sizeof(l_io_state));
+    if (ret < 0)
     {
-        return buf[0] - '0'; // 字符转换为数字
+        dp_err_n_c("l_io_state: %d\r\n", l_io_state);
+        return -2;
     }
-
-    return -1;
+    return l_io_state;
 }
 
 /******************************************************************************
@@ -504,6 +596,7 @@ int gpio_kout_do(int on, unsigned int kout)
     if (kout > DO_OUT_PRESET)
         return;
 
+#if (0 == NEW_GOIO_VERSION)
     if (on)
     {
         l_ret = rt_write(gpio_val_fd[kout + DO_OUT0], "0", 2);
@@ -514,6 +607,18 @@ int gpio_kout_do(int on, unsigned int kout)
         l_ret = rt_write(gpio_val_fd[kout + DO_OUT0], "1", 2);
         // dp_info_n_c("kout = %d, on = %d, l_ret = %d", kout, on, l_ret);
     }
+#else
+    if (on)
+    {
+        l_ret = rt_write(mst_gpio_cfg[kout + DO_OUT0].l_pin_fd, "0", 2);
+        // dp_info_n_c("kout = %d, on = %d, l_ret = %d", kout, on, l_ret);
+    }
+    else
+    {
+        l_ret = rt_write(mst_gpio_cfg[kout + DO_OUT0].l_pin_fd, "1", 2);
+        // dp_info_n_c("kout = %d, on = %d, l_ret = %d", kout, on, l_ret);
+    }
+#endif
     return l_ret;
 }
 
@@ -597,77 +702,44 @@ void esam_power_ctrl(int on)
 
 /*------------------------------ 测试函数 -------------------------------------
  */
-#ifdef _GPIO_DEBUG
-#include "ustimer.h"
-#include "rt.h"
 
-int test_kc_function(void)
+#if (0)
+int test_read_pin(void)
 {
-    rt_write(gpio_val_fd[DO_OUT_PRESET], "0", 2); // 预置动作
-    char gpio_state[2];
-    int ret;
-    sleep(1);
+    int ret, l_io_state = 0;
+    dp_info_n_c("test_read_pin!");
 
-#if (1)
-    // 读取GPIO状态
-    ret = rt_read(gpio_val_fd[DO_IN_PRESET], gpio_state, sizeof(gpio_state));
-    printf("ret: %d\n", ret);
+    ret = rt_read(mst_gpio_cfg[GPIO_INT_M1].l_pin_fd, &l_io_state, sizeof(l_io_state));
+    dp_info_n_c("ret: %d", ret);
     if (ret > 0)
     {
-        gpio_state[ret] = '\0';             // 添加字符串结束符
-        printf("PRESET: %s\n", gpio_state); // 应该是"0"或"1"
+        dp_info_n_c("l_io_state: %d\r\n", l_io_state);
+    }
+    else
+    {
+        dp_err_n_c("l_io_state: %d\r\n", l_io_state);
     }
-#endif
-    rt_write(gpio_val_fd[DO_OUT0], "0", 2);
-    sleep(1);
-    rt_write(gpio_val_fd[DO_OUT0], "1", 2);
-
-    rt_write(gpio_val_fd[DO_OUT1], "0", 2);
-    sleep(1);
-    rt_write(gpio_val_fd[DO_OUT1], "1", 2);
-
-#if (0)
-
-    rt_write(gpio_val_fd[DO_OUT2], "0", 2);
-    sleep(5);
-    rt_write(gpio_val_fd[DO_OUT2], "1", 2);
-
-    rt_write(gpio_val_fd[DO_OUT3], "0", 2);
-    sleep(5);
-    rt_write(gpio_val_fd[DO_OUT3], "1", 2);
-#endif
-
-    rt_write(gpio_val_fd[DO_OUT_PRESET], "1", 2); // 预置动作
-    sleep(1);
 
-#if (1)
-    // 读取GPIO状态
-    ret = rt_read(gpio_val_fd[DO_IN_PRESET], gpio_state, sizeof(gpio_state));
-    printf("ret: %d\n", ret);
+    ret = rt_read(mst_gpio_cfg[GPIO_INT_M3].l_pin_fd, &l_io_state, sizeof(l_io_state));
+    dp_info_n_c("ret: %d", ret);
     if (ret > 0)
     {
-        gpio_state[ret] = '\0';             // 添加字符串结束符
-        printf("PRESET: %s\n", gpio_state); // 应该是"0"或"1"
+        dp_info_n_c("l_io_state: %d\r\n", l_io_state);
+    }
+    else
+    {
+        dp_err_n_c("l_io_state: %d\r\n", l_io_state);
     }
-#endif
-
-#if (0)
-    rt_write(gpio_val_fd[DO_OUT4], "0", 2);
-    sleep(5);
-    rt_write(gpio_val_fd[DO_OUT4], "1", 2);
-
-    rt_write(gpio_val_fd[DO_OUT5], "0", 2);
-    sleep(5);
-    rt_write(gpio_val_fd[DO_OUT5], "1", 2);
-
-    rt_write(gpio_val_fd[DO_OUT6], "0", 2);
-    sleep(5);
-    rt_write(gpio_val_fd[DO_OUT6], "1", 2);
 
-    rt_write(gpio_val_fd[DO_OUT7], "0", 2);
-    sleep(5);
-    rt_write(gpio_val_fd[DO_OUT7], "1", 2);
-#endif
+    ret = rt_read(mst_gpio_cfg[GPIO_INT_M4].l_pin_fd, &l_io_state, sizeof(l_io_state));
+    dp_info_n_c("ret: %d", ret);
+    if (ret > 0)
+    {
+        dp_info_n_c("l_io_state: %d\r\n", l_io_state);
+    }
+    else
+    {
+        dp_err_n_c("l_io_state: %d\r\n", l_io_state);
+    }
 }
-
 #endif

app_public/fuxi_public/fuxi_bsp/source/gps.c

@@ -137,6 +137,25 @@ int gps_init(void)
     }
     fflush(stdout);
 
+    /* Get linux system current time */
+    // 此处精度还可以再提高，但是ioctl接口读取rtc时间后会有问题，暂时先这样了
+    clock_gettime(CLOCK_REALTIME, &ts);
+    timespec_to_rtc(ts, &ct, 1);
+    if (ct.hour >= 24 || ct.min >= 60 || ct.month > 12 || ct.day > 31 || ct.day == 0 || ct.month == 0) // 读取系统时钟错误
+    {
+        /* Reset linux system time */
+        ct.year = 8;
+        ct.month = 8;
+        ct.day = 8;
+        ct.hour = 8;
+        ct.min = 8;
+        rtc_to_timespec(&ct, &ts);
+        rt_printf("gps read system date data error!!!");
+    }
+
+    g_sys_time.tv_sec = ts.tv_sec;
+    g_sys_time.tv_nsec = ts.tv_nsec;
+
     g_gps_virt_addr = (char *)g_gps_map_base + offset_in_page;
     // printf("g_gps_virt_addr: %p %p %x\n", g_gps_virt_addr, g_gps_map_base, offset_in_page);
 
@@ -152,7 +171,7 @@ int gps_init(void)
     /* set timer intervalue */
     temp_virt_l_base = (char *)g_gps_map_base + 0x84;
     temp_virt_h_base = (char *)g_gps_map_base + 0x8C;
-    *(volatile u_int32_t *)(temp_virt_l_base) = 3000000;
+    *(volatile u_int32_t *)(temp_virt_l_base) = (ts.tv_nsec == 0) ? 3000000 : ts.tv_nsec / 1000 * 3;
     *(volatile u_int32_t *)(temp_virt_h_base) = 0x0;
 
     /* set mode to auto reload */
@@ -166,23 +185,13 @@ int gps_init(void)
     read_result = *(volatile u_int32_t *)(temp_virt_irq_base);
     *(volatile u_int32_t *)(temp_virt_irq_base) = (read_result | TIMER_IRQ_EN(3));
 
-    /* Get linux system current time */
-    clock_gettime(CLOCK_REALTIME, &ts);
-    timespec_to_rtc(ts, &ct, 1);
-    if (ct.hour >= 24 || ct.min >= 60 || ct.month > 12 || ct.day > 31 || ct.day == 0 || ct.month == 0) // 读取系统时钟错误
-    {
-        /* Reset linux system time */
-        ct.year = 8;
-        ct.month = 8;
-        ct.day = 8;
-        ct.hour = 8;
-        ct.min = 8;
-        rtc_to_timespec(&ct, &ts);
-        rt_printf("gps read system date data error!!!");
-    }
-
-    g_sys_time.tv_sec = ts.tv_sec;
-    g_sys_time.tv_nsec = ts.tv_nsec;
+    usleep(1);
+    read_result = *(volatile u_int32_t *)temp_virt_ctl_base;
+    read_result &= ~TIMER_CTL_ENABLE;
+    *(volatile u_int32_t *)temp_virt_ctl_base = read_result;
+    *(volatile u_int32_t *)(temp_virt_l_base) = 3000000;
+    read_result |= (TIMER_CTL_ENABLE);
+    *(volatile u_int32_t *)temp_virt_ctl_base = read_result;
 
     init_timer_1ms_thread();
 
@@ -200,6 +209,7 @@ int timer_1ms(void *arg)
 
     printf("Thread created successfully: %s, PID: %d LWP: %d\r\n",
            "timer_1ms", (int)syscall(SYS_gettid), (int)syscall(SYS_gettid));
+    prctl(PR_SET_NAME, "gps_check_isr_thread");
     while (1)
     {
         gps_isr();
@@ -318,40 +328,116 @@ int gps_get_time(struct timespec *p_ts)
 
 int gps_set_time(struct timespec *p_ts)
 {
+    int ret = 0;
+    bool write_rtc = false;
+    struct timespec r_ts;
+    struct rtc_time_t rtc_set, rtc_read;
     unsigned int flags;
     unsigned int tmp;
     unsigned int read_result;
-    void *temp_virt_cvl_base, *temp_virt_irq_base, *temp_virt_ctrl_base;
+    void *temp_virt_ivl_base, *temp_virt_ctrl_base;
 
     if (!p_ts)
     {
         return -1;
     }
 
+    // 转换为rtc格式
+    if (timespec_to_rtc(*p_ts, &rtc_set, 1) != 0)
+    {
+        return -11;
+    }
+
+    if (rtc_set.ms > 59999)
+    {
+        return -2;
+    }
+    if (rtc_set.min > 59)
+    {
+        return -3;
+    }
+    if (rtc_set.hour >= 24)
+    {
+        return -4;
+    }
+    if (rtc_set.day > 31)
+    {
+        return -5;
+    }
+    if (rtc_set.month > 12)
+    {
+        return -6;
+    }
+
     rt_irq_save(flags);
     g_sys_time.tv_nsec = p_ts->tv_nsec;
     g_sys_time.tv_sec = p_ts->tv_sec;
 
+    clk_time_get(&r_ts);
+    timespec_to_rtc(r_ts, &rtc_read, 1);
+
     tmp = 3000000 - ((g_sys_time.tv_nsec / 1000) * 3);
     if (tmp > 3000000)
         tmp = 3000000;
 
     temp_virt_ctrl_base = (char *)g_gps_map_base + 0x80;
-    temp_virt_cvl_base = (char *)g_gps_map_base + 0x88;
+    temp_virt_ivl_base = (char *)g_gps_map_base + 0x84;
 
     read_result = *(volatile u_int32_t *)temp_virt_ctrl_base;
     read_result &= ~TIMER_CTL_ENABLE;
     *(volatile u_int32_t *)temp_virt_ctrl_base = read_result;
 
-    *(volatile u_int32_t *)(temp_virt_cvl_base) = tmp;
-
+    // 暂停定时器后根据对时ms修改间隔寄存器的值然后开启定时器的同时reload计数寄存器从设置的ms开始跑
+    *(volatile u_int32_t *)(temp_virt_ivl_base) = tmp;
     read_result |= (TIMER_CTL_ENABLE | TIMER_CTL_AUTORELOAD);
     *(volatile u_int32_t *)temp_virt_ctrl_base = read_result;
-    // ((TIMER_TypeDef *) g_timer_base)->TMR3_CVH_REG = 0x0;
-
+    if (tmp != 3000000)
+    {
+        usleep(1);
+        // 暂停定时器将间隔寄存器恢复3000000,即1s的定时器中断
+        read_result = *(volatile u_int32_t *)temp_virt_ctrl_base;
+        read_result &= ~TIMER_CTL_ENABLE;
+        *(volatile u_int32_t *)temp_virt_ctrl_base = read_result;
+        *(volatile u_int32_t *)(temp_virt_ivl_base) = 3000000;
+        read_result |= (TIMER_CTL_ENABLE);
+        *(volatile u_int32_t *)temp_virt_ctrl_base = read_result;
+        // ((TIMER_TypeDef *) g_timer_base)->TMR3_CVH_REG = 0x0;
+    }
     rt_irq_restore(flags);
 
-    return 0;
+    // 更新RTC时间
+    write_rtc = false;
+    // 秒脉冲修正不需要频繁写入rtc
+    if (rtc_set.ms != rtc_read.ms)
+    {
+        if (rtc_set.ms >= rtc_read.ms)
+        {
+            if (rtc_set.ms - rtc_read.ms >= 10)
+            {
+                write_rtc = true;
+            }
+        }
+        else
+        {
+            if (rtc_read.ms - rtc_set.ms >= 10)
+            {
+                write_rtc = true;
+            }
+        }
+    }
+
+    if (write_rtc)
+    {
+        ret = rtc_time_write(&rtc_set);
+        if (ret == 0)
+        {
+            rt_err_clr(ERR_CODE_RTC, 0);
+        }
+        else
+        {
+            rt_printf("rtc_time_write:ret=%d.\r\n", ret);
+        }
+    }
 }
 
 /******************************************************************************

app_public/fuxi_public/fuxi_bsp/source/led_ftu.c

@@ -160,8 +160,7 @@ int led_polling_5ms(void)
 {
     int i;
     // 遍历所有灯
-#if !defined CPU_FUXI
-    // TODO EWen 开出点控灯的集中式不用此方式
+#if !defined CPU_FUXI // EWen 开出点控灯的集中式不用此方式
     for (i = 0; i < g_led_slot[EQU_SLOT_KZ].num; i++)
     {
         // 如果没有配置，跳过

app_public/fuxi_public/fuxi_bsp/source/pps_sync.c

@@ -23,6 +23,7 @@
 #include <sys/time.h>
 #include <sys/timex.h>
 #include <stdint.h>
+#include <sys/prctl.h>
 
 #include <gps.h>
 
@@ -235,10 +236,12 @@ int calibrated_subsecond_adjust(uint64_t pps_ns, struct performance_benchmark *b
 
     struct timespec current_ts, new_ts;
     int ret;
+    bool bset = false;
+    const int correction_value_ns = 500000; // 0.5ms
 
     if (gps_time_valid == 1)
     {
-        new_ts.tv_sec = shared_gps_time; // TODO，是否得加一秒
+        new_ts.tv_sec = shared_gps_time + 1; // TODO，是否得加一秒
         new_ts.tv_nsec = 0;
         gps_time_valid = 0;
     }
@@ -250,9 +253,46 @@ int calibrated_subsecond_adjust(uint64_t pps_ns, struct performance_benchmark *b
     // clock_gettime(CLOCK_REALTIME, &current_ts); //这个是改为获取GPS本身时间 zhl
     // DBG_SYNC("当前时间 clock_gettime: %ld.%09ld\n", current_ts.tv_sec, current_ts.tv_nsec);
     // ret = clock_settime(CLOCK_REALTIME, &new_ts);
-
+    gps_get_time(&current_ts);
+    if (current_ts.tv_sec == new_ts.tv_sec)
+    {
+        if (current_ts.tv_nsec >= correction_value_ns)
+        {
+            bset = true;
+        }
+    }
+    else
+    {
+        if (abs(new_ts.tv_sec - current_ts.tv_sec) > 1)
+        {
+            bset = true;
+        }
+        else
+        {
+            if (new_ts.tv_sec > current_ts.tv_sec)
+            {
+                // 终端时间慢1ms以上
+                if (NSEC_PER_SEC - current_ts.tv_nsec >= correction_value_ns)
+                {
+                    bset = true;
+                }
+            }
+            else
+            {
+                // 终端时间快1ms以上
+                if (current_ts.tv_nsec - correction_value_ns >= 0)
+                {
+                    bset = true;
+                }
+            }
+        }
+    }
     // DBG_SYNC("pps_adjust->gps_set_time:: %ld.%09ld\n", new_ts.tv_sec, new_ts.tv_nsec);
-    gps_set_time(&new_ts); // 写入应用程序全局定时器
+    if (bset)
+    {
+        gps_set_time(&new_ts); // 写入应用程序全局定时器
+        rt_printf("gps set time!\r\n");
+    }
     // memset(&new_ts, 0, sizeof(new_ts));
     // gps_get_time(&new_ts);
     // DBG_SYNC("pps_adjust->gps_get_time: %ld.%09ld\n", new_ts.tv_sec, new_ts.tv_nsec);
@@ -324,6 +364,7 @@ void pps_capture_main(void *arg)
 
     display_system_time("当前系统时间");
 
+    prctl(PR_SET_NAME, "pps_capture_thread");
     while (running)
     {
         // 检查信号状态

app_public/fuxi_public/fuxi_bsp/source/rtc_rx8025.c

@@ -69,9 +69,13 @@ typedef struct
 
 /*------------------------------ 全局变量 -------------------------------------
  */
-
-int g_rtc_write_5ms;    // 离实际写入时间还差多少个5ms
-rtc_t g_rtc_write_data; // 需要写入RTC芯片的时间
+struct rtc_write
+{
+    bool write_flg;               // 执行写入标志
+    int write_5ms;                // 离实际写入时间还差多少个5ms
+    struct rtc_time_t write_data; // 需要写入RTC芯片的时间
+};
+struct rtc_write rtc_write;
 
 /*------------------------------ 函数声明 -------------------------------------
  */
@@ -177,7 +181,7 @@ int rtc_time_read(struct rtc_time_t *p_tm)
 extern void sys_time_change(struct rtc_time_t *p_ct);
 int rtc_time_write(struct rtc_time_t *p_tm)
 {
-    // uint32_t flags;
+    uint32_t flags;
     int seccond, ms5;
     rtc_t rtc;
 
@@ -227,12 +231,15 @@ int rtc_time_write(struct rtc_time_t *p_tm)
         ms5 = 1;
     }
 
+    p_tm->ms = seccond * 1000; // 在下一秒整秒时写入rtc
     if (seccond >= 60)
     {
         seccond -= 60;
+        p_tm->ms = 0; // 加1秒后刚好一分钟，分钟加1，ms清0
         sys_time_change(p_tm);
     }
 
+#if (0)
     // 二进制转换为BCD
     rtc.second = (unsigned char)(((seccond / 10) << 4) | (seccond % 10));
     rtc.minute = (unsigned char)(((p_tm->min / 10) << 4) | (p_tm->min % 10));
@@ -243,11 +250,12 @@ int rtc_time_write(struct rtc_time_t *p_tm)
 
     // 星期不使用直接赋值1
     rtc.week = 1;
+#endif
 
     // 写入数据
     rt_irq_save(flags);
-    g_rtc_write_data = rtc;
-    g_rtc_write_5ms = ms5;
+	rtc_write.write_data = *p_tm;
+	rtc_write.write_5ms = ms5;
     rt_irq_restore(flags);
 
     return 0;
@@ -258,13 +266,14 @@ void rtc_time_write_5ms(void)
     int ret = 0;
     rtc_ctrl_t rtc_ctrl;
 
-    if (g_rtc_write_5ms == 0)
+    if (rtc_write.write_5ms == 0)
     {
         return;
     }
 
-    if (g_rtc_write_5ms == 1)
+    if (rtc_write.write_5ms == 1)
     {
+#if (0)
         // 写入时间数据
         // ret = _rtc_write(0,(unsigned char *)&g_rtc_write_data,sizeof(g_rtc_write_data));  //jack.liu 20200921 读写RTC失能
         if (ret)
@@ -281,9 +290,29 @@ void rtc_time_write_5ms(void)
         {
             rt_printf("rtc_write_5ms1:ret=%d)\r\n", ret);
         }
+#endif
+        // 置此标志在大循环中写入RTC,不在实时线程中写，因为调用非实时接口会造成模式切换;
+        // 会有10ms左右的误差
+        rtc_write.write_flg = true;
     }
 
-    g_rtc_write_5ms--;
+    rtc_write.write_5ms--;
+}
+
+void check_rtc_write(void)
+{
+    char pchDT[30];
+
+    if (rtc_write.write_flg)
+    {
+        rtc_write.write_flg = false;
+        sprintf(pchDT, "date -s '%04d-%02d-%02d %02d:%02d:%02d'",
+                rtc_write.write_data.year + 2000, rtc_write.write_data.month, rtc_write.write_data.day, rtc_write.write_data.hour, rtc_write.write_data.min, rtc_write.write_data.ms / 1000);
+        system(pchDT);
+        system("hwclock -w");
+        system("sync");
+        rt_printf("设置系统时间: %s\n", pchDT);
+    }
 }
 
 /******************************************************************************

app_public/fuxi_public/fuxi_bsp/source/shmem.c

@@ -132,7 +132,7 @@ int shm_packet_write_v2(uint32_t _ul_addr, uint8_t *_puc_data, uint32_t _ul_len)
     us_updata = 1;
     memcpy(&mlinux_shm_base_w[_ul_addr], &us_updata, 2); // 数据更新
 
-    for (int i = 0; i < _ul_len; i++) // zhl add TODO
+    for (int i = 0; i < _ul_len; i++) // zhl add
         ((uint8_t *)_puc_data)[i] = *(mlinux_shm_base_w + _ul_addr + i);
 
     /* 加上us_data_a, us_data_b, crc的长度 */
@@ -220,7 +220,7 @@ int shm_packet_read_v2(uint32_t _ul_addr, uint32_t _ul_len, uint8_t *_puc_data_o
     us_data_a = _puc_data_out[2] + ((uint16_t)_puc_data_out[3] << 8);
     us_data_b = _puc_data_out[4] + ((uint16_t)_puc_data_out[5] << 8);
 
-    /* 是否有在进行读写 */ // TODO 暂时注释
+    /* 是否有在进行读写 */
     if ((us_data_a == us_data_b))
     {
         /* 在拷贝过程中，数据没有被修改 */

app_public/fuxi_public/rt_lite/include/rt_error.h

@@ -72,6 +72,7 @@ enum
 	
 	ERR_CODE_AUTH,
 	ERR_CODE_ESAM,
+	ERR_CODE_RMT,
 	
 	ERR_CODE_NUM
 };

app_public/fuxi_public/rt_lite/source/rt_error.c

@@ -135,6 +135,7 @@ struct err_t g_err_txt[] =
         {ERR_FLAGS_SW, "电池活化文件错误"},
         {ERR_FLAGS_SW, "装置授权错误"},
         {0, "加密芯片错误"},
+        {ERR_FLAGS_SW, "遥调转发表错误"},
 };
 
 struct err_t g_err_entxt[] =
@@ -190,6 +191,7 @@ struct err_t g_err_entxt[] =
         {ERR_FLAGS_SW, "Incorrect battery activation file"},
         {ERR_FLAGS_SW, "Device authorization error"},
         {0, "Encryption chip error"},
+        {ERR_FLAGS_SW, "Rmt val iectable error"},
 };
 
 atomic_uint g_err_cnt_hw = ATOMIC_VAR_INIT(0); // 硬件错误计数

app_public/fuxi_public/rt_lite/source/rt_printf.c

@@ -21,7 +21,7 @@
 
 /*------------------------------- ºê¶¨Òå --------------------------------------
  */
-#define PRINTF_BUF_SIZE 4096
+#define PRINTF_BUF_SIZE (16 * 1024)
 
 /*------------------------------ ÀàÐͽṹ -------------------------------------
  */

app_public/fuxi_public/rt_lite/source/rt_socket.c

@@ -15,6 +15,8 @@
 #include "rt_socket.h"
 #include "rt_printf.h"
 #include <linux/route.h>
+#include <linux/ethtool.h>
+#include <linux/sockios.h>
 
 #include "bspconfig.h"
 
@@ -985,30 +987,51 @@ int rt_get_net_linkstatus(int if_index)
     /* Get the vitals from the interface. */
     strncpy(ifr.ifr_name, g_if_name[if_index], IFNAMSIZ);
 
-    if (ioctl(skfd, SIOCGMIIPHY, (uint64_t)&ifr) < 0)
+    if (if_index <= 1)
     {
-        /* TODO usb扩展网口这里会报错 需要后期进行处理 */
-        rt_printf("if_index = %d, SIOCGMIIPHY on %s failed!\n", if_index, ifr.ifr_name);
-        perror("err");
-        close(skfd);
-        return -2;
-    }
+        if (ioctl(skfd, SIOCGMIIPHY, (uint64_t)&ifr) < 0)
+        {
+            rt_printf("SIOCGMIIPHY on %s failed!\n", ifr.ifr_name);
+            close(skfd);
+            return -2;
+        }
 
-    data = (unsigned short *)(&ifr.ifr_data);
-    phy_id = data[0];
-    data[1] = 1;
+        data = (unsigned short *)(&ifr.ifr_data);
+        phy_id = data[0];
+        data[1] = 1;
+
+        if (ioctl(skfd, SIOCGMIIREG, (uint64_t)&ifr) < 0)
+        {
+            rt_printf("SIOCGMIIREG on %s failed!\n", ifr.ifr_name);
+            close(skfd);
+            return -3;
+        }
 
-    if (ioctl(skfd, SIOCGMIIREG, (uint64_t)&ifr) < 0)
-    {
-        rt_printf("SIOCGMIIREG on %s failed!\n", ifr.ifr_name);
         close(skfd);
-        return -3;
-    }
 
-    close(skfd);
+        mii_val = data[3];
+        return (((mii_val & 0x0016) == 0x0004) ? 0 : 1);
+    }
+    else
+    {
+        /* ----- ethtool 方式（适用于 USB 网卡）----- */
+        struct ethtool_value edata;
+        edata.cmd = ETHTOOL_GLINK; // 获取链路状态命令
+        ifr.ifr_data = (void *)&edata;
 
-    mii_val = data[3];
-    return (((mii_val & 0x0016) == 0x0004) ? 0 : 1);
+        if (ioctl(skfd, SIOCETHTOOL, &ifr) == 0)
+        {
+            // edata.data = 1 表示链路 up，返回 0；0 表示 down，返回 1
+            close(skfd);
+            return edata.data ? 0 : 1;
+        }
+        else
+        {
+            rt_printf("SIOCETHTOOL (ETHTOOL_GLINK) on %s failed!\n", ifr.ifr_name);
+            close(skfd);
+            return -4; // 自定义错误码：ethtool 方式失败
+        }
+    }
 }
 
 #define NET_NUM_CNT 3

app_public/gps/gps_uart.c

@@ -260,13 +260,14 @@ void GPS_Comm_App(GPS_COMM *p)
         // }
 
         GpsNmeaRmcData.gps_soe_time = ustimer_get_origin();
-
+#if (0)
         timespec_to_rtc(GpsNmeaRmcData.ts, &rtc, 1);
         if (rtc_time_write(&rtc) != 0) //
         {
             rt_printf("gps_fun:rtc_time_write err.\r\n");
             return;
         }
+#endif
         GpsNmeaRmcData.DataValidFlag = '0';
         //   rt_printf_time("gps adjust,time=%d\r\n",GpsNmeaRmcData.MsOffset);
     }

dtu/dtu_main_t536/app/Appconfig.c

@@ -59,42 +59,42 @@ struct unit g_unit[UNIT_NUM] =
 const  NAME_DEF ev_para[]=
 {
 /*  单位         名称*/
-	{0,			0		,		""},			// 0
-	{UNIT_A5,	SW_AC_IA,		"Ia"},	// 2
-	{UNIT_A5,	SW_AC_IB,		"Ib"},	// 3
-	{UNIT_A5,	SW_AC_IC,		"Ic"},	// 4
-	{UNIT_A5,	SW_AC_I0,		"3I0"},	// 5
+	{0,			0		,		""},		// 0
+	{UNIT_A5,	SW_AC_IA,		"Ia"},// 2
+	{UNIT_A5,	SW_AC_IB,		"Ib"},// 3
+	{UNIT_A5,	SW_AC_IC,		"Ic"},// 4
+	{UNIT_A5,	SW_AC_I0,		"3I0"},// 5
 
 	{UNIT_A5,	SW_AC_IA,		"XBa"}, // 谐波
 	{UNIT_A5,	SW_AC_IB,		"XBb"}, // 
 	{UNIT_A5,	SW_AC_IC,		"XBc"}, // 
 		
 
-	{UNIT_V100,	PUB_AC_UAB1,	"Uab"},	// 5
-	{UNIT_V100,	PUB_AC_UBC1,	"Ubc"},	// 6
-	{UNIT_V100,	PUB_AC_UCA1,	"Uca"},	//7
+	{UNIT_V100,	PUB_AC_UAB1,	"Uab"},// 5
+	{UNIT_V100,	PUB_AC_UBC1,	"Ubc"},// 6
+	{UNIT_V100,	PUB_AC_UCA1,	"Uca"},//7
 
 
-	{UNIT_V220,	PUB_AC_US1,		"Us1"},	//xj 	2016.09.02
-	{UNIT_V220,	PUB_AC_US2,		"Us2"},	//
+	{UNIT_V220,	PUB_AC_US1,		"Us1"},//xj 	2016.09.02
+	{UNIT_V220,	PUB_AC_US2,		"Us2"},//
 	
-	{UNIT_V100,	PUB_AC_U01,		"3U0"},	// 8
-	{UNIT_V100,	0,				"Ux"},	// 9	
+	{UNIT_V100,	PUB_AC_U01,		"3U0"},// 8
+	{UNIT_V100,	0,				"Ux"},// 9	
 
-	{UNIT_W,	SW_AC_IN_P,		"P"},	// 9	
-	{UNIT_Var,	SW_AC_IN_Q,		"Q"},	// 9	
-	{UNIT_NULL,	SW_AC_IN_COS,	"COS"},	// 9	
-	{UNIT_Hz,	PUB_AC_IN_F1,	"f"},	// 10
+	{UNIT_W,	SW_AC_IN_P,		"P"},// 9	
+	{UNIT_Var,	SW_AC_IN_Q,		"Q"},// 9	
+	{UNIT_NULL,	SW_AC_IN_COS,	"COS"},// 9	
+	{UNIT_Hz,	PUB_AC_IN_F1,	"f"},// 10
 	
 #ifdef METERING_ENERGY
 		{UNIT_kWh,	0,	"当前电度值"}, 	// 10
 		{UNIT_NULL, 0,	"变化总次数"}, 		// 10
-		{UNIT_NULL, 0,	"板卡号"},			// 10
+		{UNIT_NULL, 0,	"板卡号"},		// 10
 #endif
 
-	{UNIT_NULL,	0,				"配置"},	// 11
-	{UNIT_NULL,	0,				"通道"},	// 12
-	{UNIT_NULL,	0,				"遥控"},	// 13
+	{UNIT_NULL,	0,				"配置"},// 11
+	{UNIT_NULL,	0,				"通道"},// 12
+	{UNIT_NULL,	0,				"遥控"},// 13
 	{UINT_Hour,	0,				"时长"},
 };
 
@@ -133,627 +133,742 @@ Bit.[7-5]
 Bit.[0-4] 参数表的索引，    ＝0为没有参数。
 ********************************************************************************/
 
-const SOE_DEF tAllSOE[]=
+const SOE_DEF tAllSOE[] =
 {
-/*    代码         类型          参数1    参数2    参数3        名称            */
-/*保护专用事件*/
-	// 开关事件
-	{0x04,		{0,        0,        0},				"保护动作总"},
-	{0x04,		{0,        0,        0},				"故障总"},
-	{0x04,		{0,        0,        0},				"短路故障"},
-	{0x04,		{0,        0,        0},				"接地故障"},
-  	{0x14,		{EV_PARA_Ia,	0,					0}, "A相短路故障"},
-  	{0x14,		{EV_PARA_Ib,	0,					0}, "B相短路故障"},
- 	{0x14,		{EV_PARA_Ic,	0,					0}, "C相短路故障"},
-	{0x14,		{EV_PARA_Ia,	EV_PARA_Ib,			0}, "AB相短路故障"},
-  	{0x14,		{EV_PARA_Ib,	EV_PARA_Ic,			0}, "BC相短路故障"},
- 	{0x14,		{EV_PARA_Ia,	EV_PARA_Ic,			0}, "AC相短路故障"},
- 	{0x14,		{EV_PARA_Ia,	EV_PARA_Ib,	EV_PARA_Ic},"ABC相短路故障"},
-	{0x04,		{0,        0,        0},				"分段模式"},
-	{0x04,		{0,        0,        0},				"联络模式"},
-
-	{0xD4|SOE_TYPE_DELAY_FHZ,   {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic},   "过流I段动作"},
-	{0xD4,		                {EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},    "过流I段告警"},
+    /*    代码         类型          参数1    参数2    参数3        名称            */
+    /*保护专用事件*/
+    // 开关事件
+    {0x04, {0, 0, 0}, "保护动作总"},
+    {0x04, {0, 0, 0}, "故障总"},
+
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+
+    {0xD4 | SOE_TYPE_DELAY_FHZ, {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic}, "过流I段动作"},
+    {0xD4, {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic}, "过流I段告警"},
 #ifdef EV_GL_STATR
-    {0x04,		                {EV_PARA_Ia,EV_PARA_Ib, EV_PARA_Ic},    "过流I段启动"},
+    {0x04, {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic}, "过流I段启动"},
 #endif
-    {0x14,		{EV_PARA_Ia,	0,					0},				"过流I段A相短路故障"},
-    {0x14,		{EV_PARA_Ib,	0,					0},				"过流I段B相短路故障"},
-    {0x14,		{EV_PARA_Ic,	0,					0},				"过流I段C相短路故障"},
+    {0x14, {EV_PARA_Ia, 0, 0}, "过流I段A相短路故障"},
+    {0x14, {EV_PARA_Ib, 0, 0}, "过流I段B相短路故障"},
+    {0x14, {EV_PARA_Ic, 0, 0}, "过流I段C相短路故障"},
 
-	{0xD4|SOE_TYPE_DELAY_FHZ,   {EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},    "过流II段动作"},
-	{0xD4,		                {EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},    "过流II段告警"},
+    {0xD4 | SOE_TYPE_DELAY_FHZ, {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic}, "过流II段动作"},
+    {0xD4, {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic}, "过流II段告警"},
 #ifdef EV_GL_STATR
-    {0x04,		                {EV_PARA_Ia,EV_PARA_Ib, EV_PARA_Ic},    "过流II段启动"},
+    {0x04, {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic}, "过流II段启动"},
 #endif
-    {0x14,		{EV_PARA_Ia,	0,					0},				"过流II段A相短路故障"},
-    {0x14,		{EV_PARA_Ib,	0,					0},				"过流II段B相短路故障"},
-    {0x14,		{EV_PARA_Ic,	0,					0},				"过流II段C相短路故障"},
-	
-	{0xD4|SOE_TYPE_DELAY_FHZ,   {EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},    "过流Ⅲ段动作"},
-	{0xD4,		                {EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},    "过流Ⅲ段告警"},
+    {0x14, {EV_PARA_Ia, 0, 0}, "过流II段A相短路故障"},
+    {0x14, {EV_PARA_Ib, 0, 0}, "过流II段B相短路故障"},
+    {0x14, {EV_PARA_Ic, 0, 0}, "过流II段C相短路故障"},
+
+    {0xD4 | SOE_TYPE_DELAY_FHZ, {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic}, "过流Ⅲ段动作"},
+    {0xD4, {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic}, "过流Ⅲ段告警"},
 #ifdef EV_GL_STATR
-    {0x04,		                {EV_PARA_Ia,EV_PARA_Ib, EV_PARA_Ic},    "过流Ⅲ段启动"},
+    {0x04, {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic}, "过流Ⅲ段启动"},
 #endif
-    {0x14,		{EV_PARA_Ia,	0,					0},				"过流Ⅲ段A相短路故障"},
-    {0x14,		{EV_PARA_Ib,	0,					0},				"过流Ⅲ段B相短路故障"},
-    {0x14,		{EV_PARA_Ic,	0,					0},				"过流Ⅲ段C相短路故障"},
-	
-	{0xD4|SOE_TYPE_DELAY_FHZ,   {EV_PARA_I0,	EV_PARA_U0,	0},     "零流I段动作"},
-	{0xD4,		                {EV_PARA_I0,	EV_PARA_U0,	0},     "零流I段告警"},
+    {0x14, {EV_PARA_Ia, 0, 0}, "过流Ⅲ段A相短路故障"},
+    {0x14, {EV_PARA_Ib, 0, 0}, "过流Ⅲ段B相短路故障"},
+    {0x14, {EV_PARA_Ic, 0, 0}, "过流Ⅲ段C相短路故障"},
+
+    {0xD4 | SOE_TYPE_DELAY_FHZ, {EV_PARA_I0, EV_PARA_U0, 0}, "零流I段动作"},
+    {0xD4, {EV_PARA_I0, EV_PARA_U0, 0}, "零流I段告警"},
 #ifdef EV_GL_STATR
-    {0x04,		                {EV_PARA_U0,EV_PARA_I0,		0},     "零流I段启动"},
+    {0x04, {EV_PARA_U0, EV_PARA_I0, 0}, "零流I段启动"},
 #endif
-	
-	{0xD4|SOE_TYPE_DELAY_FHZ,   {EV_PARA_I0,	EV_PARA_U0,	0},     "零流II段动作"},
-	{0xD4,		                {EV_PARA_I0,	EV_PARA_U0,	0},     "零流II段告警"},
+
+    {0xD4 | SOE_TYPE_DELAY_FHZ, {EV_PARA_I0, EV_PARA_U0, 0}, "零流II段动作"},
+    {0xD4, {EV_PARA_I0, EV_PARA_U0, 0}, "零流II段告警"},
 #ifdef EV_GL_STATR
-    {0x04,		                {EV_PARA_U0,EV_PARA_I0,		0},     "零流II段启动"},
+    {0x04, {EV_PARA_U0, EV_PARA_I0, 0}, "零流II段启动"},
 #endif
 
-    {0xD4|SOE_TYPE_DELAY_FHZ,   {EV_PARA_I0,	EV_PARA_U0, 0},     "零流III段动作"},
-    {0xD4,		                {EV_PARA_I0,	EV_PARA_U0, 0},     "零流III段告警"},
+    {0xD4 | SOE_TYPE_DELAY_FHZ, {EV_PARA_I0, EV_PARA_U0, 0}, "零流III段动作"},
+    {0xD4, {EV_PARA_I0, EV_PARA_U0, 0}, "零流III段告警"},
 #ifdef EV_GL_STATR
-    {0x04,		                {EV_PARA_U0,EV_PARA_I0,	 0},        "零流III段启动"},
+    {0x04, {EV_PARA_U0, EV_PARA_I0, 0}, "零流III段启动"},
 #endif
-	
-	{0xD4|SOE_TYPE_DELAY_FHZ,   {EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},    "过流加速动作"},	
-	{0xD4|SOE_TYPE_DELAY_FHZ,   {EV_PARA_I0,	EV_PARA_U0,	0},         "零序加速动作"},
-	{0xD4|SOE_TYPE_DELAY_FHZ,   {EV_PARA_I0,	EV_PARA_U0,	0},         "零压加速动作"},
 
-	{0xD4,		                {EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},    "反时限过流动作"},
+    {0xD4 | SOE_TYPE_DELAY_FHZ, {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic}, "过流加速动作"},
+    {0xD4 | SOE_TYPE_DELAY_FHZ, {EV_PARA_I0, EV_PARA_U0, 0}, "零序加速动作"},
+    {0xD4 | SOE_TYPE_DELAY_FHZ, {EV_PARA_I0, EV_PARA_U0, 0}, "零压加速动作"},
 
-	{0xD4|SOE_TYPE_DELAY_FHZ,   {EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},    "合后故障过流I段动作"},	
-	{0xD4|SOE_TYPE_DELAY_FHZ,   {EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},    "合后故障过流II段动作"},
-	{0xD4|SOE_TYPE_DELAY_FHZ,   {EV_PARA_I0,	EV_PARA_U0,	0},         "合后故障零序动作"},
-	{0x94,		                {EV_PARA_Ia,EV_PARA_Ib, EV_PARA_Ic},    "相间过流告警"},
-	{0x94,		                {EV_PARA_I0,	EV_PARA_U0, 0},         "接地告警"},
+    {0xD4 | SOE_TYPE_DELAY_FHZ, {EV_PARA_U0, EV_PARA_I0, 0}, "零序电压跳闸"},
+    {0xD4, {EV_PARA_U0, EV_PARA_I0, 0}, "零序电压告警"},
 #ifdef EV_GL_STATR
-	{0x04,		{EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},		"相间I段启动"},	
-    {0x04,		{EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},		"相间II段启动"},
-	{0x04,		{EV_PARA_U0,EV_PARA_I0,		0},				"接地过流启动"},
+    {0x04, {EV_PARA_U0, EV_PARA_I0, 0}, "零序电压启动"},
 #endif
-
-	{0x00,		                {0,        0,        0}, "重合闸启动"},
-	{0x44|SOE_TYPE_DELAY_FHZ,   {0,        0,        0}, "一次重合动作"},
-	{0x44|SOE_TYPE_DELAY_FHZ,   {0,        0,        0}, "二次重合动作"},
-	{0x44|SOE_TYPE_DELAY_FHZ,   {0,        0,        0}, "三次重合动作"},
-	{0x44,		                {0,        0,        0}, "重合闸闭锁"},
-	{0x44,		                {0,        0,        0}, "大电流闭锁重合闸"},
-	{0x04,		                {0,        0,        0}, "重合闸充电完成"},
-	{0x04,		                {0,        0,        0}, "终止重合闸过程"},
-
-	{0xD4|SOE_TYPE_DELAY_FHZ,   {EV_PARA_U0,	EV_PARA_I0,	0}, "零序电压跳闸"},	
-	{0xD4,		                {EV_PARA_U0,	EV_PARA_I0,	0}, "零序电压告警"},	
+    {0x44, {0, 0, 0}, "涌流谐波闭锁"},
+    {0xD4, {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic}, "反时限过流动作"},
+
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+
+    {0x00, {0, 0, 0}, "重合闸启动"},
+    {0x44 | SOE_TYPE_DELAY_FHZ, {0, 0, 0}, "一次重合动作"},
+    {0x44 | SOE_TYPE_DELAY_FHZ, {0, 0, 0}, "二次重合动作"},
+    {0x44 | SOE_TYPE_DELAY_FHZ, {0, 0, 0}, "三次重合动作"},
+    {0x44, {0, 0, 0}, "重合闸闭锁"},
+    {0x44, {0, 0, 0}, "大电流闭锁重合闸"},
+    {0x04, {0, 0, 0}, "重合闸充电完成"},
+    {0x04, {0, 0, 0}, "终止重合闸过程"},
+
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+
+    {0x04, {0, 0, 0}, "分段模式"},
+    {0x04, {0, 0, 0}, "联络模式"},
+    {0x44, {0, 0, 0}, "闭锁合闸"},
+    {0x04, {EV_PARA_Us1, EV_PARA_Us2, 0}, "母线侧有压"},
+    {0x04, {EV_PARA_Us1, EV_PARA_Us2, 0}, "线路侧有压"},
+    {0x04, {EV_PARA_Us1, EV_PARA_Us2, 0}, "双侧失压"},
+    {0x44, {0, 0, 0}, "母线侧X闭锁"},
+    {0x44, {0, 0, 0}, "线路侧X闭锁"},
+    {0x44, {0, 0, 0}, "母线侧Y闭锁"},
+    {0x44, {0, 0, 0}, "线路侧Y闭锁"},
+    {0x44, {0, 0, 0}, "母线侧残压闭锁"},
+    {0x44, {0, 0, 0}, "线路侧残压闭锁"},
+    {0x54 | SOE_TYPE_DELAY_FHZ, {EV_PARA_U0, EV_PARA_I0, 0}, "合后零压动作"},
+    {0x44, {EV_PARA_U0, 0, 0}, "合前零压闭锁"},
+    {0x04, {EV_PARA_U0, 0, 0}, "合前零压"},
 #ifdef EV_GL_STATR
-    {0x04,		                {EV_PARA_U0,	EV_PARA_I0,	0}, "零序电压启动"},	
+    {0x04, {EV_PARA_U0, EV_PARA_I0, 0}, "FA零压启动"},
 #endif
-	{0x44,		{0,        0,        0},				"涌流谐波闭锁"},
-
-	{0x44,		{0,        0,        0},				"闭锁合闸"},
-	{0x04,		{EV_PARA_Us1,	EV_PARA_Us2,0},         "母线侧有压"},
-	{0x04,		{EV_PARA_Us1,	EV_PARA_Us2,0},         "线路侧有压"},
-	{0x04,		{EV_PARA_Us1,	EV_PARA_Us2,0},         "双侧失压"},
-    {0x44,		{0,        0,        0},				"母线侧X闭锁"},
-    {0x44,		{0,        0,        0},				"线路侧X闭锁"},
-    {0x44,		{0,        0,        0},				"母线侧Y闭锁"},
-    {0x44,		{0,        0,        0},				"线路侧Y闭锁"},
-    {0x44,		{0,        0,        0},				"母线侧残压闭锁"},
-    {0x44,		{0,        0,        0},				"线路侧残压闭锁"},
-
-	{0x54|SOE_TYPE_DELAY_FHZ,   {EV_PARA_U0, EV_PARA_I0, 0},    "合后零压动作"},
-	{0x44,		                {EV_PARA_U0, 0, 0},				"合前零压闭锁"},
-	{0x04,		                {EV_PARA_U0, 0, 0},				"合前零压"},
+    {0x44 | SOE_TYPE_DELAY_FHZ, {0, 0, 0}, "手分/遥分闭锁合闸"},
+    {0x44, {0, 0, 0}, "手合/遥合闭锁失压分"},
+    {0x44, {0, 0, 0}, "双电源闭锁合闸"},
+    {0x04 | SOE_TYPE_DELAY_FHZ, {0, 0, 0}, "合后故障"},
+    {0x44, {0, 0, 0}, "母线侧合后故障"},
+    {0x44, {0, 0, 0}, "线路侧合后故障"},
+    {0x44, {0, 0, 0}, "闭锁失压分闸"},
+    {0x04, {0, 0, 0}, "合闸解锁"},
+    {0x04, {0, 0, 0}, "人工解锁"},
+    {0x04, {0, 0, 0}, "同侧来电解锁"},
+    {0x04, {0, 0, 0}, "对侧来电解锁"},
+    {0x04, {0, 0, 0}, "满足条件解锁"},
+    {0x04, {0, 0, 0}, "联络有压解锁"},
+    {0x04, {0, 0, 0}, "联络单侧失压时间到"},
+    {0x04, {0, 0, 0}, "联络A侧失压告警"},
+    {0x04, {0, 0, 0}, "联络B侧失压告警"},
+    {0x04, {0, 0, 0}, "联络A侧失压合闸"},
+    {0x04, {0, 0, 0}, "联络B侧失压合闸"},
+    {0x44 | SOE_TYPE_DELAY_FHZ, {EV_PARA_Us1, EV_PARA_Us2, 0}, "得电合闸"},
+    {0x04, {EV_PARA_Us1, EV_PARA_Us2, 0}, "母线侧得电合闸"},
+    {0x04, {EV_PARA_Us1, EV_PARA_Us2, 0}, "线路侧得电合闸"},
+    {0xC4 | SOE_TYPE_DELAY_FHZ, {EV_PARA_Us1, EV_PARA_Us2, 0}, "联络合闸"},
+    {0xC4 | SOE_TYPE_DELAY_FHZ, {EV_PARA_Us1, EV_PARA_Us2, 0}, "失电分闸"},
+    {0x44, {0, 0, 0}, "联络合闸成功"},
+    {0x44, {0, 0, 0}, "联络合闸失败"},
+    {0x44, {0, 0, 0}, "联络开关充电完成"},
+    {0xD4 | SOE_TYPE_DELAY_FHZ, {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic}, "合到过流I段动作"},
+    {0xD4 | SOE_TYPE_DELAY_FHZ, {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic}, "合到过流II段动作"},
+    {0xD4 | SOE_TYPE_DELAY_FHZ, {EV_PARA_I0, EV_PARA_U0, 0}, "合到零序动作"},
+    {0x94, {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic}, "相间过流告警"},
+    {0x94, {EV_PARA_I0, EV_PARA_U0, 0}, "接地告警"},
 #ifdef EV_GL_STATR
-	{0x04,		{EV_PARA_U0,EV_PARA_I0,		0},				"FA零压启动"},	
+    {0x04, {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic}, "相间I段启动"},
+    {0x04, {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic}, "相间II段启动"},
+    {0x04, {EV_PARA_U0, EV_PARA_I0, 0}, "接地过流启动"},
 #endif
-	{0x44|SOE_TYPE_DELAY_FHZ,   {0,        0,        0}, "手分/遥分闭锁合闸"},
-	{0x44,		                {0,        0,        0}, "手合/遥合闭锁失压分"},
-	{0x44,		                {0,        0,        0}, "双电源闭锁合闸"},	
-	{0x04|SOE_TYPE_DELAY_FHZ,   {0,        0,        0}, "合后故障"},	
-    {0x44,		                {0,        0,        0}, "母线侧合后故障"},	
-    {0x44,		{0,        0,        0}, "线路侧合后故障"},	
-	{0x44,		{0,        0,        0}, "闭锁失压分闸"},	
-	{0x04,		{0,        0,        0}, "合闸解锁"},
-	{0x04,		{0,        0,        0}, "人工解锁"},
-	{0x04,		{0,        0,        0}, "对侧来电解锁"},
-	{0x04,		{0,        0,        0}, "联络有压解锁"},
-	{0x04,		{0,        0,        0}, "联络单侧失压时间到"},
-    {0x04,		{0,        0,        0}, "联络A侧失压告警"},
-    {0x04,		{0,        0,        0}, "联络B侧失压告警"},
-    {0x04,		{0,        0,        0}, "联络A侧失压合闸"},
-    {0x04,		{0,        0,        0}, "联络B侧失压合闸"},
-	{0x44|SOE_TYPE_DELAY_FHZ,		{EV_PARA_Us1,	EV_PARA_Us2,0}, "得电合闸"},
-	{0x04,		{EV_PARA_Us1,	EV_PARA_Us2,0}, 			        "母线侧得电合闸"},
-	{0x04,		{EV_PARA_Us1,	EV_PARA_Us2,0},				        "线路侧得电合闸"},
-	{0xC4|SOE_TYPE_DELAY_FHZ,		{EV_PARA_Us1,	EV_PARA_Us2,0}, "联络合闸"},
-	{0xC4|SOE_TYPE_DELAY_FHZ,		{EV_PARA_Us1,	EV_PARA_Us2,0}, "失电分闸"},
-	{0x44,		{0,        0,        0},    "联络合闸成功"},
-	{0x44,		{0,        0,        0},    "联络合闸失败"},
-	{0x44,		{0,        0,        0},            "联络开关充电完成"},
-	{0x44,		{0,        0,        0},            "手动合闸"},
-	{0x44,		{0,        0,        0},            "手动分闸"},
-	{0x44,		{0,        0,        0},            "开关就地合闸"},
-	{0x44,		{0,        0,        0},            "开关就地分闸"},
-	{0x44,		{0,        0,        0},            "遥控合闸"},
-	{0x44|SOE_TYPE_DELAY_FHZ, {0,        0,        0},              "遥控分闸"},
-
-	{0x44,		{0,        0,        0},    "多次分闸闭锁合闸"},
-	{0x44,		{0,        0,        0},    "上电拒合"},
-
+    {0x44, {0, 0, 0}, "手动合闸"},
+    {0x44, {0, 0, 0}, "手动分闸"},
+    {0x44, {0, 0, 0}, "开关就地合闸"},
+    {0x44, {0, 0, 0}, "开关就地分闸"},
+    {0x44, {0, 0, 0}, "遥控合闸"},
+    {0x44 | SOE_TYPE_DELAY_FHZ, {0, 0, 0}, "遥控分闸"},
+    {0x44, {0, 0, 0}, "多次分闸闭锁合闸"},
+    {0x44, {0, 0, 0}, "上电拒合"},
+    {0x44, {0, 0, 0}, "自转电功能投入"},
+    {0xC4, {EV_PARA_U0, EV_PARA_I0, 0}, "合后零序电压告警"},
 #ifdef YK_FA_ENBLE
-	{0x44,		{0,        0,        0},    "遥控闭锁FA"},	
+    {0x44, {0, 0, 0}, "遥控闭锁FA"},
 #endif
-
-#ifdef	FA_OC_COUNT
-	{0x44,		{0,        0,        0},    "过流脉冲计数闭锁"},
+#ifdef FA_OC_COUNT
+    {0x44, {0, 0, 0}, "过流脉冲计数闭锁"},
+#endif
+#ifdef FUNC_YL_FZ_SOE
+    {0x44, {0, 0, 0}, "联络Y闭锁"},
 #endif
 
-	{0x44,		{0,        0,        0},    "同期合闸"},
-
-//
-	{0xD4,		{EV_PARA_Uab,	EV_PARA_Ubc,			EV_PARA_Uca},				"电压过低解列"},
-	{0xD4,		{EV_PARA_Uab,	EV_PARA_Ubc,			EV_PARA_Uca},				"低电压自动解列"},
-	{0xD4,		{EV_PARA_Uab,	EV_PARA_Ubc,			EV_PARA_Uca},				"高电压自动解列"},
-	{0xD4,		{EV_PARA_Uab,	EV_PARA_Ubc,			EV_PARA_Uca},				"电压过高解列"},
-	{0xD4,		{EV_PARA_f,	0,0},						"频率过低解列"},
-	{0xD4,		{EV_PARA_f,	0,0},						"低频自动解列"},
-	{0xD4,		{EV_PARA_f,	0,0},						"高频自动解列"},
-	{0xD4,		{EV_PARA_f,	0,0},						"频率过高解列"},
-
-	{0xC4,		{0,        0,        0},    "智能分布式切除动作"},
-	{0xC4,		{0,        0,        0},    "智能分布式切除成功"},
-	{0xC4,		{0,        0,        0},    "智能分布式切除失败"},
-	{0xC4,		{0,        0,        0},    "分布式故障隔离动作"},	
-	{0xC4,		{0,        0,        0},    "分布式故障隔离成功"},
-	{0xC4,		{0,        0,        0},    "分布式故障隔离失败"},
-	{0xC4,		{0,        0,        0},    "分布式供电恢复动作"},	
-	{0xC4,		{0,        0,        0},    "分布式供电恢复成功"},
-	{0xC4,		{0,        0,        0},    "分布式供电恢复失败"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+
+    {0x05, {0, 0, 0}, "M侧节点故障01"},
+    {0x05, {0, 0, 0}, "M侧节点故障02"},
+    {0x05, {0, 0, 0}, "M侧节点故障03"},
+    {0x05, {0, 0, 0}, "M侧节点故障04"},
+    {0x05, {0, 0, 0}, "M侧节点故障05"},
+    {0x05, {0, 0, 0}, "M侧节点故障06"},
+    {0x05, {0, 0, 0}, "M侧节点故障07"},
+    {0x05, {0, 0, 0}, "M侧节点故障08"},
+
+    {0x05, {0, 0, 0}, "N侧节点故障01"},
+    {0x05, {0, 0, 0}, "N侧节点故障02"},
+    {0x05, {0, 0, 0}, "N侧节点故障03"},
+    {0x05, {0, 0, 0}, "N侧节点故障04"},
+
+    {0x05, {0, 0, 0}, "M侧故障隔离成功01"},
+    {0x05, {0, 0, 0}, "M侧故障隔离成功02"},
+    {0x05, {0, 0, 0}, "M侧故障隔离成功03"},
+    {0x05, {0, 0, 0}, "M侧故障隔离成功04"},
+    {0x05, {0, 0, 0}, "M侧故障隔离成功05"},
+    {0x05, {0, 0, 0}, "M侧故障隔离成功06"},
+    {0x05, {0, 0, 0}, "M侧故障隔离成功07"},
+    {0x05, {0, 0, 0}, "M侧故障隔离成功08"},
+    {0x05, {0, 0, 0}, "N侧故障隔离成功01"},
+    {0x05, {0, 0, 0}, "N侧故障隔离成功02"},
+    {0x05, {0, 0, 0}, "N侧故障隔离成功03"},
+    {0x05, {0, 0, 0}, "N侧故障隔离成功04"},
+
+    {0x05, {0, 0, 0}, "M侧开关拒跳01"},
+    {0x05, {0, 0, 0}, "M侧开关拒跳02"},
+    {0x05, {0, 0, 0}, "M侧开关拒跳03"},
+    {0x05, {0, 0, 0}, "M侧开关拒跳04"},
+    {0x05, {0, 0, 0}, "M侧开关拒跳05"},
+    {0x05, {0, 0, 0}, "馈线开关拒跳01"},
+    {0x05, {0, 0, 0}, "馈线开关拒跳02"},
+    {0x05, {0, 0, 0}, "馈线开关拒跳03"},
+    {0x05, {0, 0, 0}, "N侧开关拒跳01"},
+    {0x05, {0, 0, 0}, "N侧开关拒跳02"},
+    {0x05, {0, 0, 0}, "N侧开关拒跳03"},
+    {0x05, {0, 0, 0}, "馈线开关拒跳04"},
+
+    {0x05, {0, 0, 0}, "馈线开关过流闭锁01"},
+    {0x05, {0, 0, 0}, "馈线开关过流闭锁02"},
+    {0x05, {0, 0, 0}, "馈线开关过流闭锁03"},
+    {0x05, {0, 0, 0}, "馈线开关过流闭锁04"},
+    {0x05, {0, 0, 0}, "馈线开关过流闭锁05"},
+    {0x05, {0, 0, 0}, "馈线开关过流闭锁06"},
+    {0x05, {0, 0, 0}, "馈线开关过流闭锁07"},
+    {0x05, {0, 0, 0}, "馈线开关过流闭锁08"},
+    {0x05, {0, 0, 0}, "馈线开关过流闭锁09"},
+    {0x05, {0, 0, 0}, "馈线开关过流闭锁10"},
+    {0x05, {0, 0, 0}, "馈线开关过流闭锁11"},
+    {0x05, {0, 0, 0}, "馈线开关过流闭锁12"},
+#if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020 // 中山要求通信异常，全系统均异常
+    {0x05, {0, 0, 0}, "节点01通信异常"},
+    {0x05, {0, 0, 0}, "节点02通信异常"},
+    {0x05, {0, 0, 0}, "节点03通信异常"},
+    {0x05, {0, 0, 0}, "节点04通信异常"},
+    {0x05, {0, 0, 0}, "节点05通信异常"},
+    {0x05, {0, 0, 0}, "节点06通信异常"},
+    {0x05, {0, 0, 0}, "节点07通信异常"},
+    {0x05, {0, 0, 0}, "节点08通信异常"},
+    {0x05, {0, 0, 0}, "节点09通信异常"},
+    {0x05, {0, 0, 0}, "节点10通信异常"},
+    {0x05, {0, 0, 0}, "节点11通信异常"},
+    {0x05, {0, 0, 0}, "节点12通信异常"},
+    {0x05, {0, 0, 0}, "节点01通信异常复归"},
+    {0x05, {0, 0, 0}, "节点02通信异常复归"},
+    {0x05, {0, 0, 0}, "节点03通信异常复归"},
+    {0x05, {0, 0, 0}, "节点04通信异常复归"},
+    {0x05, {0, 0, 0}, "节点05通信异常复归"},
+    {0x05, {0, 0, 0}, "节点06通信异常复归"},
+    {0x05, {0, 0, 0}, "节点07通信异常复归"},
+    {0x05, {0, 0, 0}, "节点08通信异常复归"},
+    {0x05, {0, 0, 0}, "节点09通信异常复归"},
+    {0x05, {0, 0, 0}, "节点10通信异常复归"},
+    {0x05, {0, 0, 0}, "节点11通信异常复归"},
+    {0x05, {0, 0, 0}, "节点12通信异常复归"},
+#endif
+    {0xC4, {0, 0, 0}, "智能分布式切除动作"},
+    {0xC4, {0, 0, 0}, "智能分布式切除成功"},
+    {0xC4, {0, 0, 0}, "智能分布式切除失败"},
+    {0xC4, {0, 0, 0}, "分布式故障隔离动作"},
+    {0xC4, {0, 0, 0}, "分布式故障隔离成功"},
+    {0xC4, {0, 0, 0}, "分布式故障隔离失败"},
+    {0xC4, {0, 0, 0}, "分布式供电恢复动作"},
+    {0xC4, {0, 0, 0}, "分布式供电恢复成功"},
+    {0xC4, {0, 0, 0}, "分布式供电恢复失败"},
 
 #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
-	{0xD4,		{EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},		"分布式过流I段跳闸"},
-	{0xD4,		{EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},		"分布式过流II段跳闸"},
+    {0xD4, {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic}, "分布式过流I段跳闸"},
+    {0xD4, {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic}, "分布式过流II段跳闸"},
 #else
-	{0xD4,		{EV_PARA_Ia,EV_PARA_Ib,	EV_PARA_Ic},		"分布式过流跳闸"},
+    {0xD4, {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic}, "分布式过流跳闸"},
 #endif
-	
-	{0xD4,		{EV_PARA_I0,	0,0},       "分布式零序跳闸"},
-	{0x44,		{0,        0,        0},    "首开关失压分闸"},
-	{0x44,		{0,        0,        0},    "通信异常失压分闸"},
-	{0x44,		{0,        0,        0},    "装置越级跳闸"},
+
+    {0xD4, {EV_PARA_I0, 0, 0}, "分布式零序跳闸"},
+    {0x44, {0, 0, 0}, "首开关失压分闸"},
+    {0x44, {0, 0, 0}, "通信异常失压分闸"},
+    {0x44, {0, 0, 0}, "装置越级跳闸"},
 
 #ifdef GD_AREA_ZHONGSHAN_2020
-	{0xD4,		{EV_PARA_Ia,EV_PARA_Ib, EV_PARA_Ic},		"分布式合后I段跳闸"},
-	{0xD4,		{EV_PARA_Ia,EV_PARA_Ib, EV_PARA_Ic},		"分布式合后II段跳闸"},
-	{0xD4,		{EV_PARA_I0,	0,0},						"分布式合后零序跳闸"},
+    {0xD4, {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic}, "分布式合后I段跳闸"},
+    {0xD4, {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic}, "分布式合后II段跳闸"},
+    {0xD4, {EV_PARA_I0, 0, 0}, "分布式合后零序跳闸"},
 #endif
-	
-	{0x44,		{EV_PARA_Ia,	EV_PARA_Ib,	EV_PARA_Ic},		"遮断电流闭锁"},
-	{0x84,		{EV_PARA_Ia,EV_PARA_Ib, EV_PARA_Ic},		"电流重载告警"},
-	// {0x04,		{EV_PARA_Ia,	0,			0},    "Ia重载告警"}, 
-	// {0x04,		{EV_PARA_Ib,	0,			0},    "Ib重载告警"}, 
-	// {0x04,		{EV_PARA_Ic,	0,			0},    "Ic重载告警"}, 
-
-	{0x84,		{EV_PARA_Ia,EV_PARA_Ib, EV_PARA_Ic},		"电流过载告警"},
-	// {0x04,		{EV_PARA_Ia,	0,			0},    "Ia过载告警"}, 
-	// {0x04,		{EV_PARA_Ib,	0,			0},    "Ib过载告警"}, 
-	// {0x04,		{EV_PARA_Ic,	0,			0},    "Ic过载告警"}, 
-
-	{0x84,		{EV_PARA_Ia,EV_PARA_Ib, EV_PARA_Ic},		"负荷越限告警"},
-	// {0x04,		{EV_PARA_Ia,	0,			0},    "Ia越限告警"}, 
-	// {0x04,		{EV_PARA_Ib,	0,			0},    "Ib越限告警"}, 
-	// {0x04,		{EV_PARA_Ic,	0,			0},    "Ic越限告警"}, 
-	{0x84,		{EV_PARA_I0,0,	0},						"零序电流越限告警"},
-
-	{0x44,		{0,        0,        0},    "跳闸失败"},
-	{0x44,		{0,        0,        0},    "合闸失败"},
-	{0x44,		{0,        0,        0},    "开关拒动"},
-
-	{0x04,		{0,        0,        0},    "跳位有流告警"},
-
-	{0x07,		{0,        0,        0},    "保护投入软压板"},
-	{0x07,		{0,        0,        0},    "常规保护投入"},
-	{0x07,		{0,        0,        0},    "自动重合闸投入"},
-	{0x07,		{0,        0,        0},    "就地型馈线自动化投入"},
-	{0x07,		{0,        0,        0},    "智能分布式投入"},
-	{0x07,		{0,        0,        0},    "集中式投入"},
-    {0x07,		{0,        0,        0},    "同期合闸投入"},
-	{0x07,		{0,        0,        0},    "自动解列投入"},
-	{0x07,		{0,        0,        0},    "小电流接地保护投入"},
-	{0x07,		{0,        0,        0},    "线路断线告警投入"},
-	{0x07,		{0,        0,        0},    "不停电传动投入"},
-
-	{0x07,		{0,        0,        0},    "保护出口投入软压板"},
-	{0x07,		{0,        0,        0},    "远程运维软压板"},
-
-	{0x84,		{EV_PARA_I0,	EV_PARA_U0,	0}, "小电流接地启动"},
-	{0x05,		{EV_PARA_U0,	0,			0}, "小电流零压1告警"},	
-	{0x05,		{EV_PARA_U0,	0,			0}, "小电流零压2告警"},	
-	{0x84,		{EV_PARA_I0,	EV_PARA_U0,	0}, "接地故障总"},
-	{0x0,		{EV_PARA_Ia,	0,			0}, "A相接地故障"}, 
-	{0x0,		{EV_PARA_Ib,	0,			0}, "B相接地故障"},
-	{0x0,		{EV_PARA_Ic,	0,			0}, "C相接地故障"},
+    {0x44, {0, 0, 0}, "分布式转供未满足"},
+    {0x44, {0, 0, 0}, "分布式故障闭锁合闸"},
+    {0x44, {0, 0, 0}, "分布式分闸闭锁合闸"},
+
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+
+    {0x44, {0, 0, 0}, "同期合闸"},
+    {0x44, {0, 0, 0}, "同期合闸禁止"},
+
+    // 自动解列
+    {0xD4, {EV_PARA_Uab, EV_PARA_Ubc, EV_PARA_Uca}, "解列充电完成"},
+    {0xD4, {EV_PARA_Uab, EV_PARA_Ubc, EV_PARA_Uca}, "电压过低解列"},
+    {0xD4, {EV_PARA_Uab, EV_PARA_Ubc, EV_PARA_Uca}, "低电压自动解列"},
+    {0xD4, {EV_PARA_Uab, EV_PARA_Ubc, EV_PARA_Uca}, "高电压自动解列"},
+    {0xD4, {EV_PARA_Uab, EV_PARA_Ubc, EV_PARA_Uca}, "电压过高解列"},
+    {0xD4, {EV_PARA_f, 0, 0}, "频率过低解列"},
+    {0xD4, {EV_PARA_f, 0, 0}, "低频自动解列"},
+    {0xD4, {EV_PARA_f, 0, 0}, "高频自动解列"},
+    {0xD4, {EV_PARA_f, 0, 0}, "频率过高解列"},
+
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+
+    {0x44, {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic}, "遮断电流闭锁"},
+    {0x84, {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic}, "电流重载告警"},
+    // {0x04,        {EV_PARA_Ia,    0,            0},    "Ia重载告警"},
+    // {0x04,        {EV_PARA_Ib,    0,            0},    "Ib重载告警"},
+    // {0x04,        {EV_PARA_Ic,    0,            0},    "Ic重载告警"},
+
+    {0x84, {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic}, "电流过载告警"},
+    // {0x04,        {EV_PARA_Ia,    0,            0},    "Ia过载告警"},
+    // {0x04,        {EV_PARA_Ib,    0,            0},    "Ib过载告警"},
+    // {0x04,        {EV_PARA_Ic,    0,            0},    "Ic过载告警"},
+
+    {0x84, {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic}, "负荷越限告警"},
+    // {0x04,        {EV_PARA_Ia,    0,            0},    "Ia越限告警"},
+    // {0x04,        {EV_PARA_Ib,    0,            0},    "Ib越限告警"},
+    // {0x04,        {EV_PARA_Ic,    0,            0},    "Ic越限告警"},
+    {0x84, {EV_PARA_I0, 0, 0}, "零序电流越限告警"},
+
+    {0x44, {0, 0, 0}, "跳闸失败"},
+    {0x44, {0, 0, 0}, "合闸失败"},
+    {0x44, {0, 0, 0}, "开关拒动"},
+
+    {0x04, {0, 0, 0}, "跳位有流告警"},
+
+    {0x84, {EV_PARA_I0, EV_PARA_U0, 0}, "小电流接地启动"},
+    {0x05, {EV_PARA_U0, 0, 0}, "小电流零压1告警"},
+    {0x05, {EV_PARA_U0, 0, 0}, "小电流零压2告警"},
+    {0x84, {EV_PARA_I0, EV_PARA_U0, 0}, "接地故障总"},
+    {0x0, {EV_PARA_Ia, 0, 0}, "A相接地故障"},
+    {0x0, {EV_PARA_Ib, 0, 0}, "B相接地故障"},
+    {0x0, {EV_PARA_Ic, 0, 0}, "C相接地故障"},
 #if defined FUN_JDXX
-	{0xC4,		{0, 0, 0}, "小电流接地区内告警"},	
-	{0xC4,		{0, 0, 0}, "小电流接地区内跳闸"},
-	{0x84,		{0, 0, 0}, "小电流接地区外故障"},
+    {0xC4, {0, 0, 0}, "小电流接地区内告警"},
+    {0xC4, {0, 0, 0}, "小电流接地区内跳闸"},
+    {0x84, {0, 0, 0}, "小电流接地区外故障"},
 #elif defined XDL_ZT
-	{0x84,		{EV_PARA_I0,	EV_PARA_U0,	0}, "小电流接地动作"},
-	{0x84,		{EV_PARA_I0,	EV_PARA_U0,	0}, "小电流接地告警"},
+    {0x84, {EV_PARA_I0, EV_PARA_U0, 0}, "小电流接地动作"},
+    {0x84, {EV_PARA_I0, EV_PARA_U0, 0}, "小电流接地告警"},
 #endif
 
-#ifdef YB_STHD_CHECK
-	{0x47,		{0,        0,        0},    "功能总压板不一致"},    
-	{0x47,		{0,        0,        0},    "重合闸压板不一致"},	
-	{0x47,		{0,        0,        0},    "分布式压板不一致"},
-	{0x47,		{0,        0,        0},    "就地FA压板不一致"},
-	{0x47,		{0,        0,        0},    "常规保护压板不一致"},
-#endif
-
-	{0x05,		{0,        0,        0},    "未储能告警"},
-	{0x45,		{0,        0,        0},    "控制回路异常"},
-
-	{0x05,		{0,        0,        0},    "M侧节点故障01"},
-	{0x05,		{0,        0,        0},    "M侧节点故障02"},
-	{0x05,		{0,        0,        0},    "M侧节点故障03"},
-	{0x05,		{0,        0,        0},    "M侧节点故障04"},
-	{0x05,		{0,        0,        0},    "M侧节点故障05"},
-	{0x05,		{0,        0,        0},    "M侧节点故障06"},
-	{0x05,		{0,        0,        0},    "M侧节点故障07"},
-	{0x05,		{0,        0,        0},    "M侧节点故障08"},
-
-	{0x05,		{0,        0,        0},    "N侧节点故障01"},
-	{0x05,		{0,        0,        0},    "N侧节点故障02"},
-	{0x05,		{0,        0,        0},    "N侧节点故障03"},
-	{0x05,		{0,        0,        0},    "N侧节点故障04"},
-
-	{0x05,		{0,        0,        0},    "M侧故障隔离成功01"},
-	{0x05,		{0,        0,        0},    "M侧故障隔离成功02"},
-	{0x05,		{0,        0,        0},    "M侧故障隔离成功03"},
-	{0x05,		{0,        0,        0},    "M侧故障隔离成功04"},
-	{0x05,		{0,        0,        0},    "M侧故障隔离成功05"},
-	{0x05,		{0,        0,        0},    "M侧故障隔离成功06"},
-	{0x05,		{0,        0,        0},    "M侧故障隔离成功07"},
-	{0x05,		{0,        0,        0},    "M侧故障隔离成功08"},
-	{0x05,		{0,        0,        0},    "N侧故障隔离成功01"},
-	{0x05,		{0,        0,        0},    "N侧故障隔离成功02"},
-	{0x05,		{0,        0,        0},    "N侧故障隔离成功03"},
-	{0x05,		{0,        0,        0},    "N侧故障隔离成功04"},
-	
-	{0x05,		{0,        0,        0},    "M侧开关拒跳01"},
-	{0x05,		{0,        0,        0},    "M侧开关拒跳02"},
-	{0x05,		{0,        0,        0},    "M侧开关拒跳03"},
-	{0x05,		{0,        0,        0},    "M侧开关拒跳04"},
-	{0x05,		{0,        0,        0},    "M侧开关拒跳05"},
-	{0x05,		{0,        0,        0},    "馈线开关拒跳01"},
-	{0x05,		{0,        0,        0},    "馈线开关拒跳02"},
-	{0x05,		{0,        0,        0},    "馈线开关拒跳03"},
-	{0x05,		{0,        0,        0},    "N侧开关拒跳01"},
-	{0x05,		{0,        0,        0},    "N侧开关拒跳02"},
-	{0x05,		{0,        0,        0},    "N侧开关拒跳03"},
-	{0x05,		{0,        0,        0},    "馈线开关拒跳04"},
-	
-
-	{0x05,		{0,        0,        0},    "馈线开关过流闭锁01"},
-	{0x05,		{0,        0,        0},    "馈线开关过流闭锁02"},
-	{0x05,		{0,        0,        0},    "馈线开关过流闭锁03"},
-	{0x05,		{0,        0,        0},    "馈线开关过流闭锁04"},
-	{0x05,		{0,        0,        0},    "馈线开关过流闭锁05"},
-	{0x05,		{0,        0,        0},    "馈线开关过流闭锁06"},	
-	{0x05,		{0,        0,        0},    "馈线开关过流闭锁07"},
-	{0x05,		{0,        0,        0},    "馈线开关过流闭锁08"},
-	{0x05,		{0,        0,        0},    "馈线开关过流闭锁09"},
-	{0x05,		{0,        0,        0},    "馈线开关过流闭锁10"},
-	{0x05,		{0,        0,        0},    "馈线开关过流闭锁11"},
-	{0x05,		{0,        0,        0},    "馈线开关过流闭锁12"},	
-	
-	{0x85,		{0,        0,        0},    "CT断线"},
-	{0x85,		{0,        0,        0},    "CT相序异常"},
+    {0x05, {0, 0, 0}, "未储能告警"},
+    {0x45, {0, 0, 0}, "控制回路异常"},
 
-	{0x44,		{0,        0,        0},    "自转电功能投入"},
-	{0x44,		{0,        0,        0},    "分布式供电恢复未满足"},
-	{0x44,		{0,        0,        0},    "分布式故障闭锁合闸"},
-	{0x44,		{0,        0,        0},    "分布式分闸闭锁合闸"},
-	{0xC4,		{EV_PARA_U0,	EV_PARA_I0,	0}, "合后零序电压告警"},
+    {0x85, {0, 0, 0}, "CT断线"},
+    {0x85, {0, 0, 0}, "CT相序异常"},
+    {0x85, {0, 0, 0}, "线路断线告警"},
 
 #ifdef FUNC_DRIVE
-	{0x04,		{0,        0,        0},    "不停电传动软压板"},
-	{0x04,		{0,        0,        0},    "传动开始"},
-	{0x04,		{0,        0,        0},    "传动跳闸失败"},
-	{0x04,		{0,        0,        0},    "传动合闸失败"},
+    {0x04, {0, 0, 0}, "传动开始"},
+    {0x04, {0, 0, 0}, "传动跳闸失败"},
+    {0x04, {0, 0, 0}, "传动合闸失败"},
 #endif
 
 #ifdef FUNC_DRIVE_JY
-	{0x04,		{0,        0,        0},    "不停电传动启动失败"},
-	{0x04,		{0,        0,        0},    "不停电传动成功"},
-	{0x04,		{0,        0,        0},    "不停电传动开关拒分"},
-	{0x04,		{0,        0,        0},    "不停电传动开关拒合"},
-	{0x04,		{0,        0,        0},    "不停电传动投退异常"},
-	{0x04,		{0,        0,        0},    "传动补发合闸"},
-	{0x04,		{0,        0,        0},    "不停电传动结束"},
-#endif
-#ifdef FUNC_YL_FZ_SOE
-	{0x44,		{0,        0,        0},    "联络Y闭锁"},
-#endif
-	
-#ifdef	CUSTOMIZE_BZT //备自投
-	{0x44,		{0,        0,        0},    "1#开关自投跳闸"	},
-	{0x44,		{0,        0,        0},    "2#开关自投跳闸"	},
-	{0x44,		{0,        0,        0},    "3#开关自投跳闸"	},
-
-	{0x44,		{0,        0,        0},    "1#开关自投合闸"	},
-	{0x44,		{0,        0,        0},    "2#开关自投合闸"	},
-	{0x44,		{0,        0,        0},    "3#开关自投合闸"	},
-
-	{0x44,		{0,        0,        0},    "1#开关跳闸失败"	},
-	{0x44,		{0,        0,        0},    "2#开关跳闸失败"	},
-	{0x44,		{0,        0,        0},    "3#开关跳闸失败"	},
-	
-	{0x44,		{0,        0,        0},    "1#开关合闸失败"	},
-	{0x44,		{0,        0,        0},    "2#开关合闸失败"	},
-	{0x44,		{0,        0,        0},    "3#开关合闸失败"	},
-#endif	
-
-
-
-	// 公共事件
-	{0x04,		{EV_PARA_Uab,	0,			0}, "Uab1过电压告警"},
-	{0x04,		{EV_PARA_Ubc,	0,			0}, "Ubc1过电压告警"},
-	{0x04,		{EV_PARA_Uca,	0,			0}, "Uca1过电压告警"},
-	{0x04,		{EV_PARA_Uab,	0,			0}, "Uab1低电压告警"},
-	{0x04,		{EV_PARA_Ubc,	0,			0}, "Ubc1低电压告警"},
-	{0x04,		{EV_PARA_Uca,	0,			0}, "Uca1低电压告警"},	
-	{0x04,		{EV_PARA_Uab,	0,			0}, "Uab2过电压告警"},
-	{0x04,		{EV_PARA_Ubc,	0,			0}, "Ubc2过电压告警"},
-	{0x04,		{EV_PARA_Uca,	0,			0}, "Uca2过电压告警"},
-	{0x04,		{EV_PARA_Uab,	0,			0}, "Uab2低电压告警"},
-	{0x04,		{EV_PARA_Ubc,	0,			0}, "Ubc2低电压告警"},
-	{0x04,		{EV_PARA_Uca,	0,			0}, "Uca2低电压告警"},
-    {0x04,		{EV_PARA_Us1,	0,			0}, "A侧有压"},
-    {0x04,		{EV_PARA_Us2,	0,			0}, "B侧有压"}, 
-    {0x04,		{EV_PARA_Us1,	0,			0}, "A侧无压"},
-    {0x04,		{EV_PARA_Us2,	0,			0}, "B侧无压"},
-
-	{0x85,		{0,        0,        0},        "电源模块状态"},	
-#ifdef BATTERY_WITH_COMM
-	#ifdef FUNC_SEL_BAT_MODULE	
-		{0x04,		{0,        0,        0}, 				"电池过压告警"},	
-		{0x04,		{0,        0,        0}, 				"电池离线告警"},
-		{0x04,		{0,        0,        0}, 				"电池反接告警"},	
-		{0x04,		{0,        0,        0}, 				"备用输入交流失电"},
-		{0x04,		{0,        0,        0}, 				"电池容量故障"},	
-	#endif
-	{0x04,		{0,        0,        0},    "电池活化状态"},
-	{0x04,		{0,        0,        0},    "交流失电信号"},
+    {0x04, {0, 0, 0}, "不停电传动启动失败"},
+    {0x04, {0, 0, 0}, "不停电传动成功"},
+    {0x04, {0, 0, 0}, "不停电传动开关拒分"},
+    {0x04, {0, 0, 0}, "不停电传动开关拒合"},
+    {0x04, {0, 0, 0}, "不停电传动投退异常"},
+    {0x04, {0, 0, 0}, "传动补发合闸"},
+    {0x04, {0, 0, 0}, "不停电传动结束"},
 #endif
 
-	{0x44,		{EV_PARA_Uab,	EV_PARA_Ubc,			EV_PARA_Uca},				"PT1断线"},
-	{0x44,		{EV_PARA_Uab,	EV_PARA_Ubc,			EV_PARA_Uca},				"PT2断线"},
-	{0x04,		{0,	0,			0},				"PT1相序异常"},
-	{0x04,		{0,	0,			0},				"PT2相序异常"},
-
-	{0x04,		{0,        0,        0},    "电池电压低"},
-	{0x04,		{0,        0,        0},    "电池电压高"},
-	{0x04,		{0,        0,        0},    "DC1低电压告警"},
-	{0x04,		{0,        0,        0},    "DC2低电压告警"},
-#ifdef	CUSTOMIZE_BZT //备自投	
-    {0x04,		{EV_PARA_Us1,	EV_PARA_Us2,0}, 		"备自投失电分闸"},
+#ifdef CUSTOMIZE_BZT // 备自投
+    {0x44, {0, 0, 0}, "1#开关自投跳闸"},
+    {0x44, {0, 0, 0}, "2#开关自投跳闸"},
+    {0x44, {0, 0, 0}, "3#开关自投跳闸"},
+
+    {0x44, {0, 0, 0}, "1#开关自投合闸"},
+    {0x44, {0, 0, 0}, "2#开关自投合闸"},
+    {0x44, {0, 0, 0}, "3#开关自投合闸"},
+
+    {0x44, {0, 0, 0}, "1#开关跳闸失败"},
+    {0x44, {0, 0, 0}, "2#开关跳闸失败"},
+    {0x44, {0, 0, 0}, "3#开关跳闸失败"},
+
+    {0x44, {0, 0, 0}, "1#开关合闸失败"},
+    {0x44, {0, 0, 0}, "2#开关合闸失败"},
+    {0x44, {0, 0, 0}, "3#开关合闸失败"},
 #endif
 
-#ifdef METERING_ENERGY
-	{0x04,		{EV_PARA_DD,	0,	0}, 	"电度清零"},
-	{0x04,		{EV_PARA_DD,	EV_PARA_DIR_NUM|0x20,	0}, 	"潮流变化"},
+    {0x04, {0, 0, 0}, "短路故障"},
+    {0x04, {0, 0, 0}, "接地故障"},
+    {0x14, {EV_PARA_Ia, 0, 0}, "A相短路故障"},
+    {0x14, {EV_PARA_Ib, 0, 0}, "B相短路故障"},
+    {0x14, {EV_PARA_Ic, 0, 0}, "C相短路故障"},
+    {0x14, {EV_PARA_Ia, EV_PARA_Ib, 0}, "AB相短路故障"},
+    {0x14, {EV_PARA_Ib, EV_PARA_Ic, 0}, "BC相短路故障"},
+    {0x14, {EV_PARA_Ia, EV_PARA_Ic, 0}, "AC相短路故障"},
+    {0x14, {EV_PARA_Ia, EV_PARA_Ib, EV_PARA_Ic}, "ABC相短路故障"},
+
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+
+    {0x00, {0, 0, 0}, "总保护运行"},
+    {0x00, {0, 0, 0}, "常规保护运行"},
+    {0x00, {0, 0, 0}, "重合闸运行"},
+    {0x00, {0, 0, 0}, "FA运行"},
+    {0x00, {0, 0, 0}, "智能分布式运行"},
+    {0x00, {0, 0, 0}, "集中式运行"},
+    {0x00, {0, 0, 0}, "同期合闸运行"},
+    {0x00, {0, 0, 0}, "自动解列运行"},
+    {0x00, {0, 0, 0}, "小电流接地运行"},
+    {0x00, {0, 0, 0}, "线路断线告警运行"},
+    {0x00, {0, 0, 0}, "不停电传动运行"},
+    {0x00, {0, 0, 0}, "功能模式异常"},
+
+    {0x00, {0, 0, 0}, "常规保护压板"},
+    {0x00, {0, 0, 0}, "自动重合闸压板"},
+    {0x00, {0, 0, 0}, "停用重合闸压板"},
+    {0x00, {0, 0, 0}, "就地馈线自动化压板"},
+    {0x00, {0, 0, 0}, "智能分布式压板"},
+    {0x00, {0, 0, 0}, "集中式压板"},
+    {0x00, {0, 0, 0}, "同期合闸压板"},
+    {0x00, {0, 0, 0}, "自动解列压板"},
+    {0x00, {0, 0, 0}, "小电流接地压板"},
+    {0x00, {0, 0, 0}, "线路断线告警压板"},
+    {0x00, {0, 0, 0}, "不停电传动压板"},
+    {0x00, {0, 0, 0}, "功能总投退压板"},
+    {0x00, {0, 0, 0}, "功能总出口压板"},
+    {0x00, {0, 0, 0}, "重合闸软压板"},
+    {0x00, {0, 0, 0}, "远程运维压板"},
+
+    {0x00, {0, 0, 0}, "过流一段投入"},
+    {0x00, {0, 0, 0}, "过流二段投入"},
+    {0x00, {0, 0, 0}, "过流三段投入"},
+    {0x00, {0, 0, 0}, "过流一段方向投入"},
+    {0x00, {0, 0, 0}, "过流二段方向投入"},
+    {0x00, {0, 0, 0}, "过流三段方向投入"},
+    {0x00, {0, 0, 0}, "零流一段投入"},
+    {0x00, {0, 0, 0}, "零流二段投入"},
+    {0x00, {0, 0, 0}, "零流三段投入"},
+    {0x00, {0, 0, 0}, "PT断线投入"},
+    {0x00, {0, 0, 0}, "后加速投入"},
+    {0x00, {0, 0, 0}, "过流启动重合投入"},
+    {0x00, {0, 0, 0}, "零流启动重合投入"},
+    {0x00, {0, 0, 0}, "涌流识别投入"},
+    {0x00, {0, 0, 0}, "零压保护投入"},
+    {0x00, {0, 0, 0}, "一次重合闸投入"},
+    {0x00, {0, 0, 0}, "二次重合闸投入"},
+    {0x00, {0, 0, 0}, "重合闸检同期投入"},
+    {0x00, {0, 0, 0}, "重合闸检无压投入"},
+    {0x00, {0, 0, 0}, "大电流闭锁重合投入"},
+    {0x00, {0, 0, 0}, "分段联络模式"},
+    {0x00, {0, 0, 0}, "A侧得电延时合投入"},
+    {0x00, {0, 0, 0}, "B侧得电延时合投入"},
+    {0x00, {0, 0, 0}, "A侧失电延时合投入"},
+    {0x00, {0, 0, 0}, "B侧失电延时合投入"},
+    {0x00, {0, 0, 0}, "合到故障快速分投入"},
+    {0x00, {0, 0, 0}, "合成功闭锁失压分"},
+    {0x00, {0, 0, 0}, "FA过流告警投入"},
+    {0x00, {0, 0, 0}, "FA接地告警投入"},
+    {0x00, {0, 0, 0}, "合到零序电压保护"},
+    {0x00, {0, 0, 0}, "非遮断投入"},
+    {0x00, {0, 0, 0}, "PT断线投入"},
+    {0x00, {0, 0, 0}, "多次失压分闭锁合"},
+    {0x00, {0, 0, 0}, "涌流闭锁投入"},
+    {0x00, {0, 0, 0}, "硬件残压模快投入"},
+    {0x00, {0, 0, 0}, "分布式FA方式"},
+    {0x00, {0, 0, 0}, "联络自投投入"},
+    {0x00, {0, 0, 0}, "过载闭锁自投投入"},
+    {0x00, {0, 0, 0}, "首开关失压保护投入"},
+    {0x00, {0, 0, 0}, "智能分布式启动重合"},
+    {0x00, {0, 0, 0}, "电压解列投入"},
+    {0x00, {0, 0, 0}, "电压滑差闭锁"},
+    {0x00, {0, 0, 0}, "频率解列投入"},
+    {0x00, {0, 0, 0}, "频率滑差闭锁"},
+    {0x00, {0, 0, 0}, "小电流接地投入"},
+    {0x00, {0, 0, 0}, "小电流接地启动重合"},
+    {0x00, {0, 0, 0}, "小电流接地后加速"},
+
+#ifdef YB_STHD_CHECK
+    {0x47, {0, 0, 0}, "功能总压板不一致"},
+    {0x47, {0, 0, 0}, "重合闸压板不一致"},
+    {0x47, {0, 0, 0}, "分布式压板不一致"},
+    {0x47, {0, 0, 0}, "就地FA压板不一致"},
+    {0x47, {0, 0, 0}, "常规保护压板不一致"},
 #endif
 
-	{0x05,		{0,        0,        0},    "板卡故障"},
-	{0x05,		{0,        0,        0},    "板卡通信异常"},
-	{0x05,		{0,        0,        0},    "面板通信异常"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+
+    // 公共事件
+    {0x00, {0, 0, 0}, "事故总"},
+    {0x05, {0, 0, 0}, "板卡故障"},
+    {0x05, {0, 0, 0}, "板卡通信异常"},
+    {0x05, {0, 0, 0}, "面板通信异常"},
 
 #if defined CAN_SLAVE_BOARD && defined METERING_ENERGY
-	{0x05,		{EV_PARA_CAN_SLOT|0x20, 	0,	0}, 	"线损板通信异常"},
+    {0x05, {EV_PARA_CAN_SLOT | 0x20, 0, 0}, "线损板通信异常"},
 #endif
 
-	{0x04,		{0,        0,        0},    "装置硬件故障"},
-	{0x04,		{0,        0,        0},    "装置软件故障"},
-	{0x45,		{0,        0,        0},    "本机goose通信异常"},
-	{0x05,		{0,        0,        0},    "goose数据异常"},
-	{0x45,		{0,        0,        0},    "goose系统通信异常"},
-	{0x05,		{0,        0,        0},    "61850平台库异常"},
+    {0x04, {0, 0, 0}, "装置硬件故障"},
+    {0x04, {0, 0, 0}, "装置软件故障"},
+    {0x45, {0, 0, 0}, "本机goose通信异常"},
+    {0x05, {0, 0, 0}, "goose数据异常"},
+    {0x45, {0, 0, 0}, "goose系统通信异常"},
+    {0x05, {0, 0, 0}, "61850平台库异常"},
 #ifdef GOOSE_NETTYPE_SET
-	{0x45,		{0,        0,        0},    "单网通讯异常NET1"},
-	{0x45,		{0,        0,        0},    "单网通讯异常NET2"},
-	{0x45,		{0,        0,        0},    "N侧通讯异常"},
-	{0x45,		{0,        0,        0},    "M侧通讯异常"},
-	{0x45,		{0,        0,        0},    "Goose网络类型错误"},
+    {0x45, {0, 0, 0}, "单网通讯异常NET1"},
+    {0x45, {0, 0, 0}, "单网通讯异常NET2"},
+    {0x45, {0, 0, 0}, "N侧通讯异常"},
+    {0x45, {0, 0, 0}, "M侧通讯异常"},
+    {0x45, {0, 0, 0}, "Goose网络类型错误"},
 #endif
 #if defined GD_AREA_ZHONGSHAN_2020
-	{0x05,		{0,        0,        0},    "分布式配置异常"},
+    {0x05, {0, 0, 0}, "分布式配置异常"},
 #endif
 
-	{0x00,		{0,        0,        0},    "事故总"},
-	{0x04,		{0,        0,        0},    "电池自动活化投退"},
-	{0x04,		{0,        0,        0},    "备用电源投入"},
-	{0x04,		{0,        0,        0},    "非电量1跳闸"},
-	{0x04,		{0,        0,        0},    "非电量2跳闸"},
-	{0x04,		{0,        0,        0},    "非电量3跳闸"},
-	{0x04,		{0,        0,        0},    "非电量4跳闸"},
-	{0x04,		{0,        0,        0},    "非电量5跳闸"},
-	{0x04,		{0,        0,        0},    "非电量6跳闸"},
-	{0x04,		{0,        0,        0},    "非电量1告警"},
-	{0x04,		{0,        0,        0},    "非电量2告警"},
-	{0x04,		{0,        0,        0},    "非电量3告警"},
-	{0x04,		{0,        0,        0},    "非电量4告警"},	
-	{0x04,		{0,        0,        0},    "非电量5告警"},
-	{0x04,		{0,        0,        0},    "非电量6告警"},
-	{0x04,		{0,        0,        0},    "串口1通信异常"},
-	{0x04,		{0,        0,        0},    "串口2通信异常"},
-	{0x04,		{0,        0,        0},    "串口3通信异常"},
-	{0x04,		{0,        0,        0},    "串口4通信异常"},
-	{0x04,		{0,        0,        0},    "串口5通信异常"},
-	{0x04,		{0,        0,        0},    "串口6通信异常"},
-	{0x04,		{0,        0,        0},    "网络1通信异常"},
-	{0x04,		{0,        0,        0},    "网络2通信异常"},
-
-	{0x04,		{0,        0,        0},    "级联装置1异常"},
-	{0x04,		{0,        0,        0},    "级联装置2异常"},
-	{0x04,		{0,        0,        0},    "级联装置3异常"},
-	{0x04,		{0,        0,        0},    "级联装置4异常"},
-	{0x04,		{0,        0,        0},    "级联装置5异常"},
-	{0x04,		{0,        0,        0},    "级联装置6异常"},
-	{0x04,		{0,        0,        0},    "级联装置7异常"},
-	{0x04,		{0,        0,        0},    "级联装置8异常"},
-	{0x04,		{0,        0,        0},    "级联装置9异常"},
-	{0x04,		{0,        0,        0},    "级联装置10异常"},
-	{0x04,		{0,        0,        0},    "面板合闸"},
-	{0x04,		{0,        0,        0},    "面板分闸"},
-
-#if (1)
-	{0x00,		{0,				0,			0},				"总保护运行"},
-	{0x00,		{0,				0,			0},				"常规保护运行"},
-	{0x00,		{0,				0,			0},				"FA运行"},
-	{0x00,		{0,				0,			0},				"智能分布式运行"},
-	{0x00,		{0,				0,			0},				"集中式运行"},
-	{0x00,		{0,				0,			0},				"重合闸运行"},
-	{0x00,		{0,	            0,          0},				"功能模式异常"},
-
-	{0x00,		{0,				0,			0},				"常规保护压板"},
-	{0x00,		{0,				0,			0},				"自动重合闸压板"},
-	{0x00,		{0,	            0,	        0},			    "停用重合闸压板"},
-	{0x00,		{0,				0,			0},				"就地馈线自动化压板"},
-	{0x00,		{0,				0,			0},				"智能分布式压板"},
-	{0x00,		{0,				0,			0},				"集中式压板"},
-	{0x00,		{0,				0,			0},				"同期合闸压板"},
-	{0x00,		{0,				0,			0},				"自动解列压板"},
-    {0x00,      {0,             0,          0},             "小电流接地压板"},
-    {0x00,      {0,             0,          0},             "线路断线告警压板"},
-    {0x00,      {0,             0,          0},             "不停电传动压板"},
-    {0x00,      {0,             0,          0},             "功能总投退压板"},
-    {0x00,      {0,             0,          0},             "功能总出口压板"},
-    {0x00,      {0,             0,          0},             "重合闸软压板"},
-    {0x00,      {0,             0,          0},             "远程运维压板"},
-
-    {0x00,      {0,             0,          0},             "过流零流告警投入"},
-    {0x00,      {0,             0,          0},             "常规保护跳闸投入"},
-    {0x00,      {0,             0,          0},             "过流一段投入"},
-    {0x00,      {0,             0,          0},             "过流二段投入"},
-    {0x00,      {0,             0,          0},             "过流三段投入"},
-    {0x00,      {0,             0,          0},             "过流一段方向投入"},
-    {0x00,      {0,             0,          0},             "过流二段方向投入"},
-    {0x00,      {0,             0,          0},             "过流三段方向投入"},
-    {0x00,      {0,             0,          0},             "零流一段投入"},
-    {0x00,      {0,             0,          0},             "零流二段投入"},
-    {0x00,      {0,             0,          0},             "零流三段投入"},
-    {0x00,      {0,             0,          0},             "PT断线投入"},
-    {0x00,      {0,             0,          0},             "后加速投入"},
-    {0x00,      {0,             0,          0},             "过流启动重合投入"},
-    {0x00,      {0,             0,          0},             "零流启动重合投入"},
-    {0x00,      {0,             0,          0},             "涌流识别投入"},
-    {0x00,      {0,             0,          0},             "零压保护投入"},
-    {0x00,      {0,             0,          0},             "一次重合闸投入"},
-    {0x00,      {0,             0,          0},             "二次重合闸投入"},
-    {0x00,      {0,             0,          0},             "重合闸检同期投入"},
-    {0x00,      {0,             0,          0},             "重合闸检无压投入"},
-    {0x00,      {0,             0,          0},             "大电流闭锁重合投入"},
-	{0x00,		{0,	            0,          0},				"分段联络模式"},
-    {0x00,      {0,             0,          0},             "A侧得电延时合投入"},
-    {0x00,      {0,             0,          0},             "B侧得电延时合投入"},
-    {0x00,      {0,             0,          0},             "A侧失电延时合投入"},
-    {0x00,      {0,             0,          0},             "B侧失电延时合投入"},
-    {0x00,      {0,             0,          0},             "合到故障快速分投入"},
-    {0x00,      {0,             0,          0},             "合成功闭锁失压分"},
-    {0x00,      {0,             0,          0},             "FA过流告警投入"},
-    {0x00,      {0,             0,          0},             "FA接地告警投入"},
-    {0x00,      {0,             0,          0},             "合到零序电压保护"},
-    {0x00,      {0,             0,          0},             "非遮断投入"},
-    {0x00,      {0,             0,          0},             "PT断线投入"},
-    {0x00,      {0,             0,          0},             "多次失压分闭锁合"},
-    {0x00,      {0,             0,          0},             "涌流闭锁投入"},
-    {0x00,      {0,             0,          0},             "硬件残压模快投入"},
-    {0x00,      {0,             0,          0},             "分布式FA方式"},
-    {0x00,      {0,             0,          0},             "联络自投投入"},
-    {0x00,      {0,             0,          0},             "过载闭锁自投投入"},
-    {0x00,      {0,             0,          0},             "首开关失压保护投入"},
-    {0x00,      {0,             0,          0},             "智能分布式启动重合"},
-    {0x00,      {0,             0,          0},             "电压解列投入"},
-    {0x00,      {0,             0,          0},             "电压滑差闭锁"},
-    {0x00,      {0,             0,          0},             "频率解列投入"},
-    {0x00,      {0,             0,          0},             "频率滑差闭锁"},
-    {0x00,      {0,             0,          0},             "小电流接地投入"},
-    {0x00,      {0,             0,          0},             "小电流接地启动重合"},
-    {0x00,      {0,             0,          0},             "小电流接地后加速"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+
+    {0x04, {EV_PARA_Uab, 0, 0}, "Uab1过电压告警"},
+    {0x04, {EV_PARA_Ubc, 0, 0}, "Ubc1过电压告警"},
+    {0x04, {EV_PARA_Uca, 0, 0}, "Uca1过电压告警"},
+    {0x04, {EV_PARA_Uab, 0, 0}, "Uab1低电压告警"},
+    {0x04, {EV_PARA_Ubc, 0, 0}, "Ubc1低电压告警"},
+    {0x04, {EV_PARA_Uca, 0, 0}, "Uca1低电压告警"},
+    {0x04, {EV_PARA_Uab, 0, 0}, "Uab2过电压告警"},
+    {0x04, {EV_PARA_Ubc, 0, 0}, "Ubc2过电压告警"},
+    {0x04, {EV_PARA_Uca, 0, 0}, "Uca2过电压告警"},
+    {0x04, {EV_PARA_Uab, 0, 0}, "Uab2低电压告警"},
+    {0x04, {EV_PARA_Ubc, 0, 0}, "Ubc2低电压告警"},
+    {0x04, {EV_PARA_Uca, 0, 0}, "Uca2低电压告警"},
+    {0x04, {EV_PARA_Us1, 0, 0}, "A侧有压"},
+    {0x04, {EV_PARA_Us2, 0, 0}, "B侧有压"},
+    {0x04, {EV_PARA_Us1, 0, 0}, "A侧无压"},
+    {0x04, {EV_PARA_Us2, 0, 0}, "B侧无压"},
+
+    {0x85, {0, 0, 0}, "电源模块状态"},
+#ifdef BATTERY_WITH_COMM
+#ifdef FUNC_SEL_BAT_MODULE
+    {0x04, {0, 0, 0}, "电池过压告警"},
+    {0x04, {0, 0, 0}, "电池离线告警"},
+    {0x04, {0, 0, 0}, "电池反接告警"},
+    {0x04, {0, 0, 0}, "备用输入交流失电"},
+    {0x04, {0, 0, 0}, "电池容量故障"},
+#endif
+    {0x04, {0, 0, 0}, "电池活化状态"},
+    {0x04, {0, 0, 0}, "交流失电信号"},
 #endif
 
-	
-/*下面不需要上送后台的操作或提示类的信息*/
-
-	{0x00,		{0,        0,        0},    "装置上电"},
-	/*装置状态切换*/
-	{0x00,		{0,        0,        0},    "进入测试模式"},
-	{0x00,		{0,        0,        0},    "进入运行模式"},
-
-	/*通道校正记录*/
-	{0x00,		{0,        0,        0},    "幅值手校成功"},
-	{0x00,		{0,        0,        0},    "角度手校成功"},
-	{0x00,		{0,        0,        0},    "通道自校成功"},
-
-	/*遥控操作类*/
-	{0x40,		{PARA_TYPE_YK|EV_PARA_YK,	PARA_TYPE_YK|EV_PARA_YK,	0},		"遥控合闸预置成功"},
-	{0x40,		{PARA_TYPE_YK|EV_PARA_YK,	PARA_TYPE_YK|EV_PARA_YK,	0},		"遥控合闸预置失败"},
-	{0x40,		{PARA_TYPE_YK|EV_PARA_YK,	PARA_TYPE_YK|EV_PARA_YK,	0},		"遥控合闸预置超时"},
-	{0x44,		{PARA_TYPE_YK|EV_PARA_YK,	PARA_TYPE_YK|EV_PARA_YK,	0},		"遥控合闸执行成功"},
-	{0x44,		{PARA_TYPE_YK|EV_PARA_YK,	PARA_TYPE_YK|EV_PARA_YK,	0},		"遥控合闸执行失败"},	
-	{0x40,		{PARA_TYPE_YK|EV_PARA_YK,	PARA_TYPE_YK|EV_PARA_YK,	0},		"遥控合闸终止"},
-	
-	{0x40,		{PARA_TYPE_YK|EV_PARA_YK,	PARA_TYPE_YK|EV_PARA_YK,	0},		"遥控分闸预置成功"},
-	{0x40,		{PARA_TYPE_YK|EV_PARA_YK,	PARA_TYPE_YK|EV_PARA_YK,	0},		"遥控分闸预置失败"},	
-	{0x40,		{PARA_TYPE_YK|EV_PARA_YK,	PARA_TYPE_YK|EV_PARA_YK,	0},		"遥控分闸预置超时"},
-	{0x44,		{PARA_TYPE_YK|EV_PARA_YK,	PARA_TYPE_YK|EV_PARA_YK,	0},		"遥控分闸执行成功"},
-	{0x44,		{PARA_TYPE_YK|EV_PARA_YK,	PARA_TYPE_YK|EV_PARA_YK,	0},		"遥控分闸执行失败"},
-	{0x40,		{PARA_TYPE_YK|EV_PARA_YK,	PARA_TYPE_YK|EV_PARA_YK,	0},		"遥控分闸终止"},
-	/*遥控操作类*/
-	{0x00,		{PARA_TYPE_YK|EV_PARA_YK,	PARA_TYPE_YK|EV_PARA_YK,	0},		"PLC合"},
-	{0x00,		{PARA_TYPE_YK|EV_PARA_YK,	PARA_TYPE_YK|EV_PARA_YK,	0},		"PLC分"},
-
-	{0x04,		{0,        0,        0},    "手动合闸"},
-	{0x04,		{0,        0,        0},    "手动分闸"},
-	{0x04,		{0,        0,        0},    "无线遥控合闸"},
-	{0x04,		{0,        0,        0},    "无线遥控分闸"},
-	{0x04,		{0,        0,        0},    "PDA遥控合闸"},
-	{0x04,		{0,        0,        0},    "PDA遥控分闸"},
-	{0x04,		{0,        0,        0},    "短信合闸"},
-	{0x04,		{0,        0,        0},    "短信分闸"},
-
-	{0x04,		{0,        0,        0},    "电池自动活化"},
-	{0x04,		{0,        0,        0},    "电池活化启动"},
-	{0x04,		{0,        0,        0},    "电池活化退出"},
-	{0x04,		{0,        0,        0},    "电池手动退出"},
-
-	/*定值操作类*/
-	{0x00,		{0,        0,        0},    "定值整定成功"},
-	{0x00,		{0,        0,        0},    "定值整定失败"},
-	{0x00,		{0,        0,        0},    "公共定值整定成功"},
-	{0x00,		{0,        0,        0},    "公共定值整定失败"},
-	{0x00,		{0,        0,        0},    "软压板整定成功"},
-	{0x00,		{0,        0,        0},    "软压板整定失败"},
-	{0x00,		{0,        0,        0},    "内部定值成功"},
-	{0x00,		{0,        0,        0},    "内部定值失败"},
-
-	{0x00,		{0,        0,        0},    "RTC内存初始化"},
-	/*参数操作*/
-	{0x00,		{0,        0,        0},    "参数整定成功"},
-	{0x00,		{0,        0,        0},    "参数整定失败"},
-	{0x00,		{0,        0,        0},    "信号复归"},
-	{0x00,		{0,        0,        0},    "事件记录清除"},
-	{0x00,		{0,        0,        0},    "操作记录清除"},
-	{0x00,		{0,        0,        0},    "恢复出厂设置"},
-	{0x00,		{0,        0,        0},    "录波溢出"},
-	{0x00,		{0,        0,        0}, 	"定值修改"},
-#if defined(CPU_AM335X) 
-	{0x00,		{0,        0,        0}, 	"恢复APP分区"},
-#endif	
-};
+    {0x44, {EV_PARA_Uab, EV_PARA_Ubc, EV_PARA_Uca}, "PT1断线"},
+    {0x44, {EV_PARA_Uab, EV_PARA_Ubc, EV_PARA_Uca}, "PT2断线"},
+    {0x04, {0, 0, 0}, "PT1相序异常"},
+    {0x04, {0, 0, 0}, "PT2相序异常"},
+
+    {0x04, {0, 0, 0}, "电池电压低"},
+    {0x04, {0, 0, 0}, "电池电压高"},
+    {0x04, {0, 0, 0}, "DC1低电压告警"},
+    {0x04, {0, 0, 0}, "DC2低电压告警"},
+#ifdef CUSTOMIZE_BZT // 备自投
+    {0x04, {EV_PARA_Us1, EV_PARA_Us2, 0}, "备自投失电分闸"},
+#endif
 
+#ifdef METERING_ENERGY
+    {0x04, {EV_PARA_DD, 0, 0}, "电度清零"},
+    {0x04, {EV_PARA_DD, EV_PARA_DIR_NUM | 0x20, 0}, "潮流变化"},
+#endif
+
+    {0x04, {0, 0, 0}, "电池自动活化投退"},
+    {0x04, {0, 0, 0}, "备用电源投入"},
+    {0x04, {0, 0, 0}, "非电量1跳闸"},
+    {0x04, {0, 0, 0}, "非电量2跳闸"},
+    {0x04, {0, 0, 0}, "非电量3跳闸"},
+    {0x04, {0, 0, 0}, "非电量4跳闸"},
+    {0x04, {0, 0, 0}, "非电量5跳闸"},
+    {0x04, {0, 0, 0}, "非电量6跳闸"},
+    {0x04, {0, 0, 0}, "非电量1告警"},
+    {0x04, {0, 0, 0}, "非电量2告警"},
+    {0x04, {0, 0, 0}, "非电量3告警"},
+    {0x04, {0, 0, 0}, "非电量4告警"},
+    {0x04, {0, 0, 0}, "非电量5告警"},
+    {0x04, {0, 0, 0}, "非电量6告警"},
+    {0x04, {0, 0, 0}, "串口1通信异常"},
+    {0x04, {0, 0, 0}, "串口2通信异常"},
+    {0x04, {0, 0, 0}, "串口3通信异常"},
+    {0x04, {0, 0, 0}, "串口4通信异常"},
+    {0x04, {0, 0, 0}, "串口5通信异常"},
+    {0x04, {0, 0, 0}, "串口6通信异常"},
+    {0x04, {0, 0, 0}, "网络1通信异常"},
+    {0x04, {0, 0, 0}, "网络2通信异常"},
+    {0x04, {0, 0, 0}, "网络3通信异常"},
+
+    {0x04, {0, 0, 0}, "级联装置1异常"},
+    {0x04, {0, 0, 0}, "级联装置2异常"},
+    {0x04, {0, 0, 0}, "级联装置3异常"},
+    {0x04, {0, 0, 0}, "级联装置4异常"},
+    {0x04, {0, 0, 0}, "级联装置5异常"},
+    {0x04, {0, 0, 0}, "级联装置6异常"},
+    {0x04, {0, 0, 0}, "级联装置7异常"},
+    {0x04, {0, 0, 0}, "级联装置8异常"},
+    {0x04, {0, 0, 0}, "级联装置9异常"},
+    {0x04, {0, 0, 0}, "级联装置10异常"},
+    {0x04, {0, 0, 0}, "面板合闸"},
+    {0x04, {0, 0, 0}, "面板分闸"},
+
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+    {0x04, {0, 0, 0}, "备用"},
+
+    /*下面不需要上送后台的操作或提示类的信息*/
+
+    {0x00, {0, 0, 0}, "装置上电"},
+    /*装置状态切换*/
+    {0x00, {0, 0, 0}, "进入测试模式"},
+    {0x00, {0, 0, 0}, "进入运行模式"},
+
+    /*通道校正记录*/
+    {0x00, {0, 0, 0}, "幅值手校成功"},
+    {0x00, {0, 0, 0}, "角度手校成功"},
+    {0x00, {0, 0, 0}, "通道自校成功"},
+
+    /*遥控操作类*/
+    {0x40, {PARA_TYPE_YK | EV_PARA_YK, PARA_TYPE_YK | EV_PARA_YK, 0}, "遥控合闸预置成功"},
+    {0x40, {PARA_TYPE_YK | EV_PARA_YK, PARA_TYPE_YK | EV_PARA_YK, 0}, "遥控合闸预置失败"},
+    {0x40, {PARA_TYPE_YK | EV_PARA_YK, PARA_TYPE_YK | EV_PARA_YK, 0}, "遥控合闸预置超时"},
+    {0x44, {PARA_TYPE_YK | EV_PARA_YK, PARA_TYPE_YK | EV_PARA_YK, 0}, "遥控合闸执行成功"},
+    {0x44, {PARA_TYPE_YK | EV_PARA_YK, PARA_TYPE_YK | EV_PARA_YK, 0}, "遥控合闸执行失败"},
+    {0x40, {PARA_TYPE_YK | EV_PARA_YK, PARA_TYPE_YK | EV_PARA_YK, 0}, "遥控合闸终止"},
+
+    {0x40, {PARA_TYPE_YK | EV_PARA_YK, PARA_TYPE_YK | EV_PARA_YK, 0}, "遥控分闸预置成功"},
+    {0x40, {PARA_TYPE_YK | EV_PARA_YK, PARA_TYPE_YK | EV_PARA_YK, 0}, "遥控分闸预置失败"},
+    {0x40, {PARA_TYPE_YK | EV_PARA_YK, PARA_TYPE_YK | EV_PARA_YK, 0}, "遥控分闸预置超时"},
+    {0x44, {PARA_TYPE_YK | EV_PARA_YK, PARA_TYPE_YK | EV_PARA_YK, 0}, "遥控分闸执行成功"},
+    {0x44, {PARA_TYPE_YK | EV_PARA_YK, PARA_TYPE_YK | EV_PARA_YK, 0}, "遥控分闸执行失败"},
+    {0x40, {PARA_TYPE_YK | EV_PARA_YK, PARA_TYPE_YK | EV_PARA_YK, 0}, "遥控分闸终止"},
+    /*遥控操作类*/
+    {0x00, {PARA_TYPE_YK | EV_PARA_YK, PARA_TYPE_YK | EV_PARA_YK, 0}, "PLC合"},
+    {0x00, {PARA_TYPE_YK | EV_PARA_YK, PARA_TYPE_YK | EV_PARA_YK, 0}, "PLC分"},
+
+    {0x04, {0, 0, 0}, "手动合闸"},
+    {0x04, {0, 0, 0}, "手动分闸"},
+    {0x04, {0, 0, 0}, "无线遥控合闸"},
+    {0x04, {0, 0, 0}, "无线遥控分闸"},
+    {0x04, {0, 0, 0}, "PDA遥控合闸"},
+    {0x04, {0, 0, 0}, "PDA遥控分闸"},
+    {0x04, {0, 0, 0}, "短信合闸"},
+    {0x04, {0, 0, 0}, "短信分闸"},
+
+    {0x04, {0, 0, 0}, "电池自动活化"},
+    {0x04, {0, 0, 0}, "电池活化启动"},
+    {0x04, {0, 0, 0}, "电池活化退出"},
+    {0x04, {0, 0, 0}, "电池手动退出"},
+
+    /*定值操作类*/
+    {0x00, {0, 0, 0}, "定值整定成功"},
+    {0x00, {0, 0, 0}, "定值整定失败"},
+    {0x00, {0, 0, 0}, "公共定值整定成功"},
+    {0x00, {0, 0, 0}, "公共定值整定失败"},
+    {0x00, {0, 0, 0}, "软压板整定成功"},
+    {0x00, {0, 0, 0}, "软压板整定失败"},
+    {0x00, {0, 0, 0}, "内部定值成功"},
+    {0x00, {0, 0, 0}, "内部定值失败"},
+
+    {0x00, {0, 0, 0}, "RTC内存初始化"},
+    /*参数操作*/
+    {0x00, {0, 0, 0}, "参数整定成功"},
+    {0x00, {0, 0, 0}, "参数整定失败"},
+    {0x00, {0, 0, 0}, "信号复归"},
+    {0x00, {0, 0, 0}, "事件记录清除"},
+    {0x00, {0, 0, 0}, "操作记录清除"},
+    {0x00, {0, 0, 0}, "恢复出厂设置"},
+    {0x00, {0, 0, 0}, "录波溢出"},
+    {0x00, {0, 0, 0}, "定值修改"},
+#if defined(CPU_AM335X)
+    {0x00, {0, 0, 0}, "恢复APP分区"},
+#endif
+};
 
 const WORD SOENumber=sizeof(tAllSOE)/sizeof(SOE_DEF);  // 测量值个数
 

dtu/dtu_main_t536/app/Appconfig.h

@@ -126,17 +126,17 @@ enum
 {
     EV_BH_FAULT = 0, // 保护动作总
     EV_ALL_FAULT,    // 故障总
-    EV_GL_FAULT,     // 短路故障
-    EV_LX_FAULT,     // 接地故障
-    EV_IA_GL,        // A相短路故障
-    EV_IB_GL,        // B相短路故障
-    EV_IC_GL,        // C相短路故障
-    EV_IAB_GL,       // AB相短路故障
-    EV_IBC_GL,       // BC相短路故障
-    EV_ICA_GL,       // CA相短路故障
-    EV_IABC_GL,      // ABC相短路故障
-    EV_TYPE_S,       // 分段模式
-    EV_TYPE_L,       // 联络模式
+
+    EV_BK_000, // 备用
+    EV_BK_001, // 备用
+    EV_BK_002, // 备用
+    EV_BK_003, // 备用
+    EV_BK_004, // 备用
+    EV_BK_005, // 备用
+    EV_BK_006, // 备用
+    EV_BK_007, // 备用
+    EV_BK_008, // 备用
+    EV_BK_009, // 备用
 
     EV_GL1TZ, // 过流I段动作
     EV_GL1GJ, // 过流I段告警
@@ -147,10 +147,10 @@ enum
     EV_GL1_IB, // 过流I段B相故障
     EV_GL1_IC, // 过流I段C相故障
 
-    EV_GL2TZ,      // 过流II段动作
-    EV_GL2GJ,      // 过流II段告警
-#ifdef EV_GL_STATR // 过流II段启动
-    EV_GL2_START,  //
+    EV_GL2TZ, // 过流II段动作
+    EV_GL2GJ, // 过流II段告警
+#ifdef EV_GL_STATR
+    EV_GL2_START, // 过流II段启动
 #endif
     EV_GL2_IA, // 过流II段A相短路故障
     EV_GL2_IB, // 过流II段B相短路故障
@@ -182,20 +182,28 @@ enum
     EV_LX3_START, // 零流III段启动
 #endif
 
-    EV_GLJS,      // 过流加速动作
-    EV_LXJS,      // 零序加速动作
-    EV_U0JS,      // 零压加速动作
-    EV_FSXGL,     // 反时限过流动作
-    EV_FA_GL_TZ,  // 合后故障过流I段动作
-    EV_FA_GL_TZ2, // 合后故障过流II段动作
-    EV_FA_LX_TZ,  // 合后故障零序动作
-    EV_FA_GL_GJ,  // 相间过流告警
-    EV_FA_LX_GJ,  // 接地告警
+    EV_GLJS, // 过流加速动作
+    EV_LXJS, // 零序加速动作
+    EV_U0JS, // 零压加速动作
+
+    EV_U0TZ, // 零序电压跳闸
+    EV_U0GJ, // 零序电压告警
 #ifdef EV_GL_STATR
-    EV_FA_GL_START,  // 相间I段启动
-    EV_FA_GL2_START, // 相间II段启动
-    EV_FA_LX_START,  // 接地过流启动
+    EV_U0_STATR, // 零序电压启动
 #endif
+    EV_XBBS,  // 涌流谐波闭锁
+    EV_FSXGL, // 反时限过流动作
+
+    EV_BK_010, // 备用
+    EV_BK_011, // 备用
+    EV_BK_012, // 备用
+    EV_BK_013, // 备用
+    EV_BK_014, // 备用
+    EV_BK_015, // 备用
+    EV_BK_016, // 备用
+    EV_BK_017, // 备用
+    EV_BK_018, // 备用
+    EV_BK_019, // 备用
 
     EV_AR_START,    // 重合闸启动
     EV_AR1,         // 一次重合动作
@@ -206,13 +214,19 @@ enum
     EV_ARCD,        // 重合闸充电完成
     EV_CHZ_TOPEN,   // 终止重合闸过程
 
-    EV_U0TZ, // 零序电压跳闸
-    EV_U0GJ, // 零序电压告警
-#ifdef EV_GL_STATR
-    EV_U0_STATR, // 零序电压启动
-#endif
-    EV_XBBS, // 谐波闭锁
-
+    EV_BK_020, // 备用
+    EV_BK_021, // 备用
+    EV_BK_022, // 备用
+    EV_BK_023, // 备用
+    EV_BK_024, // 备用
+    EV_BK_025, // 备用
+    EV_BK_026, // 备用
+    EV_BK_027, // 备用
+    EV_BK_028, // 备用
+    EV_BK_029, // 备用
+
+    EV_TYPE_S,  // 分段模式
+    EV_TYPE_L,  // 联络模式
     EV_BS_ALL,  // 闭锁合闸
     EV_YY_P,    // 母线侧有压
     EV_YY_L,    // 线路侧有压
@@ -238,7 +252,9 @@ enum
     EV_BSTZ_FA,     // 闭锁失压分闸
     EV_JS_HZ,       // 合闸解锁
     EV_JS_HA,       // 人工解锁
-    EV_JS_POWER,    // 对侧来电解锁
+    EV_JS_TCLD,     // 同侧来电解锁
+    EV_JS_DCLD,     // 对侧来电解锁
+    EV_JS_MZTJ,     // 满足条件解锁
     EV_JS_L,        // 联络有压解锁
     EV_L_LST_T,     // 联络单侧失压时间到
     EV_L_A_LST_ALA, // 联络A侧失压告警
@@ -254,6 +270,16 @@ enum
     EV_FA_HZ_FAIL,  // 联络合闸失败
     EV_FA_LL_CD,    // 联络开关充电完成
 
+    EV_FA_GL_TZ,  // 合到过流I段动作
+    EV_FA_GL_TZ2, // 合到过流II段动作
+    EV_FA_LX_TZ,  // 合到零序动作
+    EV_FA_GL_GJ,  // 相间过流告警
+    EV_FA_LX_GJ,  // 接地告警
+#ifdef EV_GL_STATR
+    EV_FA_GL_START,  // 相间I段启动
+    EV_FA_GL2_START, // 相间II段启动
+    EV_FA_LX_START,  // 接地过流启动
+#endif
     EV_HA_HZ,     // 手动合闸
     EV_HA_FZ,     // 手动分闸
     EV_DL_HZ,     // 开关就地合闸
@@ -262,35 +288,41 @@ enum
     EV_YK_FZ,     // 遥控分闸
     EV_BS_FZMORE, // 多次分闸闭锁合闸
     EV_X_SWFAIL,  // 上电拒合
-
+    EV_FA_LL_EN,  // 自转电功能投入
+    EV_FA_U0GJ,   // 合后零序电压告警
 #ifdef YK_FA_ENBLE
     EV_YK_BS_FA, // 遥控闭锁FA
 #endif
-
 #ifdef FA_OC_COUNT
     EV_BS_OC_COUNT, // 过流脉冲计数闭锁
 #endif
-    EV_TQHZ, // 同期合闸
+#ifdef FUNC_YL_FZ_SOE
+    EV_YL_FZ, // 联络Y闭锁
+#endif
 
-    EV_GDDY_TZ,   // 电压过低解列
-    EV_DDY_TZ,    // 电压低解列
-    EV_GDY_TZ,    // 电压高解列
-    EV_GGDY_TZ,   // 电压过高解列
-    EV_LOWPL_TZ,  // 频率过低解列
-    EV_DPL_TZ,    // 低频解列
-    EV_GPL_TZ,    // 高频解列
-    EV_HIGHPL_TZ, // 频率过高解列
+    EV_BK_030, // 备用
+    EV_BK_031, // 备用
+    EV_BK_032, // 备用
+    EV_BK_033, // 备用
+    EV_BK_034, // 备用
+    EV_BK_035, // 备用
+    EV_BK_036, // 备用
+    EV_BK_037, // 备用
+    EV_BK_038, // 备用
+    EV_BK_039, // 备用
 
-    EV_GOOSE_QC_QD,   // 智能分布式切除动作
-    EV_GOOSE_QC_OK,   // 智能分布式切除成功
-    EV_GOOSE_QC_FAIL, // 智能分布式切除失败
-    EV_GOOSE_GL_QD,   // 分布式故障隔离动作
-    EV_GOOSE_GL_OK,   // 分布式故障隔离成功
-    EV_GOOSE_GL_FAIL, // 分布式故障隔离失败
-    EV_GOOSE_HZ_QD,   // 分布式供电恢复动作
-    EV_GOOSE_HZ_OK,   // 分布式供电恢复成功
-    EV_GOOSE_HZ_FAIL, // 分布式供电恢复失败
-    EV_GOOSE_GL_TZ,   // 分布式过流跳闸
+    EV_GOOSE_BGN,                                       // 从goose 来的故障信息
+    EV_GOOSE_END = EV_GOOSE_BGN + GOOSE_RECV_LOGIC_NUM, // 从goose 来的故障信息
+    EV_GOOSE_QC_QD,                                     // 智能分布式切除动作
+    EV_GOOSE_QC_OK,                                     // 智能分布式切除成功
+    EV_GOOSE_QC_FAIL,                                   // 智能分布式切除失败
+    EV_GOOSE_GL_QD,                                     // 分布式故障隔离动作
+    EV_GOOSE_GL_OK,                                     // 分布式故障隔离成功
+    EV_GOOSE_GL_FAIL,                                   // 分布式故障隔离失败
+    EV_GOOSE_HZ_QD,                                     // 分布式供电恢复动作
+    EV_GOOSE_HZ_OK,                                     // 分布式供电恢复成功
+    EV_GOOSE_HZ_FAIL,                                   // 分布式供电恢复失败
+    EV_GOOSE_GL_TZ,                                     // 分布式过流跳闸
 #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
     EV_GOOSE_GL2_TZ, // 分布式过流II段跳闸
 #endif
@@ -303,6 +335,44 @@ enum
     EV_GOOSE_HZ_GL2, // 分布式合后II段跳闸
     EV_GOOSE_HZ_LX,  // 分布式合后零序跳闸
 #endif
+    EV_GOOSE_LL_UNOK, // 分布式转供未满足
+    EV_GOOSE_GZBS_FA, // 分布式故障闭锁合闸
+    EV_GOOSE_TZBS_FA, // 分布式分闸闭锁合闸
+
+    EV_BK_040, // 备用
+    EV_BK_041, // 备用
+    EV_BK_042, // 备用
+    EV_BK_043, // 备用
+    EV_BK_044, // 备用
+    EV_BK_045, // 备用
+    EV_BK_046, // 备用
+    EV_BK_047, // 备用
+    EV_BK_048, // 备用
+    EV_BK_049, // 备用
+
+    EV_TQHZ,     // 同期合闸
+    EV_TQHZ_BAN, // 同期合闸禁止
+
+    EV_JL_CD,     // 解列充电完成
+    EV_GDDY_TZ,   // 电压过低解列
+    EV_DDY_TZ,    // 电压低解列
+    EV_GDY_TZ,    // 电压高解列
+    EV_GGDY_TZ,   // 电压过高解列
+    EV_LOWPL_TZ,  // 频率过低解列
+    EV_DPL_TZ,    // 低频解列
+    EV_GPL_TZ,    // 高频解列
+    EV_HIGHPL_TZ, // 频率过高解列
+
+    EV_BK_050, // 备用
+    EV_BK_051, // 备用
+    EV_BK_052, // 备用
+    EV_BK_053, // 备用
+    EV_BK_054, // 备用
+    EV_BK_055, // 备用
+    EV_BK_056, // 备用
+    EV_BK_057, // 备用
+    EV_BK_058, // 备用
+    EV_BK_059, // 备用
 
     EV_BSTZ, // 遮断电流闭锁
     EV_DLZZ, // 电流重载告警
@@ -318,27 +388,13 @@ enum
     // EV_IBYX,					// Ib越限告警
     // EV_ICYX,					// ic越限告警
     EV_I0YX,   // 零序电流越限告警
+
     EV_TZFAIL, // 跳闸失败
     EV_HZFAIL, // 合闸失败
     EV_SWFAIL, // 开关拒动
 
     EV_TWYL, // 跳位有流告警
 
-    EV_BH_YB,       // 保护投入软压板
-    EV_BH_YBTT,     // 常规保护投入
-    EV_CHZ_YB,      // 自动重合闸投入
-    EV_FA_YBTT,     // 就地型馈线自动化投入
-    EV_GOOSE_YBTT,  // 智能分布式投入
-    EV_JZS_YBTT,    // 集中式投入
-    EV_TQ_YBTT,     // 同期合闸投入
-    EV_JL_YBTT,     // 自动解列投入
-    EV_XDLJD_YBTT,  // 小电流接地保护投入
-    EV_XLDXGJ_YBTT, // 线路断线告警投入
-    EV_BTDCD_YBTT,  // 不停电传动投入
-
-    EV_KZ_YB,   // 保护出口投入软压板
-    EV_EDIT_YB, // 远程运维软压板
-
     EV_LX_XDL_QD, // 小电流接地启动
     EV_XDL_U0GJ1, // 小电流零压1告警
     EV_XDL_U0GJ2, // 小电流零压2告警
@@ -355,29 +411,14 @@ enum
     EV_LX_XDL_GJ, // 小电流接地告警
 #endif
 
-#ifdef YB_STHD_CHECK
-    EV_FUNALL_CHECK, // 功能总压板不一致
-    EV_CHZ_CHECK,    // 重合闸压板不一致
-    EV_GOOSE_CHECK,  // 分布式压板不一致
-    EV_FA_CHECK,     // 就地FA压板不一致
-    EV_BH_CHECK,     // 常规保护压板不一致
-#endif
-
-    EV_TH_WCN,                                          // 未储能告警
-    EV_KZHL,                                            // 控制回路异常
-    EV_GOOSE_BGN,                                       // 从goose 来的故障信息
-    EV_GOOSE_END = EV_GOOSE_BGN + GOOSE_RECV_LOGIC_NUM, // 从goose 来的故障信息
+    EV_TH_WCN, // 未储能告警
+    EV_KZHL,   // 控制回路异常
 
     EV_CTYC,   // CT断线
     EV_CTXXYC, // CT相序异常
+    EV_LBA,    // 线路断线告警
 
-    EV_FA_LL_EN,      // 自转电功能投入
-    EV_GOOSE_LL_UNOK, // 分布式供电恢复未满足
-    EV_GOOSE_GZBS_FA, // 分布式故障闭锁合闸
-    EV_GOOSE_TZBS_FA, // 分布式分闸闭锁合闸
-    EV_FA_U0GJ,       // 合后零序电压告警
 #ifdef FUNC_DRIVE
-    EV_DRIVE,         // 不停电传动功能软压板
     EV_DRIVE_BEGIN,   // 不停电传动开始
     EV_DRIVE_TZ_FAIL, // 不停电传动跳闸失败
     EV_DRIVE_HZ_FAIL, // 不停电传动合闸失败
@@ -392,9 +433,6 @@ enum
     EV_DRIVE_ADD_HZ,  // 传动补发合闸
     EV_DRIVE_END,     // 不停电传动结束
 #endif
-#ifdef FUNC_YL_FZ_SOE
-    EV_YL_FZ, // 联络Y闭锁
-#endif
 
 #ifdef CUSTOMIZE_BZT // 备自投
     EV_ZT_TZ1,       // 1#开关自投跳闸
@@ -414,28 +452,186 @@ enum
     EV_BZT_HZ3_FAIL, // 3#开关合闸失败
 #endif
 
+    EV_GL_FAULT, // 短路故障
+    EV_LX_FAULT, // 接地故障
+    EV_IA_GL,    // A相短路故障
+    EV_IB_GL,    // B相短路故障
+    EV_IC_GL,    // C相短路故障
+    EV_IAB_GL,   // AB相短路故障
+    EV_IBC_GL,   // BC相短路故障
+    EV_ICA_GL,   // CA相短路故障
+    EV_IABC_GL,  // ABC相短路故障
+
+    EV_BK_060, // 备用
+    EV_BK_061, // 备用
+    EV_BK_062, // 备用
+    EV_BK_063, // 备用
+    EV_BK_064, // 备用
+    EV_BK_065, // 备用
+    EV_BK_066, // 备用
+    EV_BK_067, // 备用
+    EV_BK_068, // 备用
+    EV_BK_069, // 备用
+
+    /* 功能遥信 */
+    EV_GENERAL_PRO,   /* 总保护运行 */
+    EV_CON_PRO,       /* 常规保护运行 */
+    EV_RECLOSE_PRO,   /* 重合闸运行 */
+    EV_FA_PRO,        /* FA运行 */
+    EV_DFA_PRO,       /* 智能分布式运行 */
+    EV_CEN_PRO,       /* 集中式运行 */
+    EV_SC_PRO,        /* 同期合闸运行 */
+    EV_AUTOLIST_PRO,  /* 自动解列运行 */
+    EV_CERGROUND_PRO, /* 小电流接地运行 */
+    EV_BREAKLINE_PRO, /* 线路断线告警运行 */
+    EV_PFD_PRO,       /* 不停电传动运行 */
+    EV_FUN_ERR,       /* 功能模式异常 */
+
+    /* 软压板 */
+    EV_GPFPRO_SOFT,     /* 常规保护压板 */
+    EV_RECLOSEON_SOFT,  /* 自动重合闸压板  */
+    EV_BAR_TT,          /* 停用重合闸压板 */
+    EV_FAPRO_SOFT,      /* 就地馈线自动化压板 */
+    EV_DFAPRO_SOFT,     /* 智能分布式压板 */
+    EV_CTLPRO_SOFT,     /* 集中式压板 */
+    EV_SC_SOFT,         /* 同期合闸压板 */
+    EV_AUTOLIST_SOFT,   /* 自动解列压板 */
+    EV_CERGROUND_SOFT,  /* 小电流接地压板 */
+    EV_BREAKLINE_SOFT,  /* 线路断线告警压板 */
+    EV_PFD_SOFT,        /* 不停电传动压板 */
+    EV_PROALL_SOFT,     /* 功能总投退压板 */
+    EV_LOGICTRIP_SOFT,  /* 功能总出口压板 */
+    EV_LOGICCLOSE_SOFT, /* 重合闸软压板 */
+    EV_YFYT_SOFT,       /* 远程运维压板 */
+
+    EV_CON_CTRL_01, /* 过流一段投入 */
+    EV_CON_CTRL_02, /* 过流二段投入 */
+    EV_CON_CTRL_03, /* 过流三段投入 */
+    EV_CON_CTRL_04, /* 过流一段方向投入 */
+    EV_CON_CTRL_05, /* 过流二段方向投入 */
+    EV_CON_CTRL_06, /* 过流三段方向投入 */
+    EV_CON_CTRL_07, /* 零流一段投入 */
+    EV_CON_CTRL_08, /* 零流二段投入 */
+    EV_CON_CTRL_09, /* 零流三段投入 */
+    EV_CON_CTRL_10, /* PT断线投入 */
+    EV_CON_CTRL_11, /* 后加速投入 */
+    EV_CON_CTRL_12, /* 过流启动重合投入 */
+    EV_CON_CTRL_13, /* 零流启动重合投入 */
+    EV_CON_CTRL_14, /* 涌流识别投入 */
+    EV_CON_CTRL_15, /* 零压保护投入 */
+    EV_REC_CTRL_01, /* 一次重合闸投入 */
+    EV_REC_CTRL_02, /* 二次重合闸投入 */
+    EV_REC_CTRL_03, /* 重合闸检同期投入 */
+    EV_REC_CTRL_04, /* 重合闸检无压投入 */
+    EV_REC_CTRL_05, /* 大电流闭锁重合投入 */
+    EV_FA_SLMODE,   /* 分段联络模式 */
+    EV_FA_CTRL_01,  /* A侧得电延时合投入 */
+    EV_FA_CTRL_02,  /* B侧得电延时合投入 */
+    EV_FA_CTRL_03,  /* A侧失电延时合投入 */
+    EV_FA_CTRL_04,  /* B侧失电延时合投入 */
+    EV_FA_CTRL_05,  /* 合到故障快速分投入 */
+    EV_FA_CTRL_06,  /* 合成功闭锁失压分 */
+    EV_FA_CTRL_07,  /* FA过流告警投入 */
+    EV_FA_CTRL_08,  /* FA接地告警投入*/
+    EV_FA_CTRL_09,  /* 合到零序电压保护 */
+    EV_FA_CTRL_10,  /* 非遮断投入 */
+    EV_FA_CTRL_11,  /* PT断线投入 */
+    EV_FA_CTRL_12,  /* 多次失压分闭锁合 */
+    EV_FA_CTRL_13,  /* 涌流闭锁投入 */
+    EV_FA_CTRL_14,  /* 硬件残压模快投入 */
+    EV_DFA_CTRL_01, /* 分布式FA方式 */
+    EV_DFA_CTRL_02, /* 联络自投投入 */
+    EV_DFA_CTRL_03, /* 过载闭锁自投投入 */
+    EV_DFA_CTRL_04, /* 首开关失压保护投入 */
+    EV_DFA_CTRL_05, /* 智能分布式启动重合 */
+    EV_AL_CTRL_01,  /* 电压解列投入 */
+    EV_AL_CTRL_02,  /* 电压滑差闭锁 */
+    EV_AL_CTRL_03,  /* 频率解列投入 */
+    EV_AL_CTRL_04,  /* 频率滑差闭锁 */
+    EV_LC_CTRL_01,  /* 小电流接地投入 */
+    EV_LC_CTRL_02,  /* 小电流接地启动重合 */
+    EV_LC_CTRL_03,  /* 小电流接地后加速 */
+
+#ifdef YB_STHD_CHECK
+    EV_FUNALL_CHECK, // 功能总压板不一致
+    EV_CHZ_CHECK,    // 重合闸压板不一致
+    EV_GOOSE_CHECK,  // 分布式压板不一致
+    EV_FA_CHECK,     // 就地FA压板不一致
+    EV_BH_CHECK,     // 常规保护压板不一致
+#endif
+
+    EV_BK_070, // 备用
+    EV_BK_071, // 备用
+    EV_BK_072, // 备用
+    EV_BK_073, // 备用
+    EV_BK_074, // 备用
+    EV_BK_075, // 备用
+    EV_BK_076, // 备用
+    EV_BK_077, // 备用
+    EV_BK_078, // 备用
+    EV_BK_079, // 备用
+
     EV_SW_NUM, //
 };
 
 enum
 {
     EV_PUB_START = EV_SW_NUM * SWITCH_NUM_MAX,
-    EV_UAB1GDY = EV_PUB_START, // Uab1过电压告警
-    EV_UBC1GDY,                // UBC1过电压告警
-    EV_UCA1GDY,                // UCA1过电压告警
-    EV_UAB1DDY,                // UAB1低电压告警
-    EV_UBC1DDY,                // UBC1低电压告警
-    EV_UCA1DDY,                // UCA1低电压告警
-    EV_UAB2GDY,                // UAB2过电压告警
-    EV_UBC2GDY,                // UBC2过电压告警
-    EV_UCA2GDY,                // UCA2过电压告警
-    EV_UAB2DDY,                // UAB2低电压告警
-    EV_UBC2DDY,                // UBC2低电压告警
-    EV_UCA2DDY,                // UCA2低电压告警
-    EV_POW1YY,                 // A侧有压
-    EV_POW2YY,                 // B侧有压
-    EV_POW1WY,                 // A侧无压
-    EV_POW2WY,                 // B侧无压
+    FAULT_ALL = EV_PUB_START, // 事故总
+    EV_BOARDERR,              // 板卡故障
+    EV_BOARDCOMM,             // 板卡通信异常
+    EV_HMIERR,                // 面板通信异常
+
+#if defined CAN_SLAVE_BOARD && defined METERING_ENERGY
+    EV_CAN_METERING_ERR, // 线损通信异常
+#endif
+
+    EV_EQU_ERR_HW,    // 装置硬件故障
+    EV_EQU_ERR_SW,    // 装置软件故障
+    EV_GOOSE_ERR,     // 系统通信异常
+    EV_GOOSE_DECODE,  // 本机goose通信异常
+    EV_SYS_GOOSE_ERR, // goose数据异常
+    EV_61850_ERR,     // 61850平台库异常
+#ifdef GOOSE_NETTYPE_SET
+    EV_NET1_DOWN,         // 单网通讯异常NET1
+    EV_NET2_DOWN,         // 单网通讯异常NET2
+    EV_GOOSE_ERR_N,       // N侧通讯异常
+    EV_GOOSE_ERR_M,       // M侧通讯异常
+    EV_GOOSE_NETTYPE_ERR, // Goose网络类型设置错误
+#endif
+
+#ifdef GD_AREA_ZHONGSHAN_2020
+    EV_GO
+        OSE_CONFIG_ERR, // goose 配置异常
+#endif
+
+    EV_BK_080, // 备用
+    EV_BK_081, // 备用
+    EV_BK_082, // 备用
+    EV_BK_083, // 备用
+    EV_BK_084, // 备用
+    EV_BK_085, // 备用
+    EV_BK_086, // 备用
+    EV_BK_087, // 备用
+    EV_BK_088, // 备用
+    EV_BK_089, // 备用
+
+    EV_UAB1GDY, // Uab1过电压告警
+    EV_UBC1GDY, // UBC1过电压告警
+    EV_UCA1GDY, // UCA1过电压告警
+    EV_UAB1DDY, // UAB1低电压告警
+    EV_UBC1DDY, // UBC1低电压告警
+    EV_UCA1DDY, // UCA1低电压告警
+    EV_UAB2GDY, // UAB2过电压告警
+    EV_UBC2GDY, // UBC2过电压告警
+    EV_UCA2GDY, // UCA2过电压告警
+    EV_UAB2DDY, // UAB2低电压告警
+    EV_UBC2DDY, // UBC2低电压告警
+    EV_UCA2DDY, // UCA2低电压告警
+    EV_POW1YY,  // A侧有压
+    EV_POW2YY,  // B侧有压
+    EV_POW1WY,  // A侧无压
+    EV_POW2WY,  // B侧无压
 
     EV_DYSTATUS, // 电源模块状态
 #ifdef BATTERY_WITH_COMM
@@ -467,33 +663,6 @@ enum
     EV_DD_DIR, // 潮流改变次数
 #endif
 
-    EV_BOARDERR,  // 板卡故障
-    EV_BOARDCOMM, // 板卡通信异常
-    EV_HMIERR,    // 面板通信异常
-
-#if defined CAN_SLAVE_BOARD && defined METERING_ENERGY
-    EV_CAN_METERING_ERR, // 线损通信异常
-#endif
-
-    EV_EQU_ERR_HW,    // 装置硬件故障
-    EV_EQU_ERR_SW,    // 装置软件故障
-    EV_GOOSE_ERR,     // 系统通信异常
-    EV_GOOSE_DECODE,  // 本机goose通信异常
-    EV_SYS_GOOSE_ERR, // goose数据异常
-    EV_61850_ERR,     // 61850平台库异常
-#ifdef GOOSE_NETTYPE_SET
-    EV_NET1_DOWN,         // 单网通讯异常NET1
-    EV_NET2_DOWN,         // 单网通讯异常NET2
-    EV_GOOSE_ERR_N,       // N侧通讯异常
-    EV_GOOSE_ERR_M,       // M侧通讯异常
-    EV_GOOSE_NETTYPE_ERR, // Goose网络类型设置错误
-#endif
-
-#ifdef GD_AREA_ZHONGSHAN_2020
-    EV_GO
-        OSE_CONFIG_ERR, // goose 配置异常
-#endif
-    FAULT_ALL,     // 事故总
     EV_TT_BAT,     // 电池自动活化
     EV_BAT_ON,     // 电池投入
     EV_FDL1_TZ,    // 非电量1跳闸
@@ -516,6 +685,7 @@ enum
     EV_COMM6_ERR,  // 串口6通信异常
     EX_NET1_ERR,   // 网口1通信异常
     EX_NET2_ERR,   // 网口2通信异常
+    EX_NET3_ERR,   // 网口3通信异常
     EV_LINK_EQU1,  // 级联装置1异常
     EV_LINK_EQU2,  // 级联装置2异常
     EV_LINK_EQU3,  // 级联装置3异常
@@ -529,83 +699,16 @@ enum
     EV_MB_HZ,      // 面板合闸
     EV_MB_TZ,      // 面板分闸
 
-#if (1)
-    /* 功能遥信 */
-    EV_GENERAL_PRO, /* 总保护运行 */
-    EV_CON_PRO,     /* 常规保护运行 */
-    EV_FA_PRO,      /* FA运行 */
-    EV_DFA_PRO,     /* 智能分布式运行 */
-    EV_CEN_PRO,     /* 集中式运行 */
-    EV_RECLOSE_PRO, /* 重合闸运行 */
-    EV_FUN_ERR,     /* 功能模式异常 */
-
-    /* 软压板 */
-    EV_GPFPRO_SOFT,     /* 常规保护压板 */
-    EV_RECLOSEON_SOFT,  /* 自动重合闸压板  */
-    EV_BAR_TT,          /* 停用重合闸压板 */
-    EV_FAPRO_SOFT,      /* 就地馈线自动化压板 */
-    EV_DFAPRO_SOFT,     /* 智能分布式压板 */
-    EV_CTLPRO_SOFT,     /* 集中式压板 */
-    EV_SC_SOFT,         /* 同期合闸压板 */
-    EV_AUTOLIST_SOFT,   /* 自动解列压板 */
-    EV_CERGROUND_SOFT,  /* 小电流接地压板 */
-    EV_BREAKLINE_SOFT,  /* 线路断线告警压板 */
-    EV_PFD_SOFT,        /* 不停电传动压板 */
-    EV_PROALL_SOFT,     /* 功能总投退压板 */
-    EV_LOGICTRIP_SOFT,  /* 功能总出口压板 */
-    EV_LOGICCLOSE_SOFT, /* 重合闸软压板 */
-    EV_YFYT_SOFT,       /* 远程运维压板 */
-
-    EV_OZ_CUR_CTRL, /* 过流零流告警投入 */
-    EV_JUMP_CTRL,   /* 常规保护跳闸投入 */
-    EV_CON_CTRL_01, /* 过流一段投入 */
-    EV_CON_CTRL_02, /* 过流二段投入 */
-    EV_CON_CTRL_03, /* 过流三段投入 */
-    EV_CON_CTRL_04, /* 过流一段方向投入 */
-    EV_CON_CTRL_05, /* 过流二段方向投入 */
-    EV_CON_CTRL_06, /* 过流三段方向投入 */
-    EV_CON_CTRL_07, /* 零流一段投入 */
-    EV_CON_CTRL_08, /* 零流二段投入 */
-    EV_CON_CTRL_09, /* 零流三段投入 */
-    EV_CON_CTRL_10, /* PT断线投入 */
-    EV_CON_CTRL_11, /* 后加速投入 */
-    EV_CON_CTRL_12, /* 过流启动重合投入 */
-    EV_CON_CTRL_13, /* 零流启动重合投入 */
-    EV_CON_CTRL_14, /* 涌流识别投入 */
-    EV_CON_CTRL_15, /* 零压保护投入 */
-    EV_REC_CTRL_01, /* 一次重合闸投入 */
-    EV_REC_CTRL_02, /* 二次重合闸投入 */
-    EV_REC_CTRL_03, /* 重合闸检同期投入 */
-    EV_REC_CTRL_04, /* 重合闸检无压投入 */
-    EV_REC_CTRL_05, /* 大电流闭锁重合投入 */
-    EV_FA_SLMODE,   /* 分段联络模式 */
-    EV_FA_CTRL_01,  /* A侧得电延时合投入 */
-    EV_FA_CTRL_02,  /* B侧得电延时合投入 */
-    EV_FA_CTRL_03,  /* A侧失电延时合投入 */
-    EV_FA_CTRL_04,  /* B侧失电延时合投入 */
-    EV_FA_CTRL_05,  /* 合到故障快速分投入 */
-    EV_FA_CTRL_06,  /* 合成功闭锁失压分 */
-    EV_FA_CTRL_07,  /* FA过流告警投入 */
-    EV_FA_CTRL_08,  /* FA接地告警投入*/
-    EV_FA_CTRL_09,  /* 合到零序电压保护 */
-    EV_FA_CTRL_10,  /* 非遮断投入 */
-    EV_FA_CTRL_11,  /* PT断线投入 */
-    EV_FA_CTRL_12,  /* 多次失压分闭锁合 */
-    EV_FA_CTRL_13,  /* 涌流闭锁投入 */
-    EV_FA_CTRL_14,  /* 硬件残压模快投入 */
-    EV_DFA_CTRL_01, /* 分布式FA方式 */
-    EV_DFA_CTRL_02, /* 联络自投投入 */
-    EV_DFA_CTRL_03, /* 过载闭锁自投投入 */
-    EV_DFA_CTRL_04, /* 首开关失压保护投入 */
-    EV_DFA_CTRL_05, /* 智能分布式启动重合 */
-    EV_AL_CTRL_01,  /* 电压解列投入 */
-    EV_AL_CTRL_02,  /* 电压滑差闭锁 */
-    EV_AL_CTRL_03,  /* 频率解列投入 */
-    EV_AL_CTRL_04,  /* 频率滑差闭锁 */
-    EV_LC_CTRL_01,  /* 小电流接地投入 */
-    EV_LC_CTRL_02,  /* 小电流接地启动重合 */
-    EV_LC_CTRL_03,  /* 小电流接地后加速 */
-#endif
+    EV_BK_090, // 备用
+    EV_BK_091, // 备用
+    EV_BK_092, // 备用
+    EV_BK_093, // 备用
+    EV_BK_094, // 备用
+    EV_BK_095, // 备用
+    EV_BK_096, // 备用
+    EV_BK_097, // 备用
+    EV_BK_098, // 备用
+    EV_BK_099, // 备用
 
     EV_PUB_END, /* 公共遥信结束 */
 

dtu/dtu_main_t536/app/FA.h

@@ -3,7 +3,7 @@
 版本号：  1.00
 文件名：  vol.h
 生成日期：2010-04-25
-作者：    电力产品开发部
+作者：    OLE
 功能说明：电压控制文件
 ****************************************************************************/
 
@@ -39,8 +39,8 @@ enum
     S_BSFZ,     // 合后闭锁分闸状态
     S_BSDL,     // 大电流闭锁分闸状态
 
-    // S_D_ZTIME,		//双电源闭锁状态中发生的Z时限计数状态
-    S_BS_SW, //
+    // S_D_ZTIME, //双电源闭锁状态中发生的Z时限计数状态
+    S_BS_SW, // X时限合闸失败
 };
 
 enum
@@ -54,6 +54,7 @@ enum
     L_XL_ZTIME, // X时限计数中发生的Z时限计数状态
     L_RELAYON,  // 开关合运行状态
     L_YL_TIME,  // 合闸成功Y计时
+    L_BSYTIME,  // Y时限闭锁状态
 };
 
 struct vol_stu
@@ -148,8 +149,8 @@ typedef union USDHZ_U
     {
         DDWORD bUABYY : 1;    // UAB有压标志
         DDWORD bUBCYY : 1;    // UBC有压标志
-        DDWORD bUABFlash : 1; // 1
-        DDWORD bUBCFlash : 1; // 2
+        DDWORD bUABFlash : 1; // 1 UAB瞬压标志
+        DDWORD bUBCFlash : 1; // 2 UBC瞬压标志
 
         DDWORD bPower : 1;    // 上电记录标志 Uab1侧，电源侧
         DDWORD bYY : 1;       // 有压标志
@@ -159,7 +160,7 @@ typedef union USDHZ_U
 
         DDWORD bOppositeYY : 1; // 对侧有压标志
         DDWORD bPowerYY : 1;    // 电源侧有压标志
-        DDWORD bPowerZ : 1;     // 停电时间		DWORD	bLockX:1;					//X时间闭锁
+        DDWORD bPowerZ : 1;     // 停电时间 DWORD bLockX:1; //X时间闭锁
 
         DDWORD bLockY : 1;      // Y时间闭锁
         DDWORD bLockUFlash : 1; // 瞬时加压闭锁
@@ -184,6 +185,7 @@ typedef union USDHZ_U
         DDWORD bSNChange : 1;   // 上电记录标志
         DDWORD bTempJS : 1;     // 临时解锁标志//		DWORD	bxdljd:1;					//暂态判断小电流接地
         DDWORD bOCing : 1;      // FA过流状态
+        DDWORD bYLock_dydl : 1;      // FA过流状态
         DDWORD bJS : 1;         // 满足解锁条件已解锁状态
 #if defined GD_AREA_ECZD_2020 && !defined GD_AREA_ZHONGSHAN_2020
         DDWORD bHhgz : 1; // 合后故障
@@ -221,7 +223,6 @@ typedef struct TSDHZ_T
 
     TIMERELAY tOnXSTime; // X时间继电器
     TIMERELAY tOnYSTime; // Y时间继电器
-    TIMERELAY tOnZSTime; // Z时间继电器
 
     TIMERELAY tOnXLTime;       // XL时间继电器
     TIMERELAY tOnYLTime;       // YL时间继电器
@@ -230,7 +231,7 @@ typedef struct TSDHZ_T
     TIMERELAY tOnOCingTime;    // FA过流状态继电器
     TIMERELAY tOnLXingTime;    // FA零序状态继电器
     TIMERELAY tOnJSTime;       // 单侧来电解锁时间继电器
-    TIMERELAY tOnY_JSTime;     // 正向闭锁后，反向来电合闸双侧有压时间继电器，中山局要求3S
+    TIMERELAY tOnY_JSTime;     // 正向闭锁后，反向来电合闸双侧有压时间继电器 3S
     TIMERELAY tOnBSTZTime;     // 合闸成功闭锁跳闸时间
     TIMERELAY tOnHW_FA_JSTime; // 合位直接解锁时间 默认1s
     TIMERELAY tUABS25ms;       // AB有压

dtu/dtu_main_t536/app/FA_g.h

@@ -39,83 +39,83 @@ enum
 
 enum
 {
-    GOOSE_RECV_TBL_M01 = 0, // M侧节点故障
-    GOOSE_RECV_TBL_M02,     // M侧节点故障
-    GOOSE_RECV_TBL_M03,     // M侧节点故障
-    GOOSE_RECV_TBL_M04,     // M侧节点故障
-    GOOSE_RECV_TBL_M05,     // M侧节点故障
-    GOOSE_RECV_TBL_M06,     // M侧节点故障
-    GOOSE_RECV_TBL_M07,     // M侧节点故障
-    GOOSE_RECV_TBL_M08,     // M侧节点故障
-
-    GOOSE_RECV_TBL_N01, // N侧节点故障
-    GOOSE_RECV_TBL_N02, // N侧节点故障
-    GOOSE_RECV_TBL_N03, // N侧节点故障
-    GOOSE_RECV_TBL_N04, // N侧节点故障
-
-    GOOSE_RECV_TBL_GL01, // 开关隔离成功
-    GOOSE_RECV_TBL_GL02, // 开关隔离成功
-    GOOSE_RECV_TBL_GL03, // 开关隔离成功
-    GOOSE_RECV_TBL_GL04, // 开关隔离成功
-    GOOSE_RECV_TBL_GL05, // 开关隔离成功
-    GOOSE_RECV_TBL_GL06, // 开关隔离成功
-    GOOSE_RECV_TBL_GL07, // 开关隔离成功
-    GOOSE_RECV_TBL_GL08, // 开关隔离成功
-    GOOSE_RECV_TBL_GL09, // 开关隔离成功
-    GOOSE_RECV_TBL_GL10, // 开关隔离成功
-    GOOSE_RECV_TBL_GL11, // 开关隔离成功
-    GOOSE_RECV_TBL_GL12, // 开关隔离成功
-
-    GOOSE_RECV_TBL_JT01, // 开关拒跳
-    GOOSE_RECV_TBL_JT02, // 开关拒跳
-    GOOSE_RECV_TBL_JT03, // 开关拒跳
-    GOOSE_RECV_TBL_JT04, // 开关拒跳
-    GOOSE_RECV_TBL_JT05, // 开关拒跳
-    GOOSE_RECV_TBL_JT06, // 开关拒跳
-    GOOSE_RECV_TBL_JT07, // 开关拒跳
-    GOOSE_RECV_TBL_JT08, // 开关拒跳
-    GOOSE_RECV_TBL_JT09, // 开关拒跳
-    GOOSE_RECV_TBL_JT10, // 开关拒跳
-    GOOSE_RECV_TBL_JT11, // 开关拒跳
-    GOOSE_RECV_TBL_JT12, // 开关拒跳
-
-    GOOSE_RECV_TBL_GLBS01,                                      // 过流闭锁01
-    GOOSE_RECV_TBL_GLBS02,                                      // 过流闭锁02
-    GOOSE_RECV_TBL_GLBS03,                                      // 过流闭锁03
-    GOOSE_RECV_TBL_GLBS04,                                      // 过流闭锁04
-    GOOSE_RECV_TBL_GLBS05,                                      // 过流闭锁05
-    GOOSE_RECV_TBL_GLBS06,                                      // 过流闭锁06
-    GOOSE_RECV_TBL_GLBS07,                                      // 过流闭锁07
-    GOOSE_RECV_TBL_GLBS08,                                      // 过流闭锁08
-    GOOSE_RECV_TBL_GLBS09,                                      // 过流闭锁09
-    GOOSE_RECV_TBL_GLBS10,                                      // 过流闭锁10
-    GOOSE_RECV_TBL_GLBS11,                                      // 过流闭锁11
-    GOOSE_RECV_TBL_GLBS12,                                      // 过流闭锁12
+    GOOSE_RECV_TBL_M01 = 0, // M侧节点故障01
+    GOOSE_RECV_TBL_M02,     // M侧节点故障02
+    GOOSE_RECV_TBL_M03,     // M侧节点故障03
+    GOOSE_RECV_TBL_M04,     // M侧节点故障04
+    GOOSE_RECV_TBL_M05,     // M侧节点故障05
+    GOOSE_RECV_TBL_M06,     // M侧节点故障06
+    GOOSE_RECV_TBL_M07,     // M侧节点故障07
+    GOOSE_RECV_TBL_M08,     // M侧节点故障08
+
+    GOOSE_RECV_TBL_N01, // N侧节点故障01
+    GOOSE_RECV_TBL_N02, // N侧节点故障02
+    GOOSE_RECV_TBL_N03, // N侧节点故障03
+    GOOSE_RECV_TBL_N04, // N侧节点故障04
+
+    GOOSE_RECV_TBL_GL01, // M侧故障隔离成功01
+    GOOSE_RECV_TBL_GL02, // M侧故障隔离成功02
+    GOOSE_RECV_TBL_GL03, // M侧故障隔离成功03
+    GOOSE_RECV_TBL_GL04, // M侧故障隔离成功04
+    GOOSE_RECV_TBL_GL05, // M侧故障隔离成功05
+    GOOSE_RECV_TBL_GL06, // M侧故障隔离成功06
+    GOOSE_RECV_TBL_GL07, // M侧故障隔离成功07
+    GOOSE_RECV_TBL_GL08, // M侧故障隔离成功08
+    GOOSE_RECV_TBL_GL09, // N侧故障隔离成功01
+    GOOSE_RECV_TBL_GL10, // N侧故障隔离成功02
+    GOOSE_RECV_TBL_GL11, // N侧故障隔离成功03
+    GOOSE_RECV_TBL_GL12, // N侧故障隔离成功04
+
+    GOOSE_RECV_TBL_JT01, // M侧开关拒跳01
+    GOOSE_RECV_TBL_JT02, // M侧开关拒跳02
+    GOOSE_RECV_TBL_JT03, // M侧开关拒跳03
+    GOOSE_RECV_TBL_JT04, // M侧开关拒跳04
+    GOOSE_RECV_TBL_JT05, // M侧开关拒跳05
+    GOOSE_RECV_TBL_JT06, // 馈线开关拒跳01
+    GOOSE_RECV_TBL_JT07, // 馈线开关拒跳02
+    GOOSE_RECV_TBL_JT08, // 馈线开关拒跳03
+    GOOSE_RECV_TBL_JT09, // N侧开关拒跳01
+    GOOSE_RECV_TBL_JT10, // N侧开关拒跳02
+    GOOSE_RECV_TBL_JT11, // N侧开关拒跳03
+    GOOSE_RECV_TBL_JT12, // 馈线开关拒跳04
+
+    GOOSE_RECV_TBL_GLBS01,                                      // 馈线开关过流闭锁01
+    GOOSE_RECV_TBL_GLBS02,                                      // 馈线开关过流闭锁02
+    GOOSE_RECV_TBL_GLBS03,                                      // 馈线开关过流闭锁03
+    GOOSE_RECV_TBL_GLBS04,                                      // 馈线开关过流闭锁04
+    GOOSE_RECV_TBL_GLBS05,                                      // 馈线开关过流闭锁05
+    GOOSE_RECV_TBL_GLBS06,                                      // 馈线开关过流闭锁06
+    GOOSE_RECV_TBL_GLBS07,                                      // 馈线开关过流闭锁07
+    GOOSE_RECV_TBL_GLBS08,                                      // 馈线开关过流闭锁08
+    GOOSE_RECV_TBL_GLBS09,                                      // 馈线开关过流闭锁09
+    GOOSE_RECV_TBL_GLBS10,                                      // 馈线开关过流闭锁10
+    GOOSE_RECV_TBL_GLBS11,                                      // 馈线开关过流闭锁11
+    GOOSE_RECV_TBL_GLBS12,                                      // 馈线开关过流闭锁12
 #if defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020 // 中山要求通信异常，全系统均异常
-    GOOSE_RECV_TBL_STATUS01,                                    // 节点通信异常状态
-    GOOSE_RECV_TBL_STATUS02,                                    // 节点通信异常状态
-    GOOSE_RECV_TBL_STATUS03,                                    // 节点通信异常状态
-    GOOSE_RECV_TBL_STATUS04,                                    // 节点通信异常状态
-    GOOSE_RECV_TBL_STATUS05,                                    // 节点通信异常状态
-    GOOSE_RECV_TBL_STATUS06,                                    // 节点通信异常状态
-    GOOSE_RECV_TBL_STATUS07,                                    // 节点通信异常状态
-    GOOSE_RECV_TBL_STATUS08,                                    // 节点通信异常状态
-    GOOSE_RECV_TBL_STATUS09,                                    // 节点通信异常状态
-    GOOSE_RECV_TBL_STATUS10,                                    // 节点通信异常状态
-    GOOSE_RECV_TBL_STATUS11,                                    // 节点通信异常状态
-    GOOSE_RECV_TBL_STATUS12,                                    // 节点通信异常状态
-    GOOSE_RECV_TBL_FG01,                                        // 节点通信异常
-    GOOSE_RECV_TBL_FG02,                                        // 节点通信异常
-    GOOSE_RECV_TBL_FG03,                                        // 节点通信异常
-    GOOSE_RECV_TBL_FG04,                                        // 节点通信异常
-    GOOSE_RECV_TBL_FG05,                                        // 节点通信异常
-    GOOSE_RECV_TBL_FG06,                                        // 节点通信异常
-    GOOSE_RECV_TBL_FG07,                                        // 节点通信异常
-    GOOSE_RECV_TBL_FG08,                                        // 节点通信异常
-    GOOSE_RECV_TBL_FG09,                                        // 节点通信异常
-    GOOSE_RECV_TBL_FG10,                                        // 节点通信异常
-    GOOSE_RECV_TBL_FG11,                                        // 节点通信异常
-    GOOSE_RECV_TBL_FG12,                                        // 节点通信异常
+    GOOSE_RECV_TBL_STATUS01,                                    // 节点01通信异常
+    GOOSE_RECV_TBL_STATUS02,                                    // 节点02通信异常
+    GOOSE_RECV_TBL_STATUS03,                                    // 节点03通信异常
+    GOOSE_RECV_TBL_STATUS04,                                    // 节点04通信异常
+    GOOSE_RECV_TBL_STATUS05,                                    // 节点05通信异常
+    GOOSE_RECV_TBL_STATUS06,                                    // 节点06通信异常
+    GOOSE_RECV_TBL_STATUS07,                                    // 节点07通信异常
+    GOOSE_RECV_TBL_STATUS08,                                    // 节点08通信异常
+    GOOSE_RECV_TBL_STATUS09,                                    // 节点09通信异常
+    GOOSE_RECV_TBL_STATUS10,                                    // 节点10通信异常
+    GOOSE_RECV_TBL_STATUS11,                                    // 节点11通信异常
+    GOOSE_RECV_TBL_STATUS12,                                    // 节点12通信异常
+    GOOSE_RECV_TBL_FG01,                                        // 节点01通信异常复归
+    GOOSE_RECV_TBL_FG02,                                        // 节点02通信异常复归
+    GOOSE_RECV_TBL_FG03,                                        // 节点03通信异常复归
+    GOOSE_RECV_TBL_FG04,                                        // 节点04通信异常复归
+    GOOSE_RECV_TBL_FG05,                                        // 节点05通信异常复归
+    GOOSE_RECV_TBL_FG06,                                        // 节点06通信异常复归
+    GOOSE_RECV_TBL_FG07,                                        // 节点07通信异常复归
+    GOOSE_RECV_TBL_FG08,                                        // 节点08通信异常复归
+    GOOSE_RECV_TBL_FG09,                                        // 节点09通信异常复归
+    GOOSE_RECV_TBL_FG10,                                        // 节点10通信异常复归
+    GOOSE_RECV_TBL_FG11,                                        // 节点11通信异常复归
+    GOOSE_RECV_TBL_FG12,                                        // 节点12通信异常复归
 #endif
     GOOSE_RECV_TBL_NUMBER, // 接收数据个数
 };

dtu/dtu_main_t536/app/IEC101.c

@@ -3851,8 +3851,12 @@ u32 IEC101_SendEvent(IEC101_DEF *pt, int is_send_cos)
     u8 arrCos1[200], arrSoe1[200];
     u16 head, cnt;
     u16 soe_no_s, soe_no_d, arg_index[64];
-    bool bFault;
+    bool bFault, b_package;
     FAULT_PARA_BUF *tf = &pt->tfault;
+    uint16_t us_pack_time = 0;
+
+    b_package = pRunSet->bTT_Package_MutuData;
+    us_pack_time = (uint16_t)pRunSet->bTT_Package_MutuTime;
 
     // 主动上送条件:
     // 1、是IEC101_ST_DATA状态
@@ -4002,7 +4006,7 @@ u32 IEC101_SendEvent(IEC101_DEF *pt, int is_send_cos)
                 timespec_to_rtc(event_p[i].ts, &rt, 1);
                 week = WEEK_DAY(event_p[i].ts.tv_sec);
 
-                // if(pRunSet->bTT_faultparaDKY)
+                // if(pRunSet->bTT_Ev_AD_LEN)
                 //{
                 yc_num = asdu_get_event_yc(arrSoe, 0, arg_index[i]); // 101规约是6个字节 按照规约规定，101 及104 遥信信息体地址都是两个字节
                 //}
@@ -4016,7 +4020,7 @@ u32 IEC101_SendEvent(IEC101_DEF *pt, int is_send_cos)
                 *pd++ = (yxtype == 1) ? 31 : 30; // 类型标识
                 *pd++ = (u8)no;                  // 信息体地址L
                 *pd++ = (u8)(no >> 8);           // 信息体地址H
-                if (pRunSet->bTT_faultparaDKY)
+                if (pRunSet->bTT_Ev_AD_LEN)
                 {
                     *pd++ = 0; // 信息体地址H2  按照规约规定，101 及104 遥信信息体地址都是两个字节
                 }
@@ -4030,7 +4034,7 @@ u32 IEC101_SendEvent(IEC101_DEF *pt, int is_send_cos)
                 *pd++ = (u8)rt.year;
                 *pd++ = yc_num; // 遥 测个数
                 *pd++ = 13;     // 类型标识	浮点值
-                // if(pRunSet->bTT_faultparaDKY)
+                // if(pRunSet->bTT_Ev_AD_LEN)
                 //{
                 memcpy(pd, arrSoe, yc_num * 6); // 标准规定，遥测点号是2个字节
                 IEC101_Asdu_Add_sts(pt, g_arrIECBuf, yc_num * 6 + (pd - g_arrIECBuf), 0, 3, 42, FRAME_I_PRIOR_LOW, 0);
@@ -4183,11 +4187,14 @@ void IEC101_AutoTimer(IEC101_DEF *pt)
 
     if (pt->tr.bpreset) // 参数预置
     {
-        if (ustimer_get_duration(pt->tr.us0_preset) > (tRunPara.dSM2Time * USTIMER_SEC))
+        if (ustimer_get_duration(pt->tr.us0_preset) > (tRunPara.dYTTime * USTIMER_SEC))
         {
             int i;
             rt_printf("101预置参数超时清除\r\n");
             pt->tr.bpreset = false;
+            pt->tr.us0_preset = 0;
+            pt->tr.uc_presetfixarea = 0xff;
+            pt->tr.uc_preset_num = 0;
             for (i = 0; i < RMT_SET_NUMBER; i++)
             {
                 pt->tr.di[i] = 0;
@@ -4724,6 +4731,7 @@ void IEC101_SectionRead(IEC101_DEF *pt101) //
     u8 *pd;
     int num;
     u8 cot;
+    u16 section; // 定值区号
 
     // 组织报文
     pd = g_arrIECBuf;
@@ -4732,10 +4740,14 @@ void IEC101_SectionRead(IEC101_DEF *pt101) //
     pd[num++] = 0;                       // 信息体地址
     pd[num++] = (u8)m_runsection;        // 当前定值区
     pd[num++] = (u8)(m_runsection >> 8); // 当前定值区
-    pd[num++] = 0;                       // 最小定值区
-    pd[num++] = 0;                       // 最小定值区
-    pd[num++] = SEC_NUMBER - 1;          // 最大定值区	1 标准上是7个字节，暂时认为是2个字节
-    pd[num++] = 0;                       // 最大定值区	2
+
+    section = setio_get_fixarearange(0);
+    pd[num++] = (BYTE)section;        // 最小定值区
+    pd[num++] = (BYTE)(section >> 8); // 最小定值区
+
+    section = setio_get_fixarearange(1);
+    pd[num++] = (BYTE)section;        // 最大定值区1
+    pd[num++] = (BYTE)(section >> 8); // 最大定值区2
 
     cot = IEC_COT_ACTCON;
     IEC101_Asdu_Add(pt101, g_arrIECBuf, num, 1, cot, 201, FRAME_I); //

dtu/dtu_main_t536/app/IEC101_FILE.c

@@ -89,6 +89,7 @@ struct file_item g_file_item[] =
         {"fixset.csv", "/app/data/", ATTR_UP | ATTR_DOWN, FILETYPE_OTHER, _file_save_app},  // 固定参数文件
         {"pcolcfg.ini", "/app/data/", ATTR_UP | ATTR_DOWN, FILETYPE_OTHER, _file_save_app}, // 级联规约文件
         {"vol_status.bin", "/app/data/", ATTR_UP | ATTR_DOWN, FILETYPE_OTHER, _file_save_app},
+	    {"ppl_tbl.csv", 	"/app/data/", 	ATTR_UP|ATTR_DOWN,	FILETYPE_OTHER, 	_file_save_app}, // 遥调配置文件
 
         {"set_data.bin", "/tmp/", ATTR_UP | ATTR_DOWN, FILETYPE_SET, _file_save_app},
         {FILE_NAME_RSC, "/tmp/", ATTR_UP | ATTR_DOWN, FILETYPE_OTHER, _file_save_app},

dtu/dtu_main_t536/app/IEC104.c

@@ -528,6 +528,15 @@ static void IEC104_Send_Polling(IEC104_DEF *pt104)
                 }
             }
 
+            if (pt->tb_us0_interval == 0)
+                pt->tb_us0_interval = ustimer_get_origin();
+            // 在数据发送前进行发送间隔时间判断
+            if (ustimer_get_duration(pt->tb_us0_interval) < (tRunPara.d104Intervalms * USTIMER_MS))
+            {
+                return;
+            }
+            pt->tb_us0_interval = 0;
+
             frm_attr = pt->tb_info[pt->tb_tail_send].frm_attr;
             len = pt->tb_data[pt->tb_tail_send][0];
             if ((frm_attr & 0xff) == FRAME_I)
@@ -1032,10 +1041,13 @@ static void IEC104_Timer(IEC104_DEF *pt104)
     }
     if (pt104->tr.bpreset) // 参数预置
     {
-        if (ustimer_get_duration(pt104->tr.us0_preset) > (tRunPara.dSM2Time * USTIMER_SEC))
+        if (ustimer_get_duration(pt104->tr.us0_preset) > (tRunPara.dYTTime * USTIMER_SEC))
         {
             rt_printf("104预置参数超时清除\r\n");
             pt104->tr.bpreset = false;
+            pt104->tr.us0_preset = 0;
+            pt104->tr.uc_presetfixarea = 0xff;
+            pt104->tr.uc_preset_num = 0;
             for (i = 0; i < RMT_SET_NUMBER; i++)
             {
                 pt104->tr.di[i] = 0;
@@ -1927,8 +1939,13 @@ u32 IEC104_SendEvent(IEC104_DEF *pt104, int is_send_cos) /*104
     u16 head, soe_no, arg_index;
     u32 cnt;
     EVENT_STRUCT event;
-    bool bFault;
+    bool bFault, b_package;
     FAULT_PARA_BUF *tf = &pt104->tfault;
+    uint16_t us_pack_time = 0;
+
+    b_package = pRunSet->bTT_Package_MutuData;
+    us_pack_time = (uint16_t)pRunSet->bTT_Package_MutuTime;
+
     // 主动上送条件:
     // 1、是IEC104_ST_STARTED状态
     // 2、没有在处理加密遥控报文
@@ -2064,7 +2081,7 @@ u32 IEC104_SendEvent(IEC104_DEF *pt104, int is_send_cos) /*104
             *pd++ = yxtype ? 31 : 30; // 类型标识		1
             *pd++ = (u8)no;           // 信息体地址L
             *pd++ = (u8)(no >> 8);    // 信息体地址H
-            if (pRunSet->bTT_faultparaDKY)
+            if (pRunSet->bTT_Ev_AD_LEN)
             {
                 *pd++ = 0; // 信息体地址H2  按照规约规定，101 及104 遥信信息体地址都是两个字节
             }
@@ -2082,7 +2099,7 @@ u32 IEC104_SendEvent(IEC104_DEF *pt104, int is_send_cos) /*104
             *pd++ = vsq; // 遥 测个数
             *pd++ = 13;  // 类型标识	浮点值
             memcpy(pd, arrSoe, vsq * 7);
-            if (pRunSet->bTT_faultparaDKY)
+            if (pRunSet->bTT_Ev_AD_LEN)
             {
                 IEC104_Send_sts(pt104, FRAME_I_PRIOR_LOW, (pd - &pt104->arrSendBuf[6]) + vsq * 7, 0); //  21 改为20 原因: 按照规约规定，101 及104 事件参数 遥信信息体地址都是两个字节
             }
@@ -4057,6 +4074,7 @@ void IEC104_SectionWrite(IEC104_DEF *pt104, u8 *ps) // 确
 
 void IEC104_SectionRead(IEC104_DEF *pt104) // 读定值区
 {
+    u16 section; // 定值区号
 
     BYTE *pd = &pt104->arrSendBuf[6]; // 从第7个字节开始
     BYTE cot = IEC_COT_ACTCON;        // 定值区为0，肯定应答，其他否定应答
@@ -4070,12 +4088,17 @@ void IEC104_SectionRead(IEC104_DEF *pt104) //
     pd[num++] = 0;                            // 信息体地址L  7
     pd[num++] = 0;                            // 信息体地址H  8
     pd[num++] = 0;                            // 信息体地址H  9
+
     pd[num++] = (u8)m_runsection;             // 当前定值区
     pd[num++] = (u8)(m_runsection >> 8);      // 当前定值区
-    pd[num++] = 0;                            // 最小定值区
-    pd[num++] = 0;                            // 最小定值区
-    pd[num++] = SEC_NUMBER - 1;               // 最大定值区1
-    pd[num++] = 0;                            // 最大定值区2
+
+    section = setio_get_fixarearange(0);
+    pd[num++] = (BYTE)section;        // 最小定值区
+    pd[num++] = (BYTE)(section >> 8); // 最小定值区
+
+    section = setio_get_fixarearange(1);
+    pd[num++] = (BYTE)section;        // 最大定值区1
+    pd[num++] = (BYTE)(section >> 8); // 最大定值区2
 
     IEC104_Send(pt104, FRAME_I, num); // 应答
 }

dtu/dtu_main_t536/app/IECComm.h

@@ -235,6 +235,7 @@ typedef struct iec_tbuf
     volatile u8 tb_head;
     volatile u8 tb_tail_send;
     volatile u8 tb_tail_ack;
+	u32            	tb_us0_interval;
 
     iec_tbuf_head_t tb_info[IEC_TBUF_NUM];
     u8 tb_data[IEC_TBUF_NUM][IEC_TBUF_LEN];
@@ -292,16 +293,17 @@ typedef struct T_FILE_DEF
 
 typedef struct RMT_SET_DAT_DEF
 {
-    WORD di[RMT_SET_NUMBER];
-    float val[RMT_SET_NUMBER];
-    struct
+    WORD di[RMT_SET_NUMBER]; // 点号
+    union
     {
-        WORD di;
-        char str[32];
-    } t_str[RMT_STR_NUM];
-    DWORD us0_preset; // 预置参数
-    bool bpreset;     // 预置参数标志
-
+        float f_val;
+        uint32_t ul_val;
+    } val[RMT_SET_NUMBER];    // 数值
+    uint8_t uc_presetfixarea; // 预置定值区
+    // uint8_t uc_solidifyfixarea; // 固化定值区
+    DWORD us0_preset;      // 预置参数
+    bool bpreset;          // 预置参数标志
+    uint8_t uc_preset_num; // 预置数量
 } RMT_SET_DATA;
 
 #define RMT_FIXED_SET_NUM FIXED_SET_MAX // 固定定值

dtu/dtu_main_t536/app/IECLINK.c

@@ -702,7 +702,7 @@ void lnk_find_yc_iec_no(u8 ch, u8 *ps, u8 baddr3, u8 yc_type) // Ѱ
                 ps[0] = (u8)g_ac_table[i].cp;
                 ps[1] = (u8)(g_ac_table[i].cp >> 8);
 
-                if (pRunSet->bTT_EV_YCRate)
+                if (pRunSet->bTT_EvFailprimary)
                 {
                     union
                     {

dtu/dtu_main_t536/app/Maintain.c

@@ -1583,7 +1583,7 @@ int Maintain_Manage(u8 *buf, u32 len, u8 *cmd_buf)
             break;
         case 3:
             sprintf(cmd_buf + 3, "APP    VERSION:SV%02d.%03d %s",
-                    VER_NUM / 1000, VER_NUM % 1000, VER_TIME);
+                    (VER_NUM >> 12) & 0XFF, (VER_NUM & 0XFFF), VER_TIME);
             cmd_len = strlen(cmd_buf + 3) + 3;
             break;
 #ifdef CPU_FUXI

dtu/dtu_main_t536/app/MmiData.c

@@ -3937,7 +3937,7 @@ static void mmd_GetBoardYXValue(int no, DATA_FIELD_DEF *pF)
         }
         else
         {
-            //			// TODO:if(g_di[g_sw_index].value&(1<<di_no))
+            // TODO:if(g_di[g_sw_index].value&(1<<di_no))
             if (dido_di_is_on(g_sw_index, di_no))
             {
                 strcpy(tmpstr, "●");
@@ -5344,7 +5344,7 @@ int mmd_SetCstKey(int key)
 
 int mmd_SaveAdjustValue(int value)
 {
-    // TODO:增加恢复默认系数操作
+    // 增加恢复默认系数操作
     factor_restore_default();
 
     strcpy(m_WarningStr, "通道系数恢复为默认值");
@@ -7205,8 +7205,11 @@ int mmd_changesection(int value)
 #ifdef PUB_SET_SECTION
     int i;
 #endif
+    uint16_t us_fa_max = 0, us_fa_min = 0;
 
-    if (m_dstsection >= SEC_NUMBER || m_runsection == m_dstsection)
+    us_fa_min = setio_get_fixarearange(0);
+    us_fa_max = setio_get_fixarearange(1);
+    if (m_dstsection > us_fa_max || m_dstsection < us_fa_min || m_runsection == m_dstsection)
     {
         strcpy(m_WarningStr, "切换区号异常");
         return M_JUMP3;
@@ -8047,6 +8050,7 @@ void log_operate_set_change(const TSETTABLE *pTable, u16 setno, long v1, long v2
 
     log_str_time(LOG_FIXSET, namestr, 0, 0);
 }
+
 void para_change_check_soe(float *pf, DWORD wAddr, WORD num, const TSETTABLE *pTable)
 {
     SET_VALUE *pbuf;

dtu/dtu_main_t536/app/PDA_FILE.c

@@ -115,7 +115,7 @@ int PDA_TransFile(PDA_COMM *pt, unsigned char *buf)
         // 复位状态机
         _PDA_file_state_reset();
 
-        sprintf(cmd_buf + 2, "ZHFS " EQUIP_NAME_STRING "版本号:V%d.%02d.%02d", (VER_NUM >> 16) & 0XFF, (VER_NUM >> 8) & 0XFF, VER_NUM & 0XFF, VER_TIME "CRC:%04XH", m_CodeCrc);
+        sprintf(cmd_buf + 2, "ZHFS " EQUIP_NAME_STRING "版本号:SV%02d.%03d", (VER_NUM >> 12) & 0xff, VER_NUM & 0xfff, VER_TIME "CRC:%04XH", m_CodeCrc);
         cmd_len = strlen(cmd_buf + 2) + 1 + 2;
         if (memcmp(buf + 1, szPdaTool, 20) != 0) // 具体版本号暂时不检查(匹配V1.XX.XX)
         {
@@ -133,7 +133,7 @@ int PDA_TransFile(PDA_COMM *pt, unsigned char *buf)
         // 复位状态机
         _PDA_file_state_reset();
 
-        sprintf(cmd_buf + 2, "ZHFS " EQUIP_NAME_STRING "版本号:V%d.%02d.%02d", (VER_NUM >> 16) & 0XFF, (VER_NUM >> 8) & 0XFF, VER_NUM & 0XFF, VER_TIME "CRC:%04XH", m_CodeCrc);
+        sprintf(cmd_buf + 2, "ZHFS " EQUIP_NAME_STRING "版本号:SV%02d.%03d", (VER_NUM >> 12) & 0xff, VER_NUM & 0xfff, VER_TIME "CRC:%04XH", m_CodeCrc);
         cmd_len = strlen(cmd_buf + 2) + 1 + 2;
         if (memcmp(buf + 1, szPdaTool, 20) != 0) // 具体版本号暂时不检查(匹配V1.XX.XX)
         {

dtu/dtu_main_t536/app/SOE.c

@@ -531,9 +531,17 @@ void soe_record_allArg(s32 *arg, int sw)
 void soe_record_ev(u16 code, u8 value, long v1, long v2, long v3)
 {
     u16 extarg;
-    EVENT_STRUCT *ev;
+    EVENT_STRUCT *ev = &soe_get_buffer(&extarg)->es_ev;;
     u32 sw;
-    bool allarg = false;
+    bool allarg = false, b_event_z = false, b_event_en = true;
+    
+    /* 清零上送投退 */
+    b_event_z = pRunSet->bTT_EvFailure_Z;
+    if (!b_event_z && 0 == value)
+    {
+        b_event_en = false;
+    }
+
     if (code < EV_PUB_START)
     {
         sw = (code / EV_SW_NUM) + 1;
@@ -543,235 +551,241 @@ void soe_record_ev(u16 code, u8 value, long v1, long v2, long v3)
         sw = 0;
     }
 
-    if (code < EV_PUB_START) // add by sunxi 增加故障记录标示
+    if (b_event_en)
     {
-#ifdef SOE_RECORD_DELAY
-        if (!gb_wake_soe) // 首次上电时，对前一次上电产生的闭锁事件不做延时处理，避免逻辑运行出错
+        if (code < EV_PUB_START) // add by sunxi 增加故障记录标示
         {
-            if (tAllSOE[code % EV_SW_NUM].soe_def & SOE_TYPE_DELAY_FHZ && (value == 0))
-            { /*清SOE事件应在置SOE事件完成上送后再清，如果当前SOE事件未置则一直等待，
-              避免因分合闸延时上送SOE导致先清了SOE事件再送置SOE事件导致上送COS出错（正确是先置再清）*/
-                if (g_soe_queue.fzsoe_wait_flag)
-                {
-                    int i;
-                    g_soe_queue.fzsoe_delay_flag = true;
-                    g_soe_queue.fzsoe_wait_flag = false;
-                    for (i = 0; i < DELAY_SOE_MAX; i++)
-                    {
-                        if (g_soe_queue.delay_fzsoe_tab[i].value == 0)
-                            break;
-                        g_soe_queue.delay_fzsoe_count = i;
-                        soe_record_ev(g_soe_queue.delay_fzsoe_tab[i].code, g_soe_queue.delay_fzsoe_tab[i].value, g_soe_queue.delay_fzsoe_tab[i].v1, g_soe_queue.delay_fzsoe_tab[i].v2, g_soe_queue.delay_fzsoe_tab[i].v3);
-                    }
-                    /*置SOE后调用一次plc_scan，避免置->清SOE间隔过短导致正常plc_san扫描时无法扫描到置SOE*/
-                    plc_scan(1);
-                    memset((char *)&g_soe_queue.delay_fzsoe_tab, 0, sizeof(DELAY_SOE_DATA) * DELAY_SOE_MAX); // clear delay_soe_tab[] buffer
-                    g_soe_queue.delay_fzsoe_count = 0;
-                    g_soe_queue.fzsoe_delay_flag = false;
-                }
-                if (g_soe_queue.hzsoe_wait_flag)
-                {
-                    int i;
-                    g_soe_queue.hzsoe_delay_flag = true;
-                    g_soe_queue.hzsoe_wait_flag = false;
-                    for (i = 0; i < DELAY_SOE_MAX; i++)
-                    {
-                        if (g_soe_queue.delay_hzsoe_tab[i].value == 0)
-                            break;
-                        g_soe_queue.delay_hzsoe_count = i;
-                        soe_record_ev(g_soe_queue.delay_hzsoe_tab[i].code, g_soe_queue.delay_hzsoe_tab[i].value, g_soe_queue.delay_hzsoe_tab[i].v1, g_soe_queue.delay_hzsoe_tab[i].v2, g_soe_queue.delay_hzsoe_tab[i].v3);
-                    }
-                    memset((char *)&g_soe_queue.delay_hzsoe_tab, 0, sizeof(DELAY_SOE_DATA) * DELAY_SOE_MAX); // clear delay_soe_tab[] buffer
-                    g_soe_queue.delay_hzsoe_count = 0;
-                    g_soe_queue.hzsoe_delay_flag = false;
-                }
-            }
-            else if (tAllSOE[code % EV_SW_NUM].soe_def & SOE_TYPE_DELAY_FHZ && value) // 开关延时保存分/合闸动作SOE && 动作
+#ifdef SOE_RECORD_DELAY
+            if (!gb_wake_soe) // 首次上电时，对前一次上电产生的闭锁事件不做延时处理，避免逻辑运行出错
             {
-                u8 i = 0;
-                bool soe_fh = ((code % EV_SW_NUM) == EV_AR1) || ((code % EV_SW_NUM) == EV_AR2) || ((code % EV_SW_NUM) == EV_AR3) ||
-                              ((code % EV_SW_NUM) == EV_FA_HZ) || ((code % EV_SW_NUM) == EV_FA_LL_HZ); // 0-fz soe;1-hz soe
-                // 延时soe入QUEUE
-                if ((g_soe_queue.fzsoe_delay_flag == 0) && (g_tRelay[0].run_stu.sw == 2) && (!soe_fh)) // 非分闸延时SOE QUEUE转录SOE && 合位 && 分闸SOE  		fzsoe_tab[]
-                {
-                    for (i = 0; i < DELAY_SOE_MAX; i++) // 大于最大缓存，直接保存SOE
+                if (tAllSOE[code % EV_SW_NUM].soe_def & SOE_TYPE_DELAY_FHZ && (value == 0))
+                { /*清SOE事件应在置SOE事件完成上送后再清，如果当前SOE事件未置则一直等待，
+                避免因分合闸延时上送SOE导致先清了SOE事件再送置SOE事件导致上送COS出错（正确是先置再清）*/
+                    if (g_soe_queue.fzsoe_wait_flag)
                     {
-                        if (g_soe_queue.delay_fzsoe_tab[i].code == code) // 当前SOE已保存
+                        int i;
+                        g_soe_queue.fzsoe_delay_flag = true;
+                        g_soe_queue.fzsoe_wait_flag = false;
+                        for (i = 0; i < DELAY_SOE_MAX; i++)
                         {
-                            return; // 此次不保存数据
+                            if (g_soe_queue.delay_fzsoe_tab[i].value == 0)
+                                break;
+                            g_soe_queue.delay_fzsoe_count = i;
+                            soe_record_ev(g_soe_queue.delay_fzsoe_tab[i].code, g_soe_queue.delay_fzsoe_tab[i].value, g_soe_queue.delay_fzsoe_tab[i].v1, g_soe_queue.delay_fzsoe_tab[i].v2, g_soe_queue.delay_fzsoe_tab[i].v3);
                         }
-                        else if (g_soe_queue.delay_fzsoe_tab[i].value == 0)
+                        /*置SOE后调用一次plc_scan，避免置->清SOE间隔过短导致正常plc_san扫描时无法扫描到置SOE*/
+                        plc_scan(1);
+                        memset((char *)&g_soe_queue.delay_fzsoe_tab, 0, sizeof(DELAY_SOE_DATA) * DELAY_SOE_MAX); // clear delay_soe_tab[] buffer
+                        g_soe_queue.delay_fzsoe_count = 0;
+                        g_soe_queue.fzsoe_delay_flag = false;
+                    }
+                    if (g_soe_queue.hzsoe_wait_flag)
+                    {
+                        int i;
+                        g_soe_queue.hzsoe_delay_flag = true;
+                        g_soe_queue.hzsoe_wait_flag = false;
+                        for (i = 0; i < DELAY_SOE_MAX; i++)
                         {
-                            clk_time_get(&g_soe_queue.delay_fzsoe_tab[i].ts);
-                            g_soe_queue.delay_fzsoe_tab[i].value = value;
-                            g_soe_queue.delay_fzsoe_tab[i].code = code;
-                            g_soe_queue.delay_fzsoe_tab[i].v1 = v1;
-                            g_soe_queue.delay_fzsoe_tab[i].v2 = v2;
-                            g_soe_queue.delay_fzsoe_tab[i].v3 = v3;
-                            g_soe_queue.fzsoe_wait_flag = true;
-                            return; // 此次不保存数据
+                            if (g_soe_queue.delay_hzsoe_tab[i].value == 0)
+                                break;
+                            g_soe_queue.delay_hzsoe_count = i;
+                            soe_record_ev(g_soe_queue.delay_hzsoe_tab[i].code, g_soe_queue.delay_hzsoe_tab[i].value, g_soe_queue.delay_hzsoe_tab[i].v1, g_soe_queue.delay_hzsoe_tab[i].v2, g_soe_queue.delay_hzsoe_tab[i].v3);
                         }
+                        memset((char *)&g_soe_queue.delay_hzsoe_tab, 0, sizeof(DELAY_SOE_DATA) * DELAY_SOE_MAX); // clear delay_soe_tab[] buffer
+                        g_soe_queue.delay_hzsoe_count = 0;
+                        g_soe_queue.hzsoe_delay_flag = false;
                     }
                 }
-                else if ((g_soe_queue.hzsoe_delay_flag == 0) && (g_tRelay[0].run_stu.sw == 1) && soe_fh) ////非合闸延时SOE QUEUE转录SOE && 分位 && 闸SOE hzsoe_tab[]
+                else if (tAllSOE[code % EV_SW_NUM].soe_def & SOE_TYPE_DELAY_FHZ && value) // 开关延时保存分/合闸动作SOE && 动作
                 {
-                    for (i = 0; i < DELAY_SOE_MAX; i++) // 大于最大缓存，直接保存SOE
+                    u8 i = 0;
+                    bool soe_fh = ((code % EV_SW_NUM) == EV_AR1) || ((code % EV_SW_NUM) == EV_AR2) || ((code % EV_SW_NUM) == EV_AR3) ||
+                                  ((code % EV_SW_NUM) == EV_FA_HZ) || ((code % EV_SW_NUM) == EV_FA_LL_HZ); // 0-fz soe;1-hz soe
+                    // 延时soe入QUEUE
+                    if ((g_soe_queue.fzsoe_delay_flag == 0) && (g_tRelay[0].run_stu.sw == 2) && (!soe_fh)) // 非分闸延时SOE QUEUE转录SOE && 合位 && 分闸SOE  		fzsoe_tab[]
                     {
-                        if (g_soe_queue.delay_hzsoe_tab[i].code == code) // 当前SOE已保存
+                        for (i = 0; i < DELAY_SOE_MAX; i++) // 大于最大缓存，直接保存SOE
                         {
-                            return; // 此次不保存数据
+                            if (g_soe_queue.delay_fzsoe_tab[i].code == code) // 当前SOE已保存
+                            {
+                                return; // 此次不保存数据
+                            }
+                            else if (g_soe_queue.delay_fzsoe_tab[i].value == 0)
+                            {
+                                clk_time_get(&g_soe_queue.delay_fzsoe_tab[i].ts);
+                                g_soe_queue.delay_fzsoe_tab[i].value = value;
+                                g_soe_queue.delay_fzsoe_tab[i].code = code;
+                                g_soe_queue.delay_fzsoe_tab[i].v1 = v1;
+                                g_soe_queue.delay_fzsoe_tab[i].v2 = v2;
+                                g_soe_queue.delay_fzsoe_tab[i].v3 = v3;
+                                g_soe_queue.fzsoe_wait_flag = true;
+                                return; // 此次不保存数据
+                            }
                         }
-                        else if (g_soe_queue.delay_hzsoe_tab[i].value == 0)
+                    }
+                    else if ((g_soe_queue.hzsoe_delay_flag == 0) && (g_tRelay[0].run_stu.sw == 1) && soe_fh) ////非合闸延时SOE QUEUE转录SOE && 分位 && 闸SOE hzsoe_tab[]
+                    {
+                        for (i = 0; i < DELAY_SOE_MAX; i++) // 大于最大缓存，直接保存SOE
                         {
-                            clk_time_get(&g_soe_queue.delay_hzsoe_tab[i].ts);
-                            g_soe_queue.delay_hzsoe_tab[i].value = value;
-                            g_soe_queue.delay_hzsoe_tab[i].code = code;
-                            g_soe_queue.delay_hzsoe_tab[i].v1 = v1;
-                            g_soe_queue.delay_hzsoe_tab[i].v2 = v2;
-                            g_soe_queue.delay_hzsoe_tab[i].v3 = v3;
-                            g_soe_queue.hzsoe_wait_flag = true;
-                            return; // 此次不保存数据
+                            if (g_soe_queue.delay_hzsoe_tab[i].code == code) // 当前SOE已保存
+                            {
+                                return; // 此次不保存数据
+                            }
+                            else if (g_soe_queue.delay_hzsoe_tab[i].value == 0)
+                            {
+                                clk_time_get(&g_soe_queue.delay_hzsoe_tab[i].ts);
+                                g_soe_queue.delay_hzsoe_tab[i].value = value;
+                                g_soe_queue.delay_hzsoe_tab[i].code = code;
+                                g_soe_queue.delay_hzsoe_tab[i].v1 = v1;
+                                g_soe_queue.delay_hzsoe_tab[i].v2 = v2;
+                                g_soe_queue.delay_hzsoe_tab[i].v3 = v3;
+                                g_soe_queue.hzsoe_wait_flag = true;
+                                return; // 此次不保存数据
+                            }
                         }
                     }
                 }
             }
-        }
 #endif
-        ev = &soe_get_buffer(&extarg)->es_ev;
-        ev->ev_type = SOE_TYPE_EV;
-        if (tAllSOE[code % EV_SW_NUM].soe_def & SOE_TYPE_FAULT) // 需上送故障记录
-        {
-            ev->ev_type |= SOE_TYPE_FAULT;
-            soe_ext_arg(extarg, sw);
-        }
-        if (tAllSOE[code % EV_SW_NUM].soe_def & SOE_TYPE_RSV3) // 置关键事件标志
-        {
-            ev->ev_type |= SOE_TYPE_VIP;
+            ev->ev_type = SOE_TYPE_EV;
+            if (tAllSOE[code % EV_SW_NUM].soe_def & SOE_TYPE_FAULT) // 需上送故障记录
+            {
+                ev->ev_type |= SOE_TYPE_FAULT;
+                soe_ext_arg(extarg, sw);
+            }
+            if (tAllSOE[code % EV_SW_NUM].soe_def & SOE_TYPE_RSV3) // 置关键事件标志
+            {
+                ev->ev_type |= SOE_TYPE_VIP;
+            }
+            if (tAllSOE[code % EV_SW_NUM].soe_def & SOE_TYPE_VIP) // 全数据保存
+            {
+                allarg = true;
+            }
         }
-        if (tAllSOE[code % EV_SW_NUM].soe_def & SOE_TYPE_VIP) // 全数据保存
+        else
         {
-            allarg = true;
-        }
-    }
-    else
-    {
 #ifdef SOE_RECORD_DELAY
-        if (!gb_wake_soe) // 首次上电时，对前一次上电产生的闭锁事件不做延时处理，避免逻辑运行出错
-        {
-            if (tAllSOE[code - EV_PUB_START + EV_SW_NUM].soe_def & SOE_TYPE_DELAY_FHZ && (value == 0))
-            {
-                if (g_soe_queue.fzsoe_wait_flag)
-                {
-                    int i;
-                    g_soe_queue.fzsoe_delay_flag = true;
-                    g_soe_queue.fzsoe_wait_flag = false;
-                    for (i = 0; i < DELAY_SOE_MAX; i++)
-                    {
-                        if (g_soe_queue.delay_fzsoe_tab[i].value == 0)
-                            break;
-                        g_soe_queue.delay_fzsoe_count = i;
-                        soe_record_ev(g_soe_queue.delay_fzsoe_tab[i].code, g_soe_queue.delay_fzsoe_tab[i].value, g_soe_queue.delay_fzsoe_tab[i].v1, g_soe_queue.delay_fzsoe_tab[i].v2, g_soe_queue.delay_fzsoe_tab[i].v3);
-                    }
-                    memset((char *)&g_soe_queue.delay_fzsoe_tab, 0, sizeof(DELAY_SOE_DATA) * DELAY_SOE_MAX); // clear delay_soe_tab[] buffer
-                    g_soe_queue.delay_fzsoe_count = 0;
-                    g_soe_queue.fzsoe_delay_flag = false;
-                }
-                if (g_soe_queue.hzsoe_wait_flag)
-                {
-                    int i;
-                    g_soe_queue.hzsoe_delay_flag = true;
-                    g_soe_queue.hzsoe_wait_flag = false;
-                    for (i = 0; i < DELAY_SOE_MAX; i++)
-                    {
-                        g_soe_queue.delay_hzsoe_count = i;
-                        if (g_soe_queue.delay_hzsoe_tab[i].value == 0)
-                            break;
-                        soe_record_ev(g_soe_queue.delay_hzsoe_tab[i].code, g_soe_queue.delay_hzsoe_tab[i].value, g_soe_queue.delay_hzsoe_tab[i].v1, g_soe_queue.delay_hzsoe_tab[i].v2, g_soe_queue.delay_hzsoe_tab[i].v3);
-                    }
-                    memset((char *)&g_soe_queue.delay_hzsoe_tab, 0, sizeof(DELAY_SOE_DATA) * DELAY_SOE_MAX); // clear delay_soe_tab[] buffer
-                    g_soe_queue.delay_hzsoe_count = 0;
-                    g_soe_queue.hzsoe_delay_flag = false;
-                }
-            }
-            else if (tAllSOE[code - EV_PUB_START + EV_SW_NUM].soe_def & SOE_TYPE_DELAY_FHZ && value) // 开关延时保存分/合闸动作SOE && 动作
+            if (!gb_wake_soe) // 首次上电时，对前一次上电产生的闭锁事件不做延时处理，避免逻辑运行出错
             {
-                u8 i = 0;
-                bool soe_fh = (((code - EV_PUB_START + EV_SW_NUM) % EV_SW_NUM) == EV_AR1) || (((code - EV_PUB_START + EV_SW_NUM) % EV_SW_NUM) == EV_AR2) || (((code - EV_PUB_START + EV_SW_NUM) % EV_SW_NUM) == EV_AR3) ||
-                              (((code - EV_PUB_START + EV_SW_NUM) % EV_SW_NUM) == EV_FA_HZ) || (((code - EV_PUB_START + EV_SW_NUM) % EV_SW_NUM) == EV_FA_LL_HZ); // 0-fz soe;1-hz soe
-                // 延时soe入QUEUE
-                if ((g_soe_queue.fzsoe_delay_flag == 0) && (g_tRelay[sw].run_stu.sw == 2) && (!soe_fh)) // 非分闸延时SOE QUEUE转录SOE && 合位 && 分闸SOE  		fzsoe_tab[]
+                if (tAllSOE[code - EV_PUB_START + EV_SW_NUM].soe_def & SOE_TYPE_DELAY_FHZ && (value == 0))
                 {
-                    for (i = 0; i < DELAY_SOE_MAX; i++) // 大于最大缓存，直接保存SOE
+                    if (g_soe_queue.fzsoe_wait_flag)
                     {
-                        if (g_soe_queue.delay_fzsoe_tab[i].code == code) // 当前SOE已保存
+                        int i;
+                        g_soe_queue.fzsoe_delay_flag = true;
+                        g_soe_queue.fzsoe_wait_flag = false;
+                        for (i = 0; i < DELAY_SOE_MAX; i++)
                         {
-                            return; // 此次不保存数据
+                            if (g_soe_queue.delay_fzsoe_tab[i].value == 0)
+                                break;
+                            g_soe_queue.delay_fzsoe_count = i;
+                            soe_record_ev(g_soe_queue.delay_fzsoe_tab[i].code, g_soe_queue.delay_fzsoe_tab[i].value, g_soe_queue.delay_fzsoe_tab[i].v1, g_soe_queue.delay_fzsoe_tab[i].v2, g_soe_queue.delay_fzsoe_tab[i].v3);
                         }
-                        else if (g_soe_queue.delay_fzsoe_tab[i].value == 0)
+                        memset((char *)&g_soe_queue.delay_fzsoe_tab, 0, sizeof(DELAY_SOE_DATA) * DELAY_SOE_MAX); // clear delay_soe_tab[] buffer
+                        g_soe_queue.delay_fzsoe_count = 0;
+                        g_soe_queue.fzsoe_delay_flag = false;
+                    }
+                    if (g_soe_queue.hzsoe_wait_flag)
+                    {
+                        int i;
+                        g_soe_queue.hzsoe_delay_flag = true;
+                        g_soe_queue.hzsoe_wait_flag = false;
+                        for (i = 0; i < DELAY_SOE_MAX; i++)
                         {
-                            clk_time_get(&g_soe_queue.delay_fzsoe_tab[i].ts);
-                            g_soe_queue.delay_fzsoe_tab[i].value = value;
-                            g_soe_queue.delay_fzsoe_tab[i].code = code;
-                            g_soe_queue.delay_fzsoe_tab[i].v1 = v1;
-                            g_soe_queue.delay_fzsoe_tab[i].v2 = v2;
-                            g_soe_queue.delay_fzsoe_tab[i].v3 = v3;
-                            g_soe_queue.fzsoe_wait_flag = true;
-                            return; // 此次不保存数据
+                            g_soe_queue.delay_hzsoe_count = i;
+                            if (g_soe_queue.delay_hzsoe_tab[i].value == 0)
+                                break;
+                            soe_record_ev(g_soe_queue.delay_hzsoe_tab[i].code, g_soe_queue.delay_hzsoe_tab[i].value, g_soe_queue.delay_hzsoe_tab[i].v1, g_soe_queue.delay_hzsoe_tab[i].v2, g_soe_queue.delay_hzsoe_tab[i].v3);
                         }
+                        memset((char *)&g_soe_queue.delay_hzsoe_tab, 0, sizeof(DELAY_SOE_DATA) * DELAY_SOE_MAX); // clear delay_soe_tab[] buffer
+                        g_soe_queue.delay_hzsoe_count = 0;
+                        g_soe_queue.hzsoe_delay_flag = false;
                     }
                 }
-                else if ((g_soe_queue.hzsoe_delay_flag == 0) && (g_tRelay[sw].run_stu.sw == 1) && soe_fh) ////非合闸延时SOE QUEUE转录SOE && 分位 && 合闸SOE hzsoe_tab[]
+                else if (tAllSOE[code - EV_PUB_START + EV_SW_NUM].soe_def & SOE_TYPE_DELAY_FHZ && value) // 开关延时保存分/合闸动作SOE && 动作
                 {
-                    for (i = 0; i < DELAY_SOE_MAX; i++) // 大于最大缓存，直接保存SOE
+                    u8 i = 0;
+                    bool soe_fh = (((code - EV_PUB_START + EV_SW_NUM) % EV_SW_NUM) == EV_AR1) || (((code - EV_PUB_START + EV_SW_NUM) % EV_SW_NUM) == EV_AR2) || (((code - EV_PUB_START + EV_SW_NUM) % EV_SW_NUM) == EV_AR3) ||
+                                  (((code - EV_PUB_START + EV_SW_NUM) % EV_SW_NUM) == EV_FA_HZ) || (((code - EV_PUB_START + EV_SW_NUM) % EV_SW_NUM) == EV_FA_LL_HZ); // 0-fz soe;1-hz soe
+                    // 延时soe入QUEUE
+                    if ((g_soe_queue.fzsoe_delay_flag == 0) && (g_tRelay[sw].run_stu.sw == 2) && (!soe_fh)) // 非分闸延时SOE QUEUE转录SOE && 合位 && 分闸SOE  		fzsoe_tab[]
                     {
-                        if (g_soe_queue.delay_hzsoe_tab[i].code == code) // 当前SOE已保存
+                        for (i = 0; i < DELAY_SOE_MAX; i++) // 大于最大缓存，直接保存SOE
                         {
-                            return; // 此次不保存数据
+                            if (g_soe_queue.delay_fzsoe_tab[i].code == code) // 当前SOE已保存
+                            {
+                                return; // 此次不保存数据
+                            }
+                            else if (g_soe_queue.delay_fzsoe_tab[i].value == 0)
+                            {
+                                clk_time_get(&g_soe_queue.delay_fzsoe_tab[i].ts);
+                                g_soe_queue.delay_fzsoe_tab[i].value = value;
+                                g_soe_queue.delay_fzsoe_tab[i].code = code;
+                                g_soe_queue.delay_fzsoe_tab[i].v1 = v1;
+                                g_soe_queue.delay_fzsoe_tab[i].v2 = v2;
+                                g_soe_queue.delay_fzsoe_tab[i].v3 = v3;
+                                g_soe_queue.fzsoe_wait_flag = true;
+                                return; // 此次不保存数据
+                            }
                         }
-                        else if (g_soe_queue.delay_hzsoe_tab[i].value == 0)
+                    }
+                    else if ((g_soe_queue.hzsoe_delay_flag == 0) && (g_tRelay[sw].run_stu.sw == 1) && soe_fh) ////非合闸延时SOE QUEUE转录SOE && 分位 && 合闸SOE hzsoe_tab[]
+                    {
+                        for (i = 0; i < DELAY_SOE_MAX; i++) // 大于最大缓存，直接保存SOE
                         {
-                            clk_time_get(&g_soe_queue.delay_hzsoe_tab[i].ts);
-                            g_soe_queue.delay_hzsoe_tab[i].value = value;
-                            g_soe_queue.delay_hzsoe_tab[i].code = code;
-                            g_soe_queue.delay_hzsoe_tab[i].v1 = v1;
-                            g_soe_queue.delay_hzsoe_tab[i].v2 = v2;
-                            g_soe_queue.delay_hzsoe_tab[i].v3 = v3;
-                            g_soe_queue.hzsoe_wait_flag = true;
-                            return; // 此次不保存数据
+                            if (g_soe_queue.delay_hzsoe_tab[i].code == code) // 当前SOE已保存
+                            {
+                                return; // 此次不保存数据
+                            }
+                            else if (g_soe_queue.delay_hzsoe_tab[i].value == 0)
+                            {
+                                clk_time_get(&g_soe_queue.delay_hzsoe_tab[i].ts);
+                                g_soe_queue.delay_hzsoe_tab[i].value = value;
+                                g_soe_queue.delay_hzsoe_tab[i].code = code;
+                                g_soe_queue.delay_hzsoe_tab[i].v1 = v1;
+                                g_soe_queue.delay_hzsoe_tab[i].v2 = v2;
+                                g_soe_queue.delay_hzsoe_tab[i].v3 = v3;
+                                g_soe_queue.hzsoe_wait_flag = true;
+                                return; // 此次不保存数据
+                            }
                         }
                     }
                 }
             }
-        }
 #endif
-        ev = &soe_get_buffer(&extarg)->es_ev;
-        ev->ev_type = SOE_TYPE_EV;
-        if (tAllSOE[code - EV_PUB_START + EV_SW_NUM].soe_def & SOE_TYPE_FAULT) // 需上送故障记录
-        {
-            ev->ev_type |= SOE_TYPE_FAULT;
-            soe_ext_arg(extarg, sw);
-        }
-        if (tAllSOE[code - EV_PUB_START + EV_SW_NUM].soe_def & SOE_TYPE_RSV3) // 关键记录 单独保存
-        {
-            ev->ev_type |= SOE_TYPE_VIP;
-        }
-        if (tAllSOE[code - EV_PUB_START + EV_SW_NUM].soe_def & SOE_TYPE_VIP) // 全参数保存
-        {
-            allarg = true;
+            ev->ev_type = SOE_TYPE_EV;
+            if (tAllSOE[code - EV_PUB_START + EV_SW_NUM].soe_def & SOE_TYPE_FAULT) // 需上送故障记录
+            {
+                ev->ev_type |= SOE_TYPE_FAULT;
+                soe_ext_arg(extarg, sw);
+            }
+            if (tAllSOE[code - EV_PUB_START + EV_SW_NUM].soe_def & SOE_TYPE_RSV3) // 关键记录 单独保存
+            {
+                ev->ev_type |= SOE_TYPE_VIP;
+            }
+            if (tAllSOE[code - EV_PUB_START + EV_SW_NUM].soe_def & SOE_TYPE_VIP) // 全参数保存
+            {
+                allarg = true;
+            }
         }
     }
+
     if (allarg) // 保存全参数
     {
 #ifdef SOE_PARA_ALL_SAVE
         soe_record_allArg(&ev->allarg[0], sw);
 #endif
     }
+
     soe_ev_set(code, value);
     ev->ev_value = value;
     ev->ev_code = code;
-    ev->ev_arg[0] = v1;
-    ev->ev_arg[1] = v2;
-    ev->ev_arg[2] = v3;
+    if (b_event_en && (0 != v1 || 0 != v2 || 0 != v3))
+    {
+        ev->ev_arg[0] = v1;
+        ev->ev_arg[1] = v2;
+        ev->ev_arg[2] = v3;
+    }
 #ifdef SOE_RECORD_DELAY
     // 延时SOE QUEUE中SOE时标获得
     // 转录SOE && QUEUE非空 && code对应 && 动作

dtu/dtu_main_t536/app/Sys.h

@@ -44,6 +44,7 @@
 装置配置  1*4+10=12
 定值区信息 10+10=18
 每个定值区占240个字节+8个字节校验码 6个区共1488 (2K)
+按照最多6个开关5个定值区计算开关定值的大小 (2000 * 4) * 5 = 40000 byte = 0x9c40 = 39.0625kByte
 
 SOE 512个，
 操作信息 512个
@@ -70,6 +71,13 @@ SOE 512
     #define EEP_SET_ADDR            ((3 * 1024) + EEP_SET_BASE) // 开关定值开始位置
 #endif /* GD_AREA_ZHONGSHAN_2020 */
 
+#define EEP_FIXVAL_DATA_SIZE        ((2000 * 4) * 5)                                    // 5个定值区 每个2000个浮点定值
+#define EEP_SET_ADDR_END            (EEP_FIXVAL_DATA_SIZE + EEP_SET_ADDR)               // 定值结束位置
+#define EEP_RUNTIMEINFO_ADDR        (EEP_SET_ADDR_END)                                  // 运行时间存放位置 8byte 64bit
+#define EEP_RUNTIMEINFO_DATA_SIZE   (16)                                                // 运行时间预留16byte
+#define EEP_SWC_ADDR                (EEP_RUNTIMEINFO_ADDR + EEP_RUNTIMEINFO_DATA_SIZE)  // 开关动作次数存放地址
+#define EEP_SWC_DATA_SIZ            (EEP_SWC_ADDR + (4 * 16))                           // 开关动作次数 2byte 合闸分闸次数 最多16个开关
+
 // 系统运行信息保存，占用256字节
 #define EEP_SYSTEM_DATA_START   ((63 * 1024) + EEP_SET_BASE)
 #define EEP_SYSTEM_DATA_END     (256 + EEP_SYSTEM_DATA_START)

dtu/dtu_main_t536/app/UnitsLib.c

@@ -181,39 +181,18 @@ void ProtectRelayInit(void)
         // 配网功能定值
         InitTR(&pR->tSDHZ.tOnXSTime, pSet->dT_X, 0);
         InitTR(&pR->tSDHZ.tOnYSTime, pSet->dT_Y, 0);
-        InitTR(&pR->tSDHZ.tOnZSTime, T_100ms * 35, 0); //  3.5秒
         InitTR(&pR->tSDHZ.tOnXLTime, pSet->dT_XL, 0);
         InitTR(&pR->tSDHZ.tOnYLTime, pSet->dT_Y, 0);
-#ifdef GD_AREA_ZHONGSHAN_2020
         InitTR(&pR->tSDHZ.tOnLLCDYLTime, pSet->dT_LL_CD, 0);
-#endif
 
         InitTR(&pR->tSDHZ.tOnBSTZTime, pSet->dT_fa_bsTz, 0);
-        InitTR(&pR->tSDHZ.tOnZLTime, T_100ms * 35, 0); //  3.5秒
-        InitTR(&pR->tSDHZ.tOnOCingTime, pSet->dT_fa_ocing, pSet->dT_Y);
-        InitTR(&pR->tSDHZ.tOnLXingTime, pSet->dT_fa_lxing, pSet->dT_Y);
-        InitTR(&pR->tSDHZ.tOnJSTime, pRunSet->dT_ldjs, 0); ////初始化单侧来电解锁计时器
-#ifdef GD_AREA_ZHONGSHAN_2020
-        InitTR(&pR->tSDHZ.tOnY_JSTime, 0, 0);
-#elif defined GD_AREA_ECZD_2020 || defined GD_AREA_ZHONGSHAN
-        InitTR(&pR->tSDHZ.tOnY_JSTime, T_1s * 6, 0);
-#else
+        InitTR(&pR->tSDHZ.tOnZLTime, T_100ms * 35, 0); // 3.5秒
+        InitTR(&pR->tSDHZ.tOnOCingTime, T_20ms, pSet->dT_Y);
+        InitTR(&pR->tSDHZ.tOnLXingTime, T_20ms, pSet->dT_Y);
+        InitTR(&pR->tSDHZ.tOnJSTime, pRunSet->dT_ldjs, 0); // 初始化单侧来电解锁计时器
         InitTR(&pR->tSDHZ.tOnY_JSTime, T_1s * 3, 0);
-#endif
+        InitTR(&pR->tSDHZ.tOnHW_FA_JSTime, T_1s * 3, 0);
 
-#if defined GD_AREA_ZHONGSHAN_2020 || defined GD_AREA_ECZD_2020 || defined GD_AREA_ZHONGSHAN
-#if defined GD_AREA_ECZD_2020
-#if defined FUNC_SET_FA_JS
-        InitTR(&pR->tSDHZ.tOnHW_FA_JSTime, pRunSet->dT_FA_JS, 0);
-#else
-        InitTR(&pR->tSDHZ.tOnHW_FA_JSTime, 5 * T_10ms, 0);
-#endif
-#else
-        InitTR(&pR->tSDHZ.tOnHW_FA_JSTime, T_1s * 6, 0);
-#endif
-#else
-        InitTR(&pR->tSDHZ.tOnHW_FA_JSTime, T_1s, 0);
-#endif
 #ifdef FA_OC_COUNT
         InitTR(&pR->tSDHZ.tFaOcCountTime, pSet->fa_oc_conut_time, 0);
 #endif
@@ -309,14 +288,17 @@ void ProtectRelayInit(void)
         InitTR(&pR->tTQHz.tTQTime, pSet->dT_tq, 0); // 同期
         InitTR(&pR->tTQHz.tTQQDTime, 0, pRunSet->dT_tq_fh);
         // 解列
-        InitTR(&pR->tDYJL.tDdyTime, pSet->dT_jl_ddy, T_20ms);   // CorrectTR(&pR->tDYJL.tDdyTime);  CorrectTR(&pR->tDYJL.tDdyTime);
-        InitTR(&pR->tDYJL.tGdyTime, pSet->dT_jl_gdy, T_20ms);   // CorrectTR(&pR->tDYJL.tGdyTime);  CorrectTR(&pR->tDYJL.tGdyTime);
-        InitTR(&pR->tDYJL.tHighTime, pSet->dT_jl_ggdy, T_20ms); // CorrectTR(&pR->tDYJL.tHighTime); CorrectTR(&pR->tDYJL.tHighTime);
-        InitTR(&pR->tDYJL.tLowTime, pSet->dT_jl_gddy, T_20ms);
+        InitTR(&pR->tJLCD.tCdTime, pSet->dT_jl_charge, T_20ms);
+
+        InitTR(&pR->tDYJL.tGdTime, pSet->dT_jl_gddy, T_20ms);
+        InitTR(&pR->tDYJL.tDTime, pSet->dT_jl_ddy, T_20ms);
+        InitTR(&pR->tDYJL.tGTime, pSet->dT_jl_gdy, T_20ms);
+        InitTR(&pR->tDYJL.tGgTime, pSet->dT_jl_ggdy, T_20ms);
 
-        InitTR(&pR->tPLJL.tDhzTime, pSet->dT_jl_dhz, T_40ms);   // CorrectTR(&pR->tPLJL.tDhzTime);   CorrectTR(&pR->tPLJL.tDhzTime);
-        InitTR(&pR->tPLJL.tHighTime, pSet->dT_jl_ghz, T_40ms);  // CorrectTR(&pR->tPLJL.tHighTime);  CorrectTR(&pR->tPLJL.tHighTime);
-        InitTR(&pR->tPLJL.tLowTime, pSet->dT_jl_lowhz, T_40ms); // CorrectTR(&pR->tPLJL.tLowTime);   CorrectTR(&pR->tPLJL.tLowTime);
+        InitTR(&pR->tPLJL.tGdTime, pSet->dT_jl_gdhz, T_40ms);
+        InitTR(&pR->tPLJL.tDTime, pSet->dT_jl_dhz, T_40ms);
+        InitTR(&pR->tPLJL.tGTime, pSet->dT_jl_ghz, T_40ms);
+        InitTR(&pR->tPLJL.tGgTime, pSet->dT_jl_gghz, T_40ms);
 
         InitTR(&pR->tDYJL.thcbs1_0ms_100ms, 0, T_100ms); // 滑差闭锁延迟返回继电器
         InitTR(&pR->tDYJL.thcbs2_0ms_100ms, 0, T_100ms);
@@ -347,7 +329,8 @@ void ProtectRelayInit(void)
         InitTR(&pR->tTZZFG_5S0ms, pRunSet->dT_ZZFG, 0);      // 无故障延时5s
         InitTR(&pR->thzbs.tBSHZTime, pSet->dT_hzbs, T_20ms); // 分闸次数过多，闭锁合闸
         InitTR(&pR->thzbs.tTw100ms100ms, T_100ms, T_100ms);
-        for (i = 0; i < 8; i++)
+        InitTR(&pR->t_lba_delay, pSet->lbla_time, WRN_RET_TIME);
+        for (i = 0; i < PROTECT_FDL_NUM; i++)
         {
             if (pRunSet->bTT_FDLTz[i])
             {
@@ -362,20 +345,82 @@ void ProtectRelayInit(void)
         fresh_set_soe(EV_TYPE_S, !g_tRelay[sw].run_stu.fa_ls, true, sw);
         fresh_set_soe(EV_TYPE_L, g_tRelay[sw].run_stu.fa_ls, true, sw);
 
-        fresh_set_soe(EV_BH_YB, FUN_ALL_EN(sw), true, sw);
-        fresh_set_soe(EV_BH_YBTT, BH_ALL_EN(sw), true, sw);
-        fresh_set_soe(EV_CHZ_YB, CHZ_ALL_EN(sw), true, sw);
-        fresh_set_soe(EV_FA_YBTT, FA_ALL_EN(sw), true, sw);
-        fresh_set_soe(EV_GOOSE_YBTT, BH_GOOSE_EN(sw), true, sw);
-        fresh_set_soe(EV_JZS_YBTT, JZS_ALL_EN(sw), true, sw);
-        fresh_set_soe(EV_TQ_YBTT, TYTQ_ALL_EN(sw), true, sw);
-        fresh_set_soe(EV_JL_YBTT, JL_ALL_EN(sw), true, sw);
-        fresh_set_soe(EV_XDLJD_YBTT, pRunSet->tSwSet[sw].btt_gnyb_xdljd, true, sw);
-        fresh_set_soe(EV_XLDXGJ_YBTT, pRunSet->tSwSet[sw].btt_gnyb_xldxgj, true, sw);
-        fresh_set_soe(EV_BTDCD_YBTT, pRunSet->tSwSet[sw].btt_gnyb_btdcd, true, sw);
-
-        fresh_set_soe(EV_KZ_YB, pRunSet->tSwSet[sw].btt_yxyb_gnzck, true, sw);
-        fresh_set_soe(EV_EDIT_YB, pRunSet->bTT_EDIT_YB, true, sw);
+        fresh_set_soe(EV_GENERAL_PRO, FUN_ALL_EN(sw), true, sw);
+        fresh_set_soe(EV_CON_PRO, BH_ALL_EN(sw), true, sw);
+        fresh_set_soe(EV_RECLOSE_PRO, CHZ_ALL_EN(sw), true, sw);
+        fresh_set_soe(EV_FA_PRO, FA_ALL_EN(sw), true, sw);
+        fresh_set_soe(EV_DFA_PRO, BH_GOOSE_EN(sw), true, sw);
+        fresh_set_soe(EV_CEN_PRO, JZS_ALL_EN(sw), true, sw);
+        fresh_set_soe(EV_SC_PRO, TYTQ_ALL_EN(sw), true, sw);
+        fresh_set_soe(EV_AUTOLIST_PRO, JL_ALL_EN(sw), true, sw);
+        fresh_set_soe(EV_CERGROUND_PRO, FUN_ALL_EN(sw) && (pRunSet->tSwSet[sw].btt_gnyb_xdljd || pRunSet->tSwSet[sw].btt_gnyb_xldxgj), true, sw);
+        fresh_set_soe(EV_BREAKLINE_PRO, FUN_ALL_EN(sw) && pRunSet->tSwSet[sw].btt_gnyb_xldxgj, true, sw);
+        fresh_set_soe(EV_PFD_PRO, FUN_ALL_EN(sw) && pRunSet->tSwSet[sw].btt_gnyb_btdcd, true, sw);
+
+        fresh_set_soe(EV_GPFPRO_SOFT, pRunSet->tSwSet[sw].btt_gnyb_cg, true, sw);
+        fresh_set_soe(EV_RECLOSEON_SOFT, pRunSet->tSwSet[sw].btt_gnyb_zdchz, true, sw);
+        fresh_set_soe(EV_BAR_TT, !pRunSet->tSwSet[sw].btt_gnyb_zdchz, true, sw);
+        fresh_set_soe(EV_FAPRO_SOFT, pRunSet->tSwSet[sw].btt_gnyb_fa, true, sw);
+        fresh_set_soe(EV_DFAPRO_SOFT, pRunSet->tSwSet[sw].btt_gnyb_dfa, true, sw);
+        fresh_set_soe(EV_CTLPRO_SOFT, pRunSet->tSwSet[sw].btt_gnyb_jzs, true, sw);
+        fresh_set_soe(EV_SC_SOFT, pRunSet->tSwSet[sw].btt_gnyb_tqhz, true, sw);
+        fresh_set_soe(EV_AUTOLIST_SOFT, pRunSet->tSwSet[sw].btt_gnyb_zdjl, true, sw);
+        fresh_set_soe(EV_CERGROUND_SOFT, pRunSet->tSwSet[sw].btt_gnyb_xdljd, true, sw);
+        fresh_set_soe(EV_BREAKLINE_SOFT, pRunSet->tSwSet[sw].btt_gnyb_xldxgj, true, sw);
+        fresh_set_soe(EV_PFD_SOFT, pRunSet->tSwSet[sw].btt_gnyb_btdcd, true, sw);
+        fresh_set_soe(EV_PROALL_SOFT, pRunSet->tSwSet[sw].btt_yxyb_gnztt, true, sw);
+        fresh_set_soe(EV_LOGICTRIP_SOFT, pRunSet->tSwSet[sw].btt_yxyb_gnzck, true, sw);
+        fresh_set_soe(EV_LOGICCLOSE_SOFT, pRunSet->tSwSet[sw].btt_yxyb_chz, true, sw);
+        fresh_set_soe(EV_YFYT_SOFT, pRunSet->bTT_EDIT_YB, true, sw);
+
+        fresh_set_soe(EV_CON_CTRL_01, pRunSet->tSwSet[sw].toc[BH_GL1].bTz || pRunSet->tSwSet[sw].toc[BH_GL1].bGj, true, sw);
+        fresh_set_soe(EV_CON_CTRL_02, pRunSet->tSwSet[sw].toc[BH_GL2].bTz || pRunSet->tSwSet[sw].toc[BH_GL2].bGj, true, sw);
+        fresh_set_soe(EV_CON_CTRL_03, pRunSet->tSwSet[sw].toc[BH_GL3].bTz || pRunSet->tSwSet[sw].toc[BH_GL3].bGj, true, sw);
+        fresh_set_soe(EV_CON_CTRL_04, pRunSet->tSwSet[sw].toc[BH_GL1].bDir, true, sw);
+        fresh_set_soe(EV_CON_CTRL_05, pRunSet->tSwSet[sw].toc[BH_GL2].bDir, true, sw);
+        fresh_set_soe(EV_CON_CTRL_06, pRunSet->tSwSet[sw].toc[BH_GL3].bDir, true, sw);
+        fresh_set_soe(EV_CON_CTRL_07, pRunSet->tSwSet[sw].toc[BH_LX1].bTz || pRunSet->tSwSet[sw].toc[BH_LX1].bGj, true, sw);
+        fresh_set_soe(EV_CON_CTRL_08, pRunSet->tSwSet[sw].toc[BH_LX2].bTz || pRunSet->tSwSet[sw].toc[BH_LX2].bGj, true, sw);
+        fresh_set_soe(EV_CON_CTRL_09, pRunSet->tSwSet[sw].toc[BH_LX3].bTz || pRunSet->tSwSet[sw].toc[BH_LX3].bGj, true, sw);
+        fresh_set_soe(EV_CON_CTRL_10, pRunSet->tSwSet[sw].bTT_bh_ptdx, true, sw);
+        fresh_set_soe(EV_CON_CTRL_11, pRunSet->tSwSet[sw].toc[BH_GLJS].bTz || pRunSet->tSwSet[sw].toc[BH_LXJS].bGj, true, sw);
+        fresh_set_soe(EV_CON_CTRL_12, pRunSet->tSwSet[sw].dT_ch_gl_tt, true, sw);
+        fresh_set_soe(EV_CON_CTRL_13, pRunSet->tSwSet[sw].dT_ch_jd_tt, true, sw);
+        fresh_set_soe(EV_CON_CTRL_14, pRunSet->tSwSet[sw].bTT_bh_xbbs, true, sw);
+        fresh_set_soe(EV_CON_CTRL_15, pRunSet->tSwSet[sw].bTT_3U0Tz || pRunSet->tSwSet[sw].bTT_3U0Gj, true, sw);
+        fresh_set_soe(EV_REC_CTRL_01, (pRunSet->tSwSet[sw].d_chz_times == 1) ? 1 : 0, true, sw);
+        fresh_set_soe(EV_REC_CTRL_02, (pRunSet->tSwSet[sw].d_chz_times == 2) ? 1 : 0, true, sw);
+        fresh_set_soe(EV_REC_CTRL_03, pRunSet->tSwSet[sw].bTT_chz_tq, true, sw);
+        fresh_set_soe(EV_REC_CTRL_04, pRunSet->tSwSet[sw].bTT_chz_wy, true, sw);
+        fresh_set_soe(EV_REC_CTRL_05, pRunSet->tSwSet[sw].bTT_IBSCHZ, true, sw);
+        fresh_set_soe(EV_FA_SLMODE, pRunSet->tSwSet[sw].bTT_fa_LL, true, sw);
+        fresh_set_soe(EV_FA_CTRL_01, pRunSet->tSwSet[sw].bTT_fa_poweron, true, sw);
+        fresh_set_soe(EV_FA_CTRL_02, pRunSet->tSwSet[sw].bTT_fa_lineon, true, sw);
+        fresh_set_soe(EV_FA_CTRL_03, pRunSet->tSwSet[sw].bTT_fa_poweroff, true, sw);
+        fresh_set_soe(EV_FA_CTRL_04, pRunSet->tSwSet[sw].bTT_fa_lineoff, true, sw);
+        fresh_set_soe(EV_FA_CTRL_05, pRunSet->tSwSet[sw].bTT_fa_gzTz, true, sw);
+        fresh_set_soe(EV_FA_CTRL_06, pRunSet->tSwSet[sw].bTT_fa_bsTz, true, sw);
+        fresh_set_soe(EV_FA_CTRL_07, pRunSet->tSwSet[sw].bTT_fa_gl2, true, sw);
+        fresh_set_soe(EV_FA_CTRL_08, pRunSet->tSwSet[sw].bTT_fa_lx2, true, sw);
+        fresh_set_soe(EV_FA_CTRL_09, pRunSet->tSwSet[sw].bTT_fa_U0Tz || pRunSet->tSwSet[sw].bTT_fa_U0Gj, true, sw);
+        fresh_set_soe(EV_FA_CTRL_10, pRunSet->tSwSet[sw].toc[FA_DLBS].bTz, true, sw);
+        fresh_set_soe(EV_FA_CTRL_11, pRunSet->tSwSet[sw].bTT_fa_ptdx, true, sw);
+        fresh_set_soe(EV_FA_CTRL_12, pRunSet->tSwSet[sw].bTT_hzbs, true, sw);
+        fresh_set_soe(EV_FA_CTRL_13, pRunSet->tSwSet[sw].bTT_fa_xbbs, true, sw);
+        fresh_set_soe(EV_FA_CTRL_14, pRunSet->tSwSet[sw].bTT_fa_yjcybs, true, sw);
+        fresh_set_soe(EV_DFA_CTRL_01, pRunSet->tSwSet[sw].tGocSet.bFA_slow, true, sw);
+        fresh_set_soe(EV_DFA_CTRL_02, pRunSet->tSwSet[sw].tGocSet.bTT_ll, true, sw);
+        fresh_set_soe(EV_DFA_CTRL_03, pRunSet->tSwSet[sw].tGocSet.bFA_gzbs, true, sw);
+        fresh_set_soe(EV_DFA_CTRL_04, pRunSet->tSwSet[sw].tGocSet.bTT_sdlost, true, sw);
+        fresh_set_soe(EV_DFA_CTRL_05, pRunSet->tSwSet[sw].tGocSet.bFA_qdch, true, sw);
+        fresh_set_soe(EV_AL_CTRL_01, pRunSet->tSwSet[sw].bTT_jl_dy, true, sw);
+        fresh_set_soe(EV_AL_CTRL_02, pRunSet->tSwSet[sw].bTT_hcbs_dy, true, sw);
+        fresh_set_soe(EV_AL_CTRL_03, pRunSet->tSwSet[sw].bTT_jl_hz, true, sw);
+        fresh_set_soe(EV_AL_CTRL_04, pRunSet->tSwSet[sw].bTT_hcbs_hz, true, sw);
+        fresh_set_soe(EV_LC_CTRL_01, pRunSet->tSwSet[sw].bTT_xdlgj || pRunSet->tSwSet[sw].bTT_xdltz, true, sw);
+        fresh_set_soe(EV_LC_CTRL_02, pRunSet->tSwSet[sw].bTT_xdl_src, true, sw);
+        fresh_set_soe(EV_LC_CTRL_03, pRunSet->tSwSet[sw].bTT_xdl_hjs, true, sw);
+
 
 #ifdef FUNC_DRIVE_JY
         InitTR(&gb_drive.tDriveUa1Time, pSet->dT_drive_ua1, 0);
@@ -424,6 +469,19 @@ void ProtectRelayInit(void)
 #ifdef FUN_JDXX
     jdxx_relayinit();
 #endif
+
+    for (i = 0; i < CFG_UART_NUM_MAX; i++)
+    {
+        fresh_set_soe(EV_COMM1_ERR + i, 1, true, 0);
+    }
+    for (i = 0; i < CFG_ETH_NUM_MAX; i++)
+    {
+        fresh_set_soe(EX_NET1_ERR + i, 1, true, 0);
+    }
+    for (i = 0; i < CFG_LINK_104_NUM; i++)
+    {
+        fresh_set_soe(EV_LINK_EQU1 + i, 1, true, 0);
+    }
 }
 
 /******************************************************************************
@@ -574,28 +632,11 @@ void ProtectRelayInit1(void)
 
         InitTR_Time(&pR->tSDHZ.tOnBSTZTime, pSet->dT_fa_bsTz, 0);
         InitTR_Time(&pR->tSDHZ.tOnJSTime, pRunSet->dT_ldjs, 0); ////初始化单侧来电解锁计时器
-#if defined GD_AREA_ZHONGSHAN_2020 || defined GD_AREA_ECZD_2020 || defined GD_AREA_ZHONGSHAN
-#if defined GD_AREA_ECZD_2020
-#if defined FUNC_SET_FA_JS
-        InitTR_Time(&pR->tSDHZ.tOnHW_FA_JSTime, pRunSet->dT_FA_JS, 0);
-#else
-        InitTR_Time(&pR->tSDHZ.tOnHW_FA_JSTime, 5 * T_10ms, 0);
-#endif
-#else
-        InitTR_Time(&pR->tSDHZ.tOnHW_FA_JSTime, T_1s * 6, 0);
-#endif
-#else
-        InitTR_Time(&pR->tSDHZ.tOnHW_FA_JSTime, T_1s, 0);
-#endif
-        InitTR_Time(&pR->tSDHZ.tOnOCingTime, pSet->dT_fa_ocing, pSet->dT_Y);
-        InitTR_Time(&pR->tSDHZ.tOnLXingTime, pSet->dT_fa_lxing, pSet->dT_Y);
-#ifdef GD_AREA_ZHONGSHAN_2020
-        InitTR_Time(&pR->tSDHZ.tOnY_JSTime, 0, 0);
-#elif defined GD_AREA_ECZD_2020 || defined GD_AREA_ZHONGSHAN
-        InitTR_Time(&pR->tSDHZ.tOnY_JSTime, T_1s * 6, 0);
-#else
+        InitTR_Time(&pR->tSDHZ.tOnHW_FA_JSTime, T_1s * 3, 0);
+
+        InitTR_Time(&pR->tSDHZ.tOnOCingTime, T_20ms, pSet->dT_Y);
+        InitTR_Time(&pR->tSDHZ.tOnLXingTime, T_20ms, pSet->dT_Y);
         InitTR_Time(&pR->tSDHZ.tOnY_JSTime, T_1s * 3, 0);
-#endif
 #ifdef FA_OC_COUNT
         InitTR_Time(&pR->tSDHZ.tFaOcCountTime, pSet->fa_oc_conut_time, 0);
 #endif
@@ -693,15 +734,17 @@ void ProtectRelayInit1(void)
         InitTR_Time(&pR->tOVER_U0TZ.tZOVTime, pSet->dBHTOverU0, T_20ms);
 
         // 解列
+        InitTR_Time(&pR->tJLCD.tCdTime, pSet->dT_jl_charge, T_20ms);
 
-        InitTR_Time(&pR->tDYJL.tDdyTime, pSet->dT_jl_ddy, T_20ms);
-        InitTR_Time(&pR->tDYJL.tGdyTime, pSet->dT_jl_gdy, T_20ms);
-        InitTR_Time(&pR->tDYJL.tHighTime, pSet->dT_jl_ggdy, T_20ms);
-        InitTR_Time(&pR->tDYJL.tLowTime, pSet->dT_jl_gddy, T_20ms);
+        InitTR_Time(&pR->tDYJL.tGdTime, pSet->dT_jl_gddy, T_20ms);
+        InitTR_Time(&pR->tDYJL.tDTime, pSet->dT_jl_ddy, T_20ms);
+        InitTR_Time(&pR->tDYJL.tGTime, pSet->dT_jl_gdy, T_20ms);
+        InitTR_Time(&pR->tDYJL.tGgTime, pSet->dT_jl_ggdy, T_20ms);
 
-        InitTR_Time(&pR->tPLJL.tDhzTime, pSet->dT_jl_dhz, T_40ms);
-        InitTR_Time(&pR->tPLJL.tHighTime, pSet->dT_jl_ghz, T_40ms);
-        InitTR_Time(&pR->tPLJL.tLowTime, pSet->dT_jl_lowhz, T_40ms);
+        InitTR_Time(&pR->tPLJL.tGdTime, pSet->dT_jl_gdhz, T_40ms);
+        InitTR_Time(&pR->tPLJL.tDTime, pSet->dT_jl_dhz, T_40ms);
+        InitTR_Time(&pR->tPLJL.tGgTime, pSet->dT_jl_ghz, T_40ms);
+        InitTR_Time(&pR->tPLJL.tGgTime, pSet->dT_jl_ghz, T_40ms);
 
         InitTR_Time(&pR->tLostVot.tLostVotTime, pSet->dT_Z, T_20ms);
         InitTR_Time(&pR->tLostVot.tLostVLockTime, 0, pSet->dT_fa_bsTz);
@@ -715,8 +758,9 @@ void ProtectRelayInit1(void)
         InitTR_Time(&pR->tSWST.tCTXXYC, T_1s * 3, WRN_RET_TIME); // CT相序异常
         InitTR_Time(&pR->tSWST.tCTYC, T_1s * 10, WRN_RET_TIME);  // CT断线
         InitTR_Time(&pR->tTZZFG_5S0ms, pRunSet->dT_ZZFG, 0);     // 无故障延时5s
+        InitTR_Time(&pR->t_lba_delay, pSet->lbla_time, 0);
 
-        for (i = 0; i < 8; i++)
+        for (i = 0; i < PROTECT_FDL_NUM; i++)
         {
             if (pRunSet->bTT_FDLTz[i])
             {
@@ -987,4 +1031,31 @@ bool PowerDirectionalRelay(long Ur, long Ui, DWORD U, long Ir, long Ii, DWORD I,
     return (bDIRB);
 }
 
+/**
+ * @brief          范围判断
+ * @author         lch (lch_work@foxmail.com)
+ * @version        1.0
+ * @date           20260115
+ * @param[in/out]  {DWORD} dI 定值
+ * @param[in/out]  {DWORD} dIdz_s 起始
+ * @param[in/out]  {DWORD} dIdz_e 结束
+ * @return         true
+ * @return         false
+ * @retval         none
+ * 
+ * @warning        none
+ * @note           none
+ */
+bool judge_range(DWORD dI, DWORD dIdz_s, DWORD dIdz_e)
+{
+    if (dIdz_s <= dI && dI < dIdz_e)
+    {
+        return (true);
+    }
+    else
+    {
+        return (false);
+    }
+}
+
 /******************************end*****************************************/

dtu/dtu_main_t536/app/UnitsLib.h

@@ -54,5 +54,6 @@ void ProtectRelayInit1(void);                         //
 bool SynJudge(long lANG1, long lANG2, DWORD dANGSET); // ͬÆÚÅбð
 long CalcAngSub(long Real1, long Imag1, long Real2, long Imag2);
 bool PowerDirectionalRelay(long Ur, long Ui, DWORD U, long Ir, long Ii, DWORD I, DWORD Umk, DWORD Imk, long sina1, long cosa1, long sina2, long cosa2);
+bool judge_range(DWORD dI, DWORD dIdz_s, DWORD dIdz_e);
 #endif
 /*******************************end***************************************/

dtu/dtu_main_t536/app/app.c

@@ -22,6 +22,7 @@
  */
 struct init_t_1 g_app_init_func[] =
     {
+        {rmtSetArray_init, ERR_CODE_INIT_SOFTWARE}, // 初始化远端参数数组
 #if (0) // xxxxxx 20220530 add 暂时屏蔽，am335x还没做授权的处理
         {auth_init, "auth_init", ERR_CODE_AUTH},
 #endif
@@ -70,7 +71,8 @@ INIT_FUNC g_app_exit_func[] =
         led_exit,
         mainimage_exit,
         auth_exit, // sunxi 20191204 added
-                   // pw_quality_exit,
+        // pw_quality_exit,
+        rmtSetArray_exit,
 };
 #define APP_EXIT_NUM (sizeof(g_app_exit_func) / sizeof(INIT_FUNC))
 

dtu/dtu_main_t536/app/defineSys.h

@@ -12,7 +12,7 @@
 #ifndef _DEFINE_SYS_H
 #define _DEFINE_SYS_H
 
-#define DEVICE_VERSION_INFORMATION "NW24_20260113_001" // NW2022意思是按照22年南网标准文件（总调）来做的
+#define DEVICE_VERSION_INFORMATION "NW24_260415_001" // NW2022意思是按照22年南网标准文件（总调）来做的
 
 #ifdef ___defineSys____//！！！此宏定义不开启，以下宏不直接开启，只用于注释显示
 
@@ -25,7 +25,7 @@
 #define KZ_OUT_TT                      // 控制出口硬压板
 #define COMM_STATION_NR                // 定义南瑞主站适应模式
 #define IECTABLE_NEWDPI_V106           // 转发表配合工具完成合并点和遥信单双点配合版本  0X01010106
-#define BHFA_YB_YK                     // 遥控保护和FA软压板投退
+#define IECTABLE_NEWTOOL_OLE           // 转发表配合工具使用第二个版本 遥信点索引号改为二字节 和 IECTABLE_NEWDPI_V106 不允许同时使用
 #define EV_GL_STATR                    // 过流启动SOE
 #define FUNC_CHZ_CHARGE_TIME		   // 重合闸充电通用一个定值，不管几次重合闸
 #define YX_DI_ERROR                    // 遥信硬件自检错误
@@ -44,7 +44,7 @@
 #define YD_TEST_REALTIME_VALUE_DISPLAY // 远动测试遥信、遥测数据显示
 #define SEC_SETVALUE_4                 // 4个定值区
 #define SEC_SETVALUE_7                 // 7个定值区
-#define SW_FAIL_SINGLE_OUT             // 开关失灵
+#define SW_FAIL_SINGLE_OUT             // 开关失灵 开关拒动发送失灵信号(动作失灵继电器)
 #define DC_OLLECT_NOT_156US_LOOPC      // DC采样在非156us循环中使用
 #define ADD_DEBUG_RECORD_FUN           // 增加调试记录功能选项
 #define ADD_DEBUG_RECORD_AUTO_SHOW_FUN // 增加调试记录功能自动显示功能
@@ -92,6 +92,7 @@
 #define GOOSE_NETTYPE_SET              // goose网络类型设置
 #define TMP_CHIP_AHT20                 // 温湿度芯片AHT20
 #define IO_CHIP_CH423S                 // 扩展IO芯片
+#define PRO_YB_LOCATION_IN_PUB         // 功能压板位于公共定值
 
 //定制功能
 #define CUSTOMIZE_BZT			//定制功能-备自投
@@ -141,10 +142,12 @@
 #define DO_KOUT_CHECK_PRESET           // 开出反校 单预置
 #define YX_RESET_TIME                  // 遥信复归时间 注意！！！跟 SOE_RECORD_DELAY 不允许同时使用
 #define YC_QUANTITY			           // 每间隔遥参数量可通过内部定值设定
+#define IECTABLE_NEWTOOL_OLE           // 转发表配合工具使用第二个版本 遥信点索引号改为二字节 和 IECTABLE_NEWDPI_V106 不允许同时使用
+#define EV_GL_STATR                    // 过流启动SOE
 
 //区分地区&客户个性化需求定义
-#if defined  GD_AREA_ECZD_2020    	//2020广东配网终端二次功能指导意见
-    #define VER_NUM 0x01111  // 应用版本号 每半个字代表1位 0x01111 01.111
+#if defined  GD_AREA_ECZD_2020    	// 配电自动化站所终端标准化技术规范书 2025版 V1.0
+    #define VER_NUM 0x01001   // 应用版本号 高8位小数点前，低8位小数点后 0x01001 01.001
     #define XDL_ZT            // 小电流接地
     #define RCD_STRAN_M       // 录波传输
     #define RCD_STRAN_S       // 录波传输
@@ -156,21 +159,20 @@
     #define IEC_QDS_HAVE
     #define YK_FA_S_L_ENBLE           // 分段联络遥控
     #define DC_OLLECT_NOT_156US_LOOPC // DC采样在非156us循环中使用
-    #define SW_FAIL_SINGLE_OUT        // 开关失灵
     #define FUNC_CHZ_CHARGE_TIME      // 重合闸充电通用一个定值，不管几次重合闸
 
 #elif defined GD_AREA_ZHONGSHAN	//中山局要求
  	#ifdef __IEC61850_GOOSE_FUNC__
-		#define VER_NUM 0x01000  // 应用版本号 每半个字代表1位 0x01111 01.111
+		#define VER_NUM 0x01001  // 应用版本号 高8位小数点前，低8位小数点后 0x01001 01.001
 	#else
-		#define VER_NUM 0x01000  // 应用版本号 每半个字代表1位 0x01111 01.111
+		#define VER_NUM 0x01001  // 应用版本号 高8位小数点前，低8位小数点后 0x01001 01.001
 	#endif
 	#define GEN_QUEUE	
 	#define RCD_STRAN_M			// 录波传输
 	#define RCD_STRAN_S			// 录波传输
 
 #elif defined GD_AREA_ZHONGSHAN_2020	//中山局2020要求
-	#define VER_NUM 0x01000  // 应用版本号 每半个字代表1位 0x01111 01.111
+	#define VER_NUM 0x01001  // 应用版本号 高8位小数点前，低8位小数点后 0x01001 01.001
 	#define PUB_SET_SECTION // 定义之后公共定值在定值区概念里面管辖
     #define ADD_DEBUG_RECORD_FUN    //增加调试记录功能选项
     #define ADD_DEBUG_RECORD_AUTO_SHOW_FUN    //增加调试记录功能自动显示功能

dtu/dtu_main_t536/app/down_panel_prog.c

@@ -231,16 +231,13 @@ static bool Is_down_program_Frame(BYTE cmd)
 
 int down_program_recv_timeout(void)
 {
-
     // łŹĘą´ŚŔí
     if (ustimer_get_duration(g_down_program.us_recv) > RECV_TIMEOUT && g_down_program.comm == RECV)
     {
         // rt_printf("program_check_period timeout:bit_prog=0x%08x,bit_echo=0x%08x.\r\n",g_program.bit_prog,g_program.bit_echo);
-
 #if 0
 		if(g_down_program.bit_echo == 0)
 		{
-			// TODO:
 			rt_printf("ĎÂÔŘÖŐÖš!\r\n");
 			g_program.bit_prog = 0;
 			g_program.bit_echo = 0;

dtu/dtu_main_t536/app/equ.c

@@ -253,7 +253,10 @@ int equ_init_file_config(void)
     g_equ_contrast.crc = g_crc_equ_cfg;
 
     // ±È¶Ô×ÊÔ´±íÎļþ
-    if ((ec->rsc_version != rsc_contrast.version) || (ec->rsc_signature != rsc_contrast.signature) || (ec->rsc_length != rsc_contrast.length) || (ec->rsc_crc != rsc_contrast.crc))
+    if ((ec->rsc_version != rsc_contrast.version) ||
+        (ec->rsc_signature != rsc_contrast.signature) ||
+        (ec->rsc_length != rsc_contrast.length) ||
+        (ec->rsc_crc != rsc_contrast.crc))
     {
         dp_err_nt_rt("equ_version = 0x%x, rsc_version = 0x%x", ec->rsc_version, rsc_contrast.version);
         dp_err_nt_rt("equ_signature = 0x%x, rsc_signature = 0x%x", ec->rsc_signature, rsc_contrast.signature);

dtu/dtu_main_t536/app/head.h

@@ -143,6 +143,7 @@
 #include "ptl_pwrm.h"
 #endif
 #include "bluetooth.h"
+#include "others.h"
 
 // ÏßËðÏà¹ØÍ·Îļþ
 #ifdef CAN_SLAVE_BOARD

dtu/dtu_main_t536/app/iectable.c

@@ -403,12 +403,15 @@ int tbl_init(void)
     }
 
     // 比对资源表文件
-    if ((brh->rsc_version != rsc_contrast.version) || (brh->rsc_signature != rsc_contrast.signature) || (brh->rsc_length != rsc_contrast.length) || (brh->rsc_crc != rsc_contrast.crc))
+    if ((brh->rsc_version != rsc_contrast.version) ||
+        (brh->rsc_signature != rsc_contrast.signature) ||
+        (brh->rsc_length != rsc_contrast.length) ||
+        (brh->rsc_crc != rsc_contrast.crc))
     {
-        rt_printf("iec_version=%4x\trsc_version=%4x\r\n", brh->rsc_version, rsc_contrast.version);
-        rt_printf("iec_signature=%4x\trsc_signature=%4x\r\n", brh->rsc_signature, rsc_contrast.signature);
-        rt_printf("iec_length=%4x\trsc_length=%4x\r\n", brh->rsc_length, rsc_contrast.length);
-        rt_printf("iec_crc=%4x\trsc_crc=%4x\r\n", brh->rsc_crc, rsc_contrast.crc);
+        dp_err_nt_rt("iec_version = 0x%4x, rsc_version = 0x%4x", brh->rsc_version, rsc_contrast.version);
+        dp_err_nt_rt("iec_signature = 0x%4x, rsc_signature = 0x%4x", brh->rsc_signature, rsc_contrast.signature);
+        dp_err_nt_rt("iec_length = 0x%4x, rsc_length = 0x%4x", brh->rsc_length, rsc_contrast.length);
+        dp_err_nt_rt("iec_crc = 0x%4x, rsc_crc = 0x%4x", brh->rsc_crc, rsc_contrast.crc);
 
         rt_free(buf);
         return -6;
@@ -422,6 +425,7 @@ int tbl_init(void)
     g_ac_table = (struct ac_table *)(buf + brh->ac_addr);
     g_sz_table = (struct sz_table *)(buf + brh->sz_addr);
     g_dd_table = (struct dd_table *)(buf + brh->dd_addr);
+
 #ifdef FUN_DIMER_LINK
     g_di_info_merge_table = (struct di_table *)FILE_ADDR_ALGIN(buf + brh->di_db_addr + g_table_head->di_db_num * sizeof(struct di_db_table));
     g_di_info_merge_num = (brh->do_addr - brh->di_db_addr) / sizeof(struct di_table);
@@ -827,7 +831,12 @@ u8 tbl_get_yx(int i, int bDPI)
 int tbl_yd_yx(u16 begin, u16 num, u8 *yx_buf)
 {
     u8 yx;
+#if !defined IECTABLE_NEWTOOL_OLE
     u8 sw, no;
+#else
+	u8 sw;
+	u16 no; //点表索引超过255，改为了2字节
+#endif
     u16 i, j, k;
     u16 cnt, cnt_begin, cnt_yx;
 
@@ -918,8 +927,13 @@ int tbl_yd_yx(u16 begin, u16 num, u8 *yx_buf)
             {
                 for (k = 0; k < 2; k++)
                 {
+#if !defined IECTABLE_NEWTOOL_OLE
                     sw = (u8)(g_di_db_table[j].no[k] >> 8);
                     no = (u8)(g_di_db_table[j].no[k]);
+#else
+                    sw = (u8)(g_di_db_table[j].no[k] >> 16);
+                    no = (u16)(g_di_db_table[j].no[k]);
+#endif
                     yx = GetRmtYxVal(sw, no);
                     yx = g_di_db_table[j].is_inv[k] ? ((~yx) & 0x03) : yx; // 取反
                     // yx += 1; 									// 变双点
@@ -952,8 +966,13 @@ int tbl_yd_yx(u16 begin, u16 num, u8 *yx_buf)
                         break;
                     }
 
+#if !defined IECTABLE_NEWTOOL_OLE
                     no = g_di_merge_table[j].no[k] & 0xff;
                     sw = (g_di_merge_table[j].no[k] >> 8) & 0xff;
+#else
+                    no = g_di_merge_table[j].no[k] & 0xffff;
+                    sw = (g_di_merge_table[j].no[k] >> 16) & 0xffff;
+#endif
 
                     yx = GetRmtYxVal(sw, no);
                     yx = g_di_merge_table[j].is_inv[k] ? ((~yx) & 0x03) : yx; // 取反
@@ -1150,7 +1169,6 @@ int tbl_yd_dd(u16 begin, u16 num, u8 *dd_buf)
 */
 void tbl_getdiname(WORD owner, WORD index, char *name)
 {
-
     if (index == 0)
     {
         sprintf(name, "备用点");
@@ -1324,12 +1342,12 @@ int tbl_getname_sz(WORD tbl_type, WORD tbl_index, char *name)
 
     return -1;
 }
+
 void tbl_getname(WORD tbl_type, WORD tbl_index, char *name)
 {
     int sz_index;
 
     if (tbl_type == RES_TYPE_YX)
-
     {
         sz_index = tbl_get_sz_index_yx(tbl_index);
         if (tbl_getname_sz(tbl_type, sz_index, name) < 0)
@@ -1338,7 +1356,6 @@ void tbl_getname(WORD tbl_type, WORD tbl_index, char *name)
         }
     }
     else if (tbl_type == RES_TYPE_YC)
-
     {
         sz_index = tbl_get_sz_index_yc(tbl_index);
         if (tbl_getname_sz(tbl_type, sz_index, name) < 0)
@@ -1355,7 +1372,6 @@ void tbl_getname(WORD tbl_type, WORD tbl_index, char *name)
         }
     }
     else if (tbl_type == RES_TYPE_DD)
-
     {
         sz_index = tbl_index;
         if (tbl_getname_sz(tbl_type, sz_index, name) < 0)
@@ -1380,14 +1396,18 @@ void _tbl_link_ch_to_text(unsigned char ch, char *buf)
 int tbl_printf(void)
 {
     int i, j;
+#if !defined IECTABLE_NEWTOOL_OLE
     u8 owner, indexno;
+#else
+	u16 owner, indexno;
+#endif
     char name[64];
 
     rt_printf("di单点点表:\r\n");
     rt_printf("cp\tsw\tno\tis_inverse\tDPI\r\n");
     for (i = 0; i < g_table_head->di_num; i++)
     {
-        //		tbl_getdiname(g_di_table[i].owner,g_di_table[i].indexno,name);
+        // tbl_getdiname(g_di_table[i].owner,g_di_table[i].indexno,name);
         tbl_getname(RES_TYPE_YX, i, name);
         rt_printf("%x,\t%d,\t%d,\t%d,\t\t%d,\t%s\r\n",
                   g_di_table[i].cp,
@@ -1407,7 +1427,11 @@ int tbl_printf(void)
     rt_printf("no\towner\tindexno\tis_inverse\r\n");
     for (i = 0; i < g_table_head->di_db_num; i++)
     {
+#if !defined IECTABLE_NEWTOOL_OLE
         owner = (g_di_db_table[i].no[0] & 0xFF00) >> 8;
+#else
+        owner = (g_di_db_table[i].no[0]) >> 16;
+#endif
         indexno = g_di_db_table[i].no[0];
 
         tbl_getdiname(owner, indexno, name);
@@ -1418,7 +1442,11 @@ int tbl_printf(void)
                   g_di_db_table[i].is_inv[0],
                   name);
 
+#if !defined IECTABLE_NEWTOOL_OLE
         owner = (g_di_db_table[i].no[1] & 0xFF00) >> 8;
+#else
+        owner = (g_di_db_table[i].no[1]) >> 16;
+#endif
         indexno = g_di_db_table[i].no[1];
 
         tbl_getdiname(owner, indexno, name);
@@ -1441,11 +1469,15 @@ int tbl_printf(void)
             {
                 break;
             }
+#if !defined IECTABLE_NEWTOOL_OLE
             owner = (g_di_merge_table[i].no[j]) >> 8;
+#else
+            owner = (g_di_merge_table[i].no[j]) >> 16;
+#endif
             indexno = g_di_merge_table[i].no[j];
 
             tbl_getdiname(owner, indexno, name);
-            rt_printf("%x,\t%d,\t%d,\t%d,\t%d,\t%x,\t%x,\t%s\r\n",
+            printf("%x,\t%d,\t%d,\t%d,\t%d,\t%x,\t%x,\t%s\r\n",
                       g_di_merge_table[i].cp,
                       g_di_merge_table[i].is_inv_all,
                       owner,

dtu/dtu_main_t536/app/iectable.h

@@ -96,10 +96,17 @@ struct rsc_file_head_data
 // DI资源表描述32byte
 struct di_rsc
 {
+#if !defined IECTABLE_NEWTOOL_OLE
     u8 is_real;                  // 是否实点
     u8 indexno;                  // 在归属中的索引号
     char name[EQU_CFG_NAME_LEN]; // DI名称
     u8 reserved[10];
+#else
+    u16 indexno;                 // 在归属中的索引号
+    char name[EQU_CFG_NAME_LEN]; // DI名称
+    u16 is_real;                 // 是否实点
+    u8 reserved[8];
+#endif
 };
 
 // DO资源表描述32byte
@@ -214,6 +221,7 @@ struct table_file_head_data
 // DI点表描述8byte
 struct di_table
 {
+#if !defined IECTABLE_NEWTOOL_OLE
     u16 cp;        // 通讯点号
     u8 owner;      // 归属：开关1~开关12、公共0
     u8 link_ch;    // 级联设备通道
@@ -224,11 +232,22 @@ struct di_table
     u8 dpi;
     u8 tmp[15]; // 备用属性
 #endif
+#else
+    u16 cp;                     // 通讯点号
+    u8  owner;                  // 归属：开关1~开关12、公共0
+    u8  link_ch;                // 级联设备通道
+    u16 indexno;                // 在归属中的索引号
+    u8  is_inverse;             // 是否取反
+    u8  rsv;                    // 保留
+    u16 link_cp;                // 级联设备通讯点号
+    u8  reserved[2];            // 对齐
+#endif
 };
 
 // DI合并点表描述48byte
 struct di_merge_table
 {
+#if !defined IECTABLE_NEWTOOL_OLE
     u16 cp;         // 通讯点号
     u8 is_inv_all;  // 合并点是否取反
     u8 reserved[1]; // 对齐
@@ -239,14 +258,27 @@ struct di_merge_table
     u8 link_ch[20];
     u8 tmp[12];
 #endif
+#else
+    u16 cp;                     // 通讯点号
+    u8  is_inv_all;             // 合并点是否取反
+    u8  rsv;                    // 保留
+    u32 no[20];                 // 资源表点号：高16位表示归属，低16位表示索引号
+    u8  is_inv[20];             // 各单点是否取反
+#endif
 };
 
 // DI双点点表描述(8byte)
 struct di_db_table
 {
+#if !defined IECTABLE_NEWTOOL_OLE
     u16 cp;       // 通讯点号
     u16 no[2];    // 资源表点号：高8位表示归属，低8位表示索引号。第0个为合位，第1个为分位。
     u8 is_inv[2]; // 各单点是否取反
+#else
+    u16 cp;                     // 通讯点号
+    u8  is_inv[2];              // 各单点是否取反
+    u32 no[2];                  // 资源表点号：高16位表示归属，低16位表示索引号。第0个为合位，第1个为分位。
+#endif
 };
 
 // DO点表描述8byte

dtu/dtu_main_t536/app/main.c

@@ -19,6 +19,8 @@
 #include <sys/prctl.h>
 #include <unistd.h>
 #include <sys/syscall.h>
+#include <inttypes.h>
+#include <time.h>
 
 // 系统秒，从程序启动时刻算起
 u32 g_tick_secs;
@@ -155,11 +157,15 @@ int app_main(void *unused)
 #endif
 
 #if (1) /* 打印信息测试函数 */
+    // extern int test_read_pin(void);
+    // test_read_pin();
+
+    dp_info_nt("开关个数 SWITCH_NUM_MAX = %d", SWITCH_NUM_MAX);
     dp_info_nt("最大定值个数 MAX_SET_NUMBER = %d", MAX_SET_NUMBER);
     dp_info_nt("装置参数 EQUIP_PARA_NUMBER = %d, PARA_NUM = %d", EQUIP_PARA_NUMBER, PARA_NUM);
-    dp_info_nt("保护定值 SW_SET_NUMBER = %d, SW_SET_NUMBER = %d", SW_SET_NUMBER, SW_SET_NUMBER);
-    dp_info_nt("开关个数 SWITCH_NUM_MAX = %d, 全部开关保护定值总个数 SET_NUMBER = %d", SWITCH_NUM_MAX, SET_NUMBER);
+    dp_info_nt("开关定值 SW_SET_NUMBER = %d, SET_NUM = %d", SW_SET_NUMBER, SET_NUM);
     dp_info_nt("公共定值 PUB_SET_NUMBER = %d, SET_PUB_NUM = %d", PUB_SET_NUMBER, SET_PUB_NUM);
+    dp_info_nt("全部开关保护定值总个数 SET_NUMBER = %d", SET_NUMBER);
     dp_info_nt("内部定值 CSTSET_NUMBER = %d, CSTSET_NUM = %d", CSTSET_NUMBER, CSTSET_NUM);
     dp_info_nt("固有参数 FIXEDSET_TABLE_NUMBER = %d", FIXEDSET_TABLE_NUMBER);
     msleep(100);
@@ -175,9 +181,9 @@ int app_main(void *unused)
     msleep(500);
     led_info_printf();
     msleep(500);
-    // extern int test_kc_function(void);
-    // test_kc_function();
     // msleep(500);
+    tbl_printf();
+    msleep(500);
 #endif
 
     rt_err_printf();
@@ -198,6 +204,14 @@ int app_main(void *unused)
     dp_err_nt_rt("tRunPara.dTBatBegin = %d", tRunPara.dTBatBegin);
     dp_err_nt_rt("tRunPara.dTBatInterval = %d", tRunPara.dTBatInterval);
     dp_err_nt_rt("pRunSet->tSwSet[0].d_chz_times = %d", pRunSet->tSwSet[0].d_chz_times);
+
+    dp_info_nt_rt("EEP_SET_ADDR = 0x%x", EEP_SET_ADDR);
+    dp_info_nt_rt("EEP_FIXVAL_DATA_SIZE = 0x%x", EEP_FIXVAL_DATA_SIZE);
+    dp_info_nt_rt("EEP_SET_ADDR_END = 0x%x", EEP_SET_ADDR_END);
+    dp_info_nt_rt("EEP_SYSTEM_DATA_START = 0x%x", EEP_SYSTEM_DATA_START);
+    dp_info_nt_rt("EEP_SOE_ADDR = 0x%x", EEP_SOE_ADDR);
+    dp_info_nt_rt("EEP_OPERATE_ADDR = 0x%x", EEP_OPERATE_ADDR);
+    dp_info_nt_rt("EEP_VIP_ADDR = 0x%x", EEP_VIP_ADDR);
 #endif
 
     {
@@ -207,6 +221,37 @@ int app_main(void *unused)
         gps_get_time(&ts);
         timespec_to_rtc(ts, &ct, 1);
         rt_printf("当前时间: %04d-%02d-%02d %02d:%02d:%02d\r\n", ct.year + 2000, ct.month, ct.day, ct.hour, ct.min, ct.ms / 1000);
+
+#if (1)
+        struct tm *local_time_gps = localtime(&ts.tv_sec);
+        if (local_time_gps == NULL)
+        {
+            perror("localtime failed");
+            return EXIT_FAILURE;
+        }
+        int ms_part_gps = ts.tv_nsec / 1000000;
+        dp_info_nt_rt("%04d-%02d-%02d %02d:%02d:%02d %03dms(GPS)",
+                      local_time_gps->tm_year + 1900, local_time_gps->tm_mon + 1, local_time_gps->tm_mday,
+                      local_time_gps->tm_hour, local_time_gps->tm_min, local_time_gps->tm_sec, ms_part_gps);
+
+        struct timespec t_ts;
+        int l_ret_ct = clock_gettime(CLOCK_REALTIME, &t_ts);
+        dp_info_nt_rt("l_ret_ct = %d, time %lu, %lu", l_ret_ct, t_ts.tv_sec, t_ts.tv_nsec);
+
+        u64 ullreturntime = t_ts.tv_sec * 1000 + t_ts.tv_nsec / 1000000;
+        dp_info_nt_rt("ullreturntime  %" PRIu64 "", ullreturntime);
+
+        struct tm *local_time = localtime(&t_ts.tv_sec);
+        if (local_time == NULL)
+        {
+            perror("localtime failed");
+            return EXIT_FAILURE;
+        }
+        int ms_part = t_ts.tv_nsec / 1000000;
+        dp_info_nt_rt("%04d-%02d-%02d %02d:%02d:%02d %03dms",
+                      local_time->tm_year + 1900, local_time->tm_mon + 1, local_time->tm_mday,
+                      local_time->tm_hour, local_time->tm_min, local_time->tm_sec, ms_part);
+#endif
     }
 #if defined(CPU_AM335X)
     watchdog_unregister_module();
@@ -285,6 +330,7 @@ int app_main(void *unused)
         clk_app();
         AppPolling(); // 设备状态处理，如点灯等
         create_set_file();
+		check_rtc_write();
 
 #ifdef TMP_CHIP_AHT20
         aht20_task();

dtu/dtu_main_t536/app/net_104.c

@@ -834,6 +834,11 @@ NET_BEGIN:
                 {
                     msleep(100);
                 }
+
+                // 测试发现修改默认网关后创建socket在bind的时候会返回地址占用而失败
+                // 此处跳转重新执行bind需加点延时，否则会由于旧socket还未完成关闭而导致bind失败
+                msleep(1000);
+
                 // 置为初始化
                 g_net_reinit[net] = NET_SOCKET_INIT;
                 rt_printf("net_104_thread:链路重新初始化!\r\n");
@@ -875,7 +880,7 @@ NET_BEGIN:
                 // 调用recv时，如果返回0，则表示对端关闭；返回负数，表示出错
                 rt_printf("net_104_thread:rt_recv(ret=%d)\r\n", len);
 
-                // TODO:以下休眠语句必须屏蔽，否则net_104_close会延时调用，
+                // 以下休眠语句必须屏蔽，否则net_104_close会延时调用，
                 // 导致主循环可以在此断开的socket上继续发送数据，引起系统异常。
                 // msleep(100);
                 break;
@@ -1980,7 +1985,7 @@ NET_BEGIN:
                 // 调用recv时，如果返回0，则表示对端关闭；返回负数，表示出错
                 rt_printf("net_104_thread:rt_recv(ret=%d)\r\n", len);
 
-                // TODO:以下休眠语句必须屏蔽，否则net_104_close会延时调用，
+                // 以下休眠语句必须屏蔽，否则net_104_close会延时调用，
                 // 导致主循环可以在此断开的socket上继续发送数据，引起系统异常。
                 // msleep(100);
                 break;

dtu/dtu_main_t536/app/net_104link.c

@@ -43,7 +43,7 @@ int _net_104link_thread(int net);
 /*------------------------------ 外部函数 -------------------------------------
 外部函数供其它实体文件引用，必须仔细检查传入参数的合法性.
 */
-//	 TODO: 需要确认是否需要重新初始化
+// TODO: 需要确认是否需要重新初始化
 int net_104link_init(void)
 {
 #if 1
@@ -389,7 +389,7 @@ int _net_104link_thread(int net);
 /*------------------------------ 外部函数 -------------------------------------
 外部函数供其它实体文件引用，必须仔细检查传入参数的合法性.
 */
-//   TODO: 需要确认是否需要重新初始化
+// TODO: 需要确认是否需要重新初始化
 int net_104link_init(void)
 {
     char buf[32];

dtu/dtu_main_t536/app/net_debug.c

@@ -206,7 +206,7 @@ int net_debug_s_exit(void)
 }
 #endif
 
-//   TODO: 需要确认是否需要重新初始化
+// TODO: 需要确认是否需要重新初始化
 int net_debug_init(void)
 {
     int ret;
@@ -356,6 +356,8 @@ R:
 r:查看实时线程状态\r\n \
 s:复位实时线程状态\r\n \
 S:ADC采样状态\r\n \
+v:遥调点表打印\r\n \
+w:录波修正\r\n \
 其它：关闭所有监视信息\r\n \
 \r\n>:";
 #endif
@@ -682,6 +684,19 @@ void net_debug_app(void)
     }
     break;
 #endif
+    case 'v':
+    {
+        g_print_to_net = 1;
+        printf_myRmtSetArray();
+    }
+    break;
+
+    case 'w':
+    {
+        g_print_to_net = 1;
+        enable_lb_zero_adjust();
+    }
+    break;
 
     default:
 #ifdef CAN_SLAVE_BOARD

dtu/dtu_main_t536/app/net_maintain.c

@@ -119,7 +119,7 @@ void net_maintain_set_sock_initflag(void)
     }
 }
 
-//   TODO: 需要确认是否需要重新初始化
+// TODO: 需要确认是否需要重新初始化
 #ifdef LINUX_KERNEL_APP
 int net_maintain_init(void)
 {

dtu/dtu_main_t536/app/oc.c

@@ -980,7 +980,6 @@ void Pro_Accheck(int sw, u32 dStep, int oc, int soe_no)
 */
 void Pro_BSTZ(int sw, u32 dStep, int oc, int soe_no)
 {
-
     bool bQDD, bTrip;
     TOC_T *poc = &g_tRelay[sw].tOC[oc];
     OC_SET *pSet = &pRunSet->tSwSet[sw].toc[oc];

dtu/dtu_main_t536/app/oc.h

@@ -35,7 +35,7 @@ typedef union UOCFLAG
         DWORD bQD : 1;      // 启动
         DWORD bGj : 1;      // 告警
         DWORD bTz : 1;      // 跳闸
-        DWORD bXBbs : 1;    // 谐波闭锁
+        DWORD bXBbs : 1;    // 谐波闭锁 智能分布式使用
         DWORD bBSCH : 1;    // 闭锁重合
         DWORD bCYL : 1;     // 曾有流
         DWORD bTripBak : 1; // 跳闸动作备份
@@ -68,8 +68,8 @@ enum
     FA_LX,      // FA零序故障
     FA_GL2,     // FA相间告警
     FA_LX2,     // FA零序告警
-    FA_DLBS,    // 大电流闭锁
-    BH_DLBS,    // 常规保护大电流闭锁
+    FA_DLBS,    // 大电流闭锁 FA非遮断
+    BH_DLBS,    // 常规保护大电流闭锁 常规非遮断
     BH_OVI_ZZ,  // 电流重载
     BH_OVI_GZ,  // 电流过载
     BH_OVI,     // 电流越限

dtu/dtu_main_t536/app/others.c

@@ -0,0 +1,489 @@
+/*******************************************************************************
+版权所有：	珠海欧力配网自动化股份有限公司
+文件名称：	others.c
+文件版本：	01.00
+创建作者:	赵海洋
+创建日期：	2021-11-03
+功能说明：	主要处理杂项和各项特殊需求功能。
+其它说明：
+注意事项:
+修改记录:
+********************************************************************************/
+
+#include "head.h"
+
+Array myRmtSetArray;  // 远端定值
+
+/**
+ * @brief _get_array_size
+ * @param [in] this
+ * @return int
+ * @author ZhaoYang
+ * @date 2023-06-16
+ * @details 获取容器数组大小
+ */
+int _get_array_size(Array *this)
+{
+    if (this)
+    {
+        // return this->size + 1;
+        return this->size;
+    }
+    else
+    {
+        return -1;
+    }
+}
+
+/**
+ * @brief _constructor
+ * @param [in] this
+ * @author ZhaoYang
+ * @date 2023-06-16
+ * @details 构造函数
+ */
+void _constructor(Array *this)
+{
+    this->size = 0;
+    this->max_size = 10;
+    this->Data = (TRMTSETTABLE *)rt_malloc(this->max_size * sizeof(TRMTSETTABLE));
+    memset(this->Data, 0, this->max_size * sizeof(TRMTSETTABLE));
+}
+
+/**
+ * @brief _input
+ * @param [in] data
+ * @param [in] this
+ * @author ZhaoYang
+ * @date 2023-06-16
+ * @details 数据添加
+ */
+void _input(TRMTSETTABLE data, Array *this)
+{
+    int i;
+    TRMTSETTABLE *ptr;
+
+    if (this->size >= this->max_size)
+    {
+        this->max_size += 10;
+        ptr = (TRMTSETTABLE *)rt_malloc(this->max_size * sizeof(TRMTSETTABLE));
+        for (i = 0; i < this->size; i++)
+            ptr[i] = this->Data[i];
+        rt_free(this->Data);
+        this->Data = ptr;
+    }
+    this->Data[this->size] = data;
+    this->size += 1;
+}
+
+/**
+ * @brief _print
+ * @param [in] this
+ * @author ZhaoYang
+ * @date 2023-06-16
+ * @details 打印数据
+ */
+void _print(struct array *this)
+{
+    int i;
+    struct array *ptr = this;
+    if (ptr == NULL)
+        return;
+
+    for (i = 0; i < ptr->size; i++)
+    {
+        rt_printf("data is 0x%04x %d %d %d %d\n", ptr->Data[i].di, ptr->Data[i].unit,
+                  ptr->Data[i].group, ptr->Data[i].offset, ptr->Data[i].index);
+    }
+    return;
+}
+
+/**
+ * @brief _return_index_value
+ * @param [in] this
+ * @param [in] index
+ * @return int
+ * @author ZhaoYang
+ * @date 2023-06-16
+ * @details
+ */
+TRMTSETTABLE *_return_index_value(Array *this, int index)
+{
+    if (this == NULL)
+        return NULL;
+    return &(this->Data[index]);
+}
+
+/**
+ * @brief _denstructor
+ * @param [in] this
+ * @author ZhaoYang
+ * @date 2023-06-16
+ * @details 析构对象
+ */
+void _denstructor(Array *this)
+{
+    int i = 0;
+    if (this == NULL)
+        return;
+    for (i = 0; i < this->max_size; i++)
+        memset(&(this->Data[i]), 0, sizeof(TRMTSETTABLE));
+    rt_free(this->Data);
+}
+
+/**
+ * @brief Init
+ * @param [in] this
+ * @author ZhaoYang
+ * @date 2023-06-16
+ * @details
+ */
+void Init(Array *this)
+{
+    this->Input = _input;
+    this->print = _print;
+    this->get_array_size = _get_array_size;
+    this->return_index_value = _return_index_value;
+    this->Constructor = _constructor;
+    this->Destructor = _denstructor;
+    this->Constructor(this);
+}
+
+/**
+ * @brief   打印遥调点表
+ * @details none
+ * @param   none
+ * @return  always 0
+ * @author  EWen
+ * @date    2025-09-02
+ * @remarks none
+ */
+int printf_myRmtSetArray(void)
+{
+    int i=0,j=0;
+    int tblnum = 0;
+    const TRMTSETTABLE *pdata=NULL;
+    const char *group[4]={"公共定值","开关定值","装置参数","内部定值"};
+    const char *tag_name[13]= {"布尔        ","小整形      ","无符号小整形","短整形      ","无符号短整形","整形        ",\
+                               "无符号整形  ","长整形      ","无符号长整形","单精度浮点  ","双精度浮点  ","字符串     ","八位位串    "};
+    const uint8_t tag[13] =   {BOOL_R,TINY_R,UTINY_R,SHORT_R,USHORT_R,INT_R, UINT_R,LONG_R,ULONG_R,FLOAT_R,DOUBLE_R,STR_R,STR_E};
+
+    if(myRmtSetArray.size != 0)
+    {
+        tblnum = myRmtSetArray.size;
+        rt_printf("配置的遥调点表。\r\n");
+    }
+    else
+    {
+        tblnum = RMT_SET_TABLE_NUMBER;
+        rt_printf("默认的遥调点表。\r\n");
+    }
+
+    rt_printf("点号\t\t类型\t\t分组\t\t偏移\t\t系数\t\t定值\r\n");
+
+    for(i=0; i<tblnum; i++)
+    {
+        if(myRmtSetArray.size != 0)
+        {
+            pdata = &myRmtSetArray.Data[i];
+        }
+        else
+        {
+            pdata = &tRmtsettable[i];
+        }
+
+        rt_printf("0x%04x(%d)\t",pdata->di,pdata->di);
+        for(j = 0; j < 13; j++)
+        {
+            if(pdata->unit == tag[j]) break;
+        }
+        rt_printf("%s\t%s\t%d\t\t%.4f\t\t",tag_name[j],group[pdata->group],pdata->offset,pdata->rate);
+
+        if(pdata->group == RMT_GRP_EQSET)
+        {
+            rt_printf("%s\r\n",tEquipParaTable[pdata->index].szName);
+        }
+        else if(pdata->group == RMT_GRP_SWSET)
+        {
+            rt_printf("%s\r\n",tSwSetTable[pdata->index].szName);
+        }
+        else if(pdata->group == RMT_GRP_PUSET)
+        {
+            rt_printf("%s\r\n",tPubSetTable[pdata->index].szName); 
+        }
+        else if(pdata->group == RMT_GRP_CSSET)
+        {
+            rt_printf("%s\r\n",tCstSetTable[pdata->index].szName); 
+        }
+        else
+        {
+            rt_printf("错误分组\r\n");
+        }
+    }
+
+    return 0;
+}
+
+/**
+ * @brief rmtSetArray_init
+ * @author ZhaoYang
+ * @date 2023-06-19
+ * @details 远端参数初始化
+ */
+int rmtSetArray_init(void)
+{
+    Init(&myRmtSetArray);
+    return 0;
+}
+
+/**
+ * @brief rmtSetArray_exit
+ * @author ZhaoYang
+ * @date 2023-06-19
+ * @details 远端参数退出
+ */
+int rmtSetArray_exit(void)
+{
+    myRmtSetArray.Destructor(&myRmtSetArray);
+    myRmtSetArray.size = 0;
+    return 0;
+}
+
+/**
+ * @brief Set the remote parse csv object
+ * @author ZhaoYang
+ * @date 2023-06-13
+ * @details 解析远端遥调表
+ */
+void set_remote_parse_csv(void)
+{
+	u32 i,file_length;
+	u8 *filebuf;
+	u8  filestr[128],*pstr,strlenth;
+	off_t pos;
+	int fp = rt_file_open("/app/data/ppl_tbl.csv", O_RDONLY, 0);
+	u8 have_check = 0;
+	u8 dot_count = 0;
+	int ret=0;
+
+	if (IS_ERR(fp)) {
+		rt_printf("ppl_tbl open failed.\n");
+		return;
+	}
+
+	// 得到文件长度
+
+	file_length = rt_file_getfile_size(fp);
+	if(file_length <= 0)
+	{
+		rt_printf("ppl_tbl file length is 0.\n");
+		rt_file_close(fp,0);
+		return; 	
+	}
+
+	// 分配内存
+	filebuf = rt_malloc(file_length);
+	if((filebuf) == NULL)
+	{
+		rt_printf("ppl_tbl file rt_malloc errors.\n");
+		rt_file_close(fp,0);
+		return; 	
+	}
+
+	pos = 0;
+	if(rt_file_read(fp,filebuf,file_length,&pos) != file_length)
+	{
+		rt_printf("ppl_tbl file rt_file_read errors.\n");
+		rt_file_close(fp,0);
+		rt_free(filebuf);
+		return;
+	}
+	pstr = filestr;
+	strlenth=0;   // 纠错处理
+	//找到\r\n位置，得到一行长度
+	for(i = 0; i < file_length; i++)
+	{
+		*pstr++=filebuf[i];
+		strlenth++;
+		if(filebuf[i] == 0x0a||strlenth>=128)
+		{
+			if(have_check == 0)
+			{
+				// 新旧版本遥调点表结构不同，新版的增加了一列系数，此处做个简单的检查
+				u8 j = 0;
+				have_check = 1;
+				for(j = 0 ; j < i ; j++)
+				{
+					if(filebuf[j] == 0x2c)//","
+						dot_count++;
+				}
+				if(dot_count<6)
+				{
+					ret = -1;
+					rt_printf("遥调点表文件为旧版本,不匹配,需要更新!\r\n");
+					break;
+				}
+			}
+			pstr-=1;  //  去掉回车(Unix:LF)
+			*pstr='\0';
+			ret = set_remote_parse_data(filestr);
+			if(ret != 0) break;
+			pstr=filestr;
+			strlenth=0;
+		}
+	}
+	// rt_printf("the array size is :%d.\n",myRmtSetArray.get_array_size(&myRmtSetArray));
+	// myRmtSetArray.print(&myRmtSetArray);
+	if(ret != 0)
+	{
+		rmtSetArray_exit();
+		rt_err_set(ERR_CODE_RMT,ret);
+	}
+	rt_file_close(fp,0);	// 关闭文件
+	rt_free(filebuf);		// 释放内存
+}
+
+int set_remote_parse_data(u8 *buf)
+{
+	u8 str[256];
+	TRMTSETTABLE tmp={0};
+	int i,len=0,val=0;
+	float fval = 0;
+
+	for ( i = 0; i < 6; i++)
+	{
+		switch (i)
+		{
+		case 0:
+			len=iec_findchardot(buf,str);
+			if(len==0)	return -1;
+			val=strtoul(str,NULL,16);
+			tmp.di = val;
+			break;
+		
+		default:
+			buf+=len+1;
+			len=iec_findchardot(buf,str); 
+			if(len==0)	return -2;
+			if(i != 4)
+			{
+				val=strtoul(str,NULL,10);
+			}
+			else
+			{
+				fval=atof1(str);
+			}
+			switch (i)
+			{
+			case 1:
+				tmp.unit = val;
+				break;
+			case 2:
+				tmp.group = val;
+				break;
+			case 3:
+				tmp.offset = val;
+				break;
+			case 4:
+				tmp.rate = fval;
+			case 5:
+				tmp.index = val;
+				break;
+			
+			default:
+				break;
+			}
+			break;
+		}
+	}
+
+	if(tmp.di < 0x8001 || tmp.group >= RMT_GRP_NUMBER || tmp.unit > 45)
+	{
+		return -3;
+	}
+
+	myRmtSetArray.Input(tmp,&myRmtSetArray);
+	return 0;
+}
+
+/**
+ * @brief   公共定值同步到开关定值
+ * @details 此处同步是为了液晶显示一致
+ * @param   none
+ * @return  none
+ * @author  EWen
+ * @date    2025-03-26
+ * @remarks none
+ */
+#if 0
+void pub_set2sw_set(void)
+{
+    bool need2update = false;
+    int sw = 0,i = 0,pubindex = 0,swindex = 0;
+    SET_VALUE *psetbuf = NULL;
+
+    if(!pRunSet->bTT_PUB_SET_TO_SW) return;
+
+    psetbuf = rt_malloc(SET_NUMBER*4);	
+    if(!psetbuf)
+	{
+		rt_printf("\r\npub_set2sw_set,分配定值缓冲区错误!\r\n");
+		return;
+	}
+
+    if(!ReadSet(0,(void *)psetbuf))  // 读定值
+	{
+		GetDefSet((float*)psetbuf);
+	}
+
+    for(sw = 0; sw < SWITCH_NUM_MAX; sw++)
+    {
+        for(i = 0; i < 3; i++)
+        {
+            if(i == 0)
+            {
+                pubindex = SET_PUB_OVLOAD_TT;
+                swindex= SET_OVLOAD_TT;
+            }
+            else if (i == 1)
+            {
+                pubindex = SET_PUB_DLGZ_TT;
+                swindex= SET_DLGZ_TT;
+            }
+            else
+            {
+                pubindex = SET_PUB_DLYX_TT;
+                swindex= SET_DLYX_TT;
+            }
+
+            if((WORD)psetbuf[pubindex].ff != ((WORD)psetbuf[swindex+sw*SW_SET_NUMBER+PUB_SET_NUMBER].ff) \
+            || (DWORD)(psetbuf[pubindex+1].ff*1000) != (DWORD)(psetbuf[swindex+1+sw*SW_SET_NUMBER+PUB_SET_NUMBER].ff*1000) \
+            || (DWORD)(psetbuf[pubindex+2].ff*1000) != (DWORD)(psetbuf[swindex+2+sw*SW_SET_NUMBER+PUB_SET_NUMBER].ff*1000))
+            {
+                need2update = true;
+                // 将公共定值同步到对应的开关定值中
+                // 实际功能使用的定值已经更新，此处同步是为了液晶显示一致。
+                psetbuf[swindex+sw*SW_SET_NUMBER+PUB_SET_NUMBER].ff = psetbuf[pubindex].ff;
+                psetbuf[swindex+1+sw*SW_SET_NUMBER+PUB_SET_NUMBER].ff = psetbuf[pubindex+1].ff;
+                psetbuf[swindex+2+sw*SW_SET_NUMBER+PUB_SET_NUMBER].ff = psetbuf[pubindex+2].ff;
+            }
+        }
+    }
+
+    if(need2update)
+    {
+        if(SaveSet(0,(void *)psetbuf))
+		{
+			soe_record_opt(EV_SET_OK,0);
+            rt_printf("电流越限公共定值同步到开关定值 成功! \r\n");
+        }
+        else
+        {
+            soe_record_opt(EV_SET_FAIL,0);  
+            rt_printf("电流越限公共定值同步到开关定值 失败! \r\n");
+        }
+    }
+
+    rt_free(psetbuf);
+}
+#endif

dtu/dtu_main_t536/app/others.h

@@ -0,0 +1,44 @@
+/*******************************************************************************
+版权所有：	珠海欧力配网自动化股份有限公司
+文件名称：	others.h
+文件版本：	01.00
+创建作者:	赵海洋
+创建日期：	2021-11-03
+功能说明：	主要处理杂项和各项特殊需求功能。
+其它说明：
+注意事项:
+修改记录:
+*/
+#ifndef __OTHERS_H__
+#define __OTHERS_H__
+
+typedef struct array
+{
+    TRMTSETTABLE *Data;
+    int size, max_size;
+    void (*Constructor)(struct array *);                      // 构造函数
+    void (*Input)(TRMTSETTABLE, struct array *);              // 输入数据
+    int (*get_array_size)(struct array *);                    // 获取arr的大小
+    TRMTSETTABLE *(*return_index_value)(struct array *, int); // 返回下标为index的值
+    void (*print)(struct array *);                            // 打印结果
+    void (*Destructor)(struct array *);                       // 析构函数
+} Array;
+
+extern Array myRmtSetArray;	// 远端定值
+
+void Init(Array *this);
+void _print(struct array *this);
+void _constructor(Array *this);
+void _denstructor(Array *this);
+void _input(TRMTSETTABLE data, Array *this);
+int _get_array_size(Array *this);
+TRMTSETTABLE *_return_index_value(Array *this, int index);
+int printf_myRmtSetArray(void);
+
+int rmtSetArray_init(void);
+int rmtSetArray_exit(void);
+
+
+// void pub_set2sw_set(void);
+
+#endif

dtu/dtu_main_t536/app/pda.c

@@ -702,8 +702,8 @@ static void _pda_comm_app(void)
 
         BYTE cmd_len;
         pt->arrAppBuf[0] = 0x01;
-        sprintf(&pt->arrAppBuf[1], EQUIP_NAME_STRING "\r\n版本号:V%d.%02d.%02d\r\n生成日期:\r\n%s\r\n校验码:%04XH\r\n",
-                (VER_NUM >> 16) & 0XFF, (VER_NUM >> 8) & 0XFF, VER_NUM & 0XFF, VER_TIME, m_CodeCrc);
+        sprintf(&pt->arrAppBuf[1], EQUIP_NAME_STRING "\r\n版本号:V%02d.%03d\r\n生成日期:\r\n%s\r\n校验码:%04XH\r\n",
+                (VER_NUM >> 12) & 0xff, VER_NUM & 0xfff, VER_TIME, m_CodeCrc);
         cmd_len = strlen(pt->arrAppBuf + 1) + 1;
 
         rt_printf("cmd_len = %d\r\n", cmd_len);

dtu/dtu_main_t536/app/plc.c

@@ -21,6 +21,7 @@
 // 高3位:	类型	0保留，其它为真正类型
 // 次高5位:	开关号，0为公共，其它为开关序号
 // 低8位:	点号,	0为无效点号，取值返回为0.
+#if !defined IECTABLE_NEWTOOL_OLE
 #define LP_TYPE			0XE000 // 逻辑点类型
 #define LP_SW			0X1F00 // 开关号
 #define LP_INDEX		0X00FF // 点号
@@ -32,16 +33,36 @@
 #define LP_TYPE_PLC		0XA000 // PLC 点
 #define LP_TYPE_PLC_CST	0XC000 // PLC 常量
 #define LP_TYPE_PLC_OPT	0XE000 // PLC 操作符
+#else
+#define LP_TYPE			0XE0000000 // 逻辑点类型
+#define LP_SW			0X001F0000 // 开关号
+#define LP_INDEX		0X0000FFFF // 点号
+
+#define LP_TYPE_YX		0X20000000 // 遥信点
+#define LP_TYPE_YK		0X40000000 // 遥控点
+#define LP_TYPE_YC		0X60000000 // 遥测点
+//#define LP_TYPE_EV		0X8000 // 事件点
+#define LP_TYPE_PLC		0XA0000000 // PLC 点
+#define LP_TYPE_PLC_CST	0XC0000000 // PLC 常量
+#define LP_TYPE_PLC_OPT	0XE0000000 // PLC 操作符
+#endif
 
 
 #define LP_SW_PUB		0
 #define LP_SW_BEGIN		1
 #define LP_SW_END		31
 
+#if !defined IECTABLE_NEWTOOL_OLE
 #define PLC_LOGIC_NOT	(LP_TYPE_PLC_OPT | 0X0001)
 #define PLC_LOGIC_AND	(LP_TYPE_PLC_OPT | 0X0002)
 #define PLC_LOGIC_OR	(LP_TYPE_PLC_OPT | 0X0003)
 #define PLC_LOGIC_XOR	(LP_TYPE_PLC_OPT | 0X0004)
+#else
+#define PLC_LOGIC_NOT	(LP_TYPE_PLC_OPT | 0X00000001)
+#define PLC_LOGIC_AND	(LP_TYPE_PLC_OPT | 0X00000002)
+#define PLC_LOGIC_OR	(LP_TYPE_PLC_OPT | 0X00000003)
+#define PLC_LOGIC_XOR	(LP_TYPE_PLC_OPT | 0X00000004)
+#endif
 
 /*------------------------------ 类型结构 -------------------------------------
  */
@@ -106,7 +127,11 @@ void plc_db_soe(EVENT_STRUCT *ev);
 /*------------------------------ 外部函数 -------------------------------------
 外部函数供其它实体文件引用，必须仔细检查传入参数的合法性.
 */
+#if !defined IECTABLE_NEWTOOL_OLE
 int plc_yx2index(u8 sw, u8 type)
+#else
+int plc_yx2index(u8 sw, u16 type)
+#endif
 {
     if (sw > SWITCH_NUM_MAX)
     {
@@ -161,13 +186,24 @@ SOE_DEF *plc_yx2soe(u8 sw, u8 type)
     return NULL;
 }
 
+#if !defined IECTABLE_NEWTOOL_OLE
 s32 plc_get_input(u16 ld)
+#else
+s32 plc_get_input(u32 ld)
+#endif
 {
+#if !defined IECTABLE_NEWTOOL_OLE
     u16 type, sw, no;
     s32 r;
 
     type = (ld & LP_TYPE);
     sw = (ld & LP_SW) >> 8;
+#else
+    s32 r, type, sw, no;
+
+    type = (ld & LP_TYPE);
+    sw = (ld & LP_SW) >> 16;
+#endif
     no = (ld & LP_INDEX);
 
     r = 0;
@@ -196,7 +232,11 @@ s32 plc_get_input(u16 ld)
 int plc_init_iec_table(void)
 {
     u16 i, j, ep;
+#if !defined IECTABLE_NEWTOOL_OLE
     u16 v;
+#else
+	u32 v;
+#endif
     int index;
     SOE_DEF *soe;
 
@@ -245,7 +285,11 @@ int plc_init_iec_table(void)
         // 插入操作数
         ep = 0;
         v = LP_TYPE_YX;
+#if !defined IECTABLE_NEWTOOL_OLE
         v |= (g_di_table[i].owner << 8) | g_di_table[i].indexno;
+#else
+		v |=  (g_di_table[i].owner << 16) | g_di_table[i].indexno;
+#endif
         g_plc[g_plc_num].exp[ep++] = v;
 
         // 单点取反
@@ -274,8 +318,14 @@ int plc_init_iec_table(void)
         ep = 0;
         for (j = 0; j < MIX_YX_NUMBER; j++)
         {
+#if !defined IECTABLE_NEWTOOL_OLE
             u8 no = g_di_merge_table[i].no[j] & 0xff;
             u8 owner = (g_di_merge_table[i].no[j] >> 8) & 0xff;
+#else
+            // 点表索引超过255，改为了2字节
+            u16 no = g_di_merge_table[i].no[j] & 0xffff;
+            u8 owner = (g_di_merge_table[i].no[j] >> 16) & 0xffff;
+#endif
 
             // 组合点号为空代表结束，退出。
             if (g_di_merge_table[i].no[j] == 0)
@@ -294,7 +344,11 @@ int plc_init_iec_table(void)
             }
 
             // 插入操作数
+#if !defined IECTABLE_NEWTOOL_OLE
             v = LP_TYPE_YX | (owner << 8) | no;
+#else
+			v =  LP_TYPE_YX | (owner << 16) | no;
+#endif
             g_plc[g_plc_num].exp[ep++] = v;
 
             // 单点取反
@@ -338,7 +392,12 @@ int plc_init_iec_table(void)
 int plc_init(void)
 {
     int i, j, k, index, ret;
+#if !defined IECTABLE_NEWTOOL_OLE
     u8 sw, no;
+#else
+	u8 sw;
+	u16 no; // 点表索引超过255，改为了2字节
+#endif
     u32 timeout[2] = {0};
     u32 timeout_add;
 
@@ -378,8 +437,13 @@ int plc_init(void)
     {
         for (k = 0; k < 2; k++)
         {
+#if !defined IECTABLE_NEWTOOL_OLE
             sw = (u8)(g_di_db_table[i].no[k] >> 8);
             no = (u8)(g_di_db_table[i].no[k]);
+#else
+			sw = (u8)((g_di_db_table[i].no[k] >> 16) & 0xffff);
+			no = (u16)((g_di_db_table[i].no[k]) & 0xffff);
+#endif
 
             // 得到检查索引
             index = plc_yx2index(sw, no);
@@ -673,7 +737,12 @@ static void plc_db_scan(void)
 int plc_scan(int is_rec)
 {
     static s32 r[64];
+#if !defined IECTABLE_NEWTOOL_OLE
     u16 *p, i, rp;
+#else
+    u16 i, rp;
+    u32 *p;
+#endif
 
     // 双点扫描
     plc_db_scan();
@@ -726,7 +795,7 @@ int plc_scan(int is_rec)
         if (rp != 1)
         {
             rt_err_set(ERR_CODE_PLC, 0);
-            rt_printf("plc_scan:i=%d,rp=%d\r\n", i, rp);
+            dp_err_nt_rt("plc_scan:i = %d,rp = %d", i, rp);
         }
 
         if (g_plc[i].result != r[rp - 1])

dtu/dtu_main_t536/app/plc.h

@@ -15,7 +15,7 @@
 
 /*------------------------------- 宏定义 --------------------------------------
  */
-#define PLC_EXP_NUM 64
+#define PLC_EXP_NUM 128
 #define PLC_EXP_LEN 64
 
 #define PLC_FLAG_FAULT 0X01 // 需上送故障事件
@@ -36,7 +36,11 @@ struct plc
     u8 do_owner;
     u8 do_index;
     u16 cp;
+#if !defined IECTABLE_NEWTOOL_OLE
     u16 exp[PLC_EXP_LEN];
+#else
+	u32 exp[PLC_EXP_LEN];
+#endif
 };
 
 /*------------------------------ 全局变量 -------------------------------------
@@ -51,7 +55,11 @@ extern u32 g_plc_merge_index; //
 int plc_init(void);
 int plc_exit(void);
 
+#if !defined IECTABLE_NEWTOOL_OLE
 int plc_yx2index(u8 sw, u8 type);
+#else
+int plc_yx2index(u8 sw, u16 type);
+#endif
 
 u8 plc_db_value(int index);
 void plc_db_init_value(u8 slot, u8 no, u8 v);

dtu/dtu_main_t536/app/protect.c

@@ -183,7 +183,7 @@ void quit_drive(void)
         MakeRunPara(false, false); // 恢复合分闸脉冲原来的值
         MakeRunSet(false);         // 加入先设置一次所有定值的处理，避免提前return导致没恢复原定值内容
 #endif
-        parBuf = rt_malloc(PUB_SET_NUMBER * 4);
+        parBuf = rt_malloc(SW_SET_NUMBER * 4);
 
         if (!parBuf)
         {
@@ -197,10 +197,10 @@ void quit_drive(void)
         if (!ReadPara((void *)parBuf, EEP_SET_ADDR + m_runsection * SETSIZE, SW_SET_NUMBER, &tSwSetTable[0]))
         {
             rt_err_set(ERR_CODE_SET, 0);
-            GetDefPara((void *)parBuf, PUB_SET_NUMBER, &tSwSetTable[0]);
+            GetDefPara((void *)parBuf, SW_SET_NUMBER, &tSwSetTable[0]);
         }
 
-        parBuf[SET_XDL_YB + gb_drive.sw * SW_SET_NUMBER].ff = 0;
+        parBuf[SET_TRASW_YB + gb_drive.sw * SW_SET_NUMBER].ff = 0;
 
         if (SavePara((void *)parBuf, EEP_SET_ADDR + m_runsection * SETSIZE, SW_SET_NUMBER, &tSwSetTable[0]))
         {
@@ -386,6 +386,7 @@ int protect_polling(void)
         Pro_TQHz(g_protect.sw, dTDelta); // 合环
         Pro_TQBS(g_protect.sw, dTDelta); //	手动闭锁
         Pro_3U0(g_protect.sw, dTDelta);
+        vol_jl_charge(g_protect.sw, dTDelta);
         vol_DYJL(g_protect.sw, dTDelta);
         vol_PLJL(g_protect.sw, dTDelta);
         fag_bh(g_protect.sw, dTDelta);
@@ -426,6 +427,8 @@ int protect_polling(void)
         }
 #endif
 
+        proio_run_lba(g_protect.sw, dTDelta);
+
         // 故障处理流程
         if (pR->zqd)
         {
@@ -459,6 +462,8 @@ int protect_polling(void)
 
         // 突变录波
         mutation_wave_record(g_protect.sw);
+
+        scaio_check_sw_act(g_protect.sw);
     }
 
     // 保护巡检完毕，检查事故总
@@ -833,7 +838,7 @@ static int _protect_amp_qd(u32 dStep)
         bool bY1 = false;
         bY1 |= pR->tgoc.sta.bFlag.bgzglQD || pR->tgoc.sta.bFlag.bsdQD || pR->tgoc.sta.bFlag.berrQD || pR->tgoc.sta.bFlag.bextQD || pR->tgoc.sta.bFlag.bllQD;
 
-        for (i = 0; i < 8; i++)
+        for (i = 0; i < PROTECT_FDL_NUM; i++)
         {
             bY1 |= pR->tFdl[i].sta.bFlag.bTz;
         }
@@ -1119,7 +1124,7 @@ static int _protect_zzfg_check(u32 dStep)
         bY1 |= (pR->tOC[i].sta.bFlag.bQD || pR->tOC[i].sta.bFlag.bXBbs || pR->tOC[i].sta.bFlag.bTz || pR->tOC[i].sta.bFlag.bGj);
     }
 
-    for (i = 0; i < 8; i++)
+    for (i = 0; i < PROTECT_FDL_NUM; i++)
     {
         bY1 |= pR->tFdl[i].sta.bFlag.bTz;
     }
@@ -1331,11 +1336,13 @@ static int _protect_sw_tz(u32 dStep)
         bTz |= pR->tgoc.tOc[i].sta.bFlag.bTz; // 跳闸
     }
 #endif
-    for (i = 0; i < 8; i++)
+    for (i = 0; i < PROTECT_FDL_NUM; i++)
     {
         bTz |= pR->tFdl[i].sta.bFlag.bTz;
         if (pR->tFdl[i].sta.bFlag.bTz)
+        {
             pR->tCHZ.sta.bFlag.bCDWC = false; // 重合闸放电
+        }
     }
     bTz |= pR->uGLFSX.bFlag.bFXDZ;
     bTz |= (pR->tU0TZ.uZOV.bFlag.bTz                                                               // 合后接地保护动作
@@ -1402,7 +1409,6 @@ static int _protect_sw_tz(u32 dStep)
 
             sw_do(sw, SW_DO_BHDZ, SW_DO_TYPE_ON);
             sw_do(sw, SW_DO_BHT, SW_DO_TYPE_ON);
-            sw_do(sw, SW_DO_BHT, SW_DO_TYPE_ON);
 
 #ifdef CUSTOMIZE_BZT // 备自投
             bzt_oc_sw_off(sw);
@@ -2102,7 +2108,7 @@ static bool _protect_check_fault(int sw)
     {
         bY1 |= (pR->tOC[i].sta.bFlag.bTz || pR->tOC[i].sta.bFlag.bGj);
     }
-    for (i = 0; i < 8; i++)
+    for (i = 0; i < PROTECT_FDL_NUM; i++)
     {
         bY1 |= pR->tFdl[i].sta.bFlag.bTz;
     }
@@ -2228,6 +2234,71 @@ bool fa_fun_true(int sw)
 }
 #endif
 
+/* 线路断线告警 */
+void proio_run_lba(int sw, u32 dStep)
+{
+    bool bok, bcheck, bcbase, bqdd, bqdd_d;
+    u16 soeno = EV_LBA + sw * EV_SW_NUM;
+
+    TRELAY_T *pR = &g_tRelay[sw];
+    TSWST *pSW = &pR->tSWST;
+    TSETSW *pSet = &pRunSet->tSwSet[sw];
+
+    u8 uc_mode = pSet->lbla_mode; // 线路断线判定方式 0非全相，1加判零压， 2加判零流和对应相电压低
+
+    bcheck = ((g_ui[UI_SW_INDEX(sw, SW_AC_IA)].chn_index != INDEX_INVALLID) && (g_ui[UI_SW_INDEX(sw, SW_AC_IC)].chn_index != INDEX_INVALLID));
+    bcbase = pSet->btt_gnyb_xldxgj                         // 投
+             && pSW->uSWST.bFlag.bDIHW                     // 合位
+             && (g_sw[sw].m2_min < pRunSet->dIWL_SQR[sw])  // 最小值小于无流定值
+             && (g_sw[sw].m2_max > pRunSet->dIWL_SQR[sw]); // 最大值大于无流定值
+
+    if (1 == uc_mode) // 加判零压
+    {
+        bqdd = OverRelay(g_ui[PUB_AC_U01].m2[0] > g_ui[PUB_AC_U02].m2[0] ? g_ui[PUB_AC_U01].m2[0] : g_ui[PUB_AC_U02].m2[0], pSet->lbla_zu, pSet->lbla_zufh, false); // 零压是否存在
+
+        bok = bcheck && bcbase && bqdd;
+    }
+    else if (2 == uc_mode) // 加判零流和对应相电压低
+    {
+        int ui_begin = UI_SW_INDEX_BEGIN(sw);
+        bqdd = OverRelay(g_ui[ui_begin + SW_AC_I0].m2[0], pSet->lbla_zc, pSet->lbla_zcfh, false);
+        if (g_ui[ui_begin + SW_AC_IA].m2[0] <  pRunSet->dIWL_SQR[sw])
+        {
+            bqdd_d = (g_ui[PUB_AC_UA1].m2[0] < pSet->lbla_du) ? true : false;
+        }
+        else if (g_ui[ui_begin + SW_AC_IB].m2[0] <  pRunSet->dIWL_SQR[sw])
+        {
+            bqdd_d = (g_ui[PUB_AC_UB1].m2[0] < pSet->lbla_du) ? true : false;
+        }
+        else if (g_ui[ui_begin + SW_AC_IC].m2[0] <  pRunSet->dIWL_SQR[sw])
+        {
+            bqdd_d = (g_ui[PUB_AC_UC1].m2[0] < pSet->lbla_du) ? true : false;
+        }
+
+        bok = bcheck && bcbase && bqdd_d;
+    }
+    else // 非全相
+    {
+        bok = bcheck && bcbase;
+    }
+
+    RunTR(&pR->t_lba_delay, bok, dStep);
+    if (pR->t_lba_delay.boolTrip)
+    {
+        if (soe_check(soeno) == false)
+        {
+            soe_record_ev(soeno, 1, 0, 0, 0);
+        }
+    }
+    else
+    {
+        if (soe_check(soeno) == true)
+        {
+            soe_record_ev(soeno, 0, 0, 0, 0);
+        }
+    }
+}
+
 /*------------------------------ 测试函数 -------------------------------------
 一个实体文件必须带一个本模块的测试函数来进行单元测试，如果的确不方便在本模块中
 进行单元测试，必须在此注明实际的测试位置（例如在哪个实体文件中使用哪个测试函数）.

dtu/dtu_main_t536/app/protect.h

@@ -98,6 +98,10 @@
 #define    	TAN30     	2479700525        	//tan30度*2^32
 #define    	TAN35      	3007368477         	//tan35度*2^32
 
+#ifndef PROTECT_FDL_NUM /* 非电量保护的数量 */
+#define PROTECT_FDL_NUM 6
+#endif
+
 /*------------------------------ 类型结构 -------------------------------------
 */
 
@@ -171,7 +175,7 @@ typedef struct URMTSW
 #ifdef SELF_OPEN_RELEASE
     bool bSwTz; // 开关本体分闸
 #endif
-    bool bTQHz; // 同期合闸标志
+    bool bTQHz;         // 同期合闸标志
     bool bYHExecute_fa; // FA遥控合闸标志
     bool bYTExecute_fa; // FA遥控分闸标志
     bool bHandHz_fa;    // 手动合闸
@@ -204,7 +208,6 @@ typedef struct TRELAY_T //
 
     bool bARSTFLT; // 开关自动复归事故总202004
 
-    TFDL_T tFdl[6];         // 非电量
     TOC_T tOC[BHOC_NUMBER]; // 过流保护相关
     TCH_T tCHZ;             // 重合闸
 
@@ -221,14 +224,17 @@ typedef struct TRELAY_T //
 
     TU0_T tOVER_U0TZ; // 过零序电压跳闸
 
-    TJL_T tDYJL; // 电压解列
-    TJL_T tPLJL; // 频率解列
+    TJLCD_T tJLCD; // 解列充电
+    TJL_T tDYJL;   // 电压解列
+    TJL_T tPLJL;   // 频率解列
+
+    TFDL_T tFdl[PROTECT_FDL_NUM]; // 非电量
 
     TTQHZ_T tTQHz; // 同期合闸标志
     TSDHZ_T tSDHZ; // 上电合闸标志
 
-    TGOC_T tgoc; // 方向过流goose
-    TSWST tSWST; // 开关运行状态识别
+    TGOC_T tgoc;        // 方向过流goose
+    TSWST tSWST;        // 开关运行状态识别
     RUN_STU_SW run_stu; // 位置、功能状态
 
     UBHQD uBHQD;             // 保护启动标志字
@@ -255,6 +261,8 @@ typedef struct TRELAY_T //
     JDXX_DEF tJD; // 小电流接地
 #endif
     YC_REFRESH_EN bYcRefresh; // 用于故障启动记录动作值标志
+    
+    TIMERELAY t_lba_delay;  // 线路断线告警
 } TRELAY_T;
 
 extern TRELAY_T g_tRelay[];
@@ -272,7 +280,6 @@ int protect_amp_qd_js(int sw);
 int protect_amp_lx_js(int sw);
 int protect_stat_reset(void);
 int protect_printf_process(void);
-int protect_amp_lx_js(int sw);
 void sw_op_fail(DWORD dStep);
 #ifdef YB_AUTO_SELECT
 bool fa_yb_enable(int sw);
@@ -289,9 +296,9 @@ bool fa_fun_true(int sw);
 void quit_drive(void);
 #endif
 
+void proio_run_lba(int sw, u32 dStep);
+
 #endif //_APP_H
 
 /*------------------------------ 文件结束 -------------------------------------
-*/
-
-
+ */

dtu/dtu_main_t536/app/reclose.c

@@ -503,13 +503,13 @@ static void AR_Logic(int sw, DWORD dStep)
 #ifdef PRO_AL_LOCK_HZ
     if (pRunSet->bTT_StartCHZ_judgeVolt)
     {
-        bVABL_OK = OverRelay(g_sw_pub.m2_max[2], pSet->dU_jl_ddy, pSet->dU_reclose_ddy_fh, pSW->CHZ_Judge_V_F.bVABLOK);
-        bVABH_OK = LowRelay(g_sw_pub.m2_max[2], pSet->dU_jl_gdy, pSet->dU_reclose_gdy_fh, pSW->CHZ_Judge_V_F.bVABHOK);
+        bVABL_OK = OverRelay(g_sw_pub.m2_max[2], pSet->dU_jl_ddy_rs, pSet->dU_reclose_ddy_fh, pSW->CHZ_Judge_V_F.bVABLOK);
+        bVABH_OK = LowRelay(g_sw_pub.m2_max[2], pSet->dU_jl_gdy_rs, pSet->dU_reclose_gdy_fh, pSW->CHZ_Judge_V_F.bVABHOK);
         pSW->CHZ_Judge_V_F.bVABLOK = bVABL_OK;
         pSW->CHZ_Judge_V_F.bVABHOK = bVABH_OK;
 
-        bVBCL_OK = OverRelay(g_sw_pub.m2_max[3], pSet->dU_jl_ddy, pSet->dU_reclose_ddy_fh, pSW->CHZ_Judge_V_F.bVBCLOK);
-        bVBCH_OK = LowRelay(g_sw_pub.m2_max[3], pSet->dU_jl_gdy, pSet->dU_reclose_gdy_fh, pSW->CHZ_Judge_V_F.bVBCHOK);
+        bVBCL_OK = OverRelay(g_sw_pub.m2_max[3], pSet->dU_jl_ddy_rs, pSet->dU_reclose_ddy_fh, pSW->CHZ_Judge_V_F.bVBCLOK);
+        bVBCH_OK = LowRelay(g_sw_pub.m2_max[3], pSet->dU_jl_gdy_rs, pSet->dU_reclose_gdy_fh, pSW->CHZ_Judge_V_F.bVBCHOK);
         pSW->CHZ_Judge_V_F.bVBCLOK = bVBCL_OK;
         pSW->CHZ_Judge_V_F.bVBCHOK = bVBCH_OK;
 
@@ -532,7 +532,7 @@ static void AR_Logic(int sw, DWORD dStep)
         freq0 = freq_get(0) * 65536;
         freq1 = freq_get(1) * 65536;
 
-        if (((freq0 >= pRunSet->tSwSet[sw].dU_jl_dhz) && (freq0 <= pRunSet->tSwSet[sw].dU_jl_ghz)) && ((freq1 >= pRunSet->tSwSet[sw].dU_jl_dhz) && (freq1 <= pRunSet->tSwSet[sw].dU_jl_ghz))) // 需双侧频率均满足条件才允许重合闸
+        if (((freq0 >= pRunSet->tSwSet[sw].dU_jl_dhz_rs) && (freq0 <= pRunSet->tSwSet[sw].dU_jl_ghz_rs)) && ((freq1 >= pRunSet->tSwSet[sw].dU_jl_dhz_rs) && (freq1 <= pRunSet->tSwSet[sw].dU_jl_ghz_rs))) // 需双侧频率均满足条件才允许重合闸
         {
             bFreqOK = true;
         }

dtu/dtu_main_t536/app/record.c

@@ -293,6 +293,17 @@ extern float g_freq;
 // static char g_file_buf[4096];
 char wave_name[RECORD_FILES_MAX][40];
 
+s16 g_adc_dots_rec_zero_drift[CFG_ADC_CHANNEL];
+struct rcd_zero_diff_struct
+{
+    bool enable_adj;  // 是否启用零漂修正
+    bool us0_init;    // us0确认时间已过
+    uint8_t chnl_cnt; // 采样配置通道数
+    uint32_t cfm_us0; // us0确认时间起始
+};
+
+static struct rcd_zero_diff_struct g_rcd_zero_diff;
+
 int g_wave_filetype = 1; // 录波文件格式.默认是BINARY
 
 const char *cca_yx_des[] = {
@@ -341,6 +352,7 @@ int rcd_write_cfg(struct rcd *prcd);
 int rcd_write_dat(struct rcd *prcd);
 
 void _rcd_uninit_wave(struct rcd *prcd);
+static int _rec_chnl_zero_drift_init(void);
 
 /*------------------------------ 外部函数 -------------------------------------
 外部函数供其它实体文件引用，必须仔细检查传入参数的合法性.
@@ -1458,6 +1470,10 @@ int rcd_init(void)
 
     g_rcd_init = 1;
 
+    ret = _rec_chnl_zero_drift_init();
+    if (ret != 0)
+        rt_printf("rec_chnl_zero_drift_init error ret %d\n", ret);
+
     return 0;
 }
 
@@ -2615,7 +2631,9 @@ int _rcd_save(struct rcd *prcd)
             for (i = 0; i < prcd->f_cfs.tt_a_cnt; i++)
             {
                 // 记录每个通道的数据
-                prcd->pAn[prcd->pAn_no++] = g_adc_dots_rec[cur][prcd->f_cfs.chnl[i]];
+                prcd->pAn[prcd->pAn_no] = g_adc_dots_rec[cur][prcd->f_cfs.chnl[i]];
+                prcd->pAn[prcd->pAn_no] -= g_adc_dots_rec_zero_drift[prcd->f_cfs.chnl[i]];
+                prcd->pAn_no++;
             }
 
             for (i = 0; i < prcd->f_cfs.tt_d_cnt; i++)
@@ -3743,6 +3761,186 @@ void mutation_wave_record(int sw)
     }
 }
 
+static int _rec_chnl_zero_drift_init(void)
+{
+    u16 crc;
+    u8 *buf;
+    loff_t pos;
+    u32 len;
+    int pfile;
+
+    memset(&g_rcd_zero_diff, 0, sizeof(g_rcd_zero_diff));
+    memset(g_adc_dots_rec_zero_drift, 0, sizeof(g_adc_dots_rec_zero_drift));
+
+    // rt_printf("Rec_chnl_zero_drift_init...\n");
+
+    pfile = rt_file_open("/app/data/rcd_zero_diff.bin", O_RDWR, 0);
+    if (IS_ERR(pfile))
+    {
+        return -1;
+    }
+
+    // 得到文件长度
+    len = rt_file_getfile_size(pfile);
+
+    // 分配内存
+    buf = rt_malloc(len);
+    if ((buf) == NULL)
+    {
+        rt_file_close(pfile, 0);
+        return -2;
+    }
+
+    // 读出内容
+    pos = 0;
+    if (rt_file_read(pfile, buf, len, &pos) != len)
+    {
+        rt_file_close(pfile, 0);
+        rt_free(buf);
+        return -3;
+    }
+
+    // 关闭文件
+    rt_file_close(pfile, 0);
+
+    // 检查CRC
+    crc = CrcStr(buf, len - 2);
+    if (crc != *(u16 *)(buf + len - 2))
+    {
+        rt_free(buf);
+        return -4;
+    }
+
+    if (sizeof(g_adc_dots_rec_zero_drift) == (len - 2))
+    {
+        memcpy(g_adc_dots_rec_zero_drift, buf, len - 2);
+    }
+    else
+    {
+        rt_free(buf);
+        return -5;
+    }
+
+    rt_free(buf);
+    return 0;
+}
+
+void rec_chnl_zero_drift_handle(void)
+{
+    u16 crc16;
+    loff_t pos;
+    uint8_t i = 0;
+    int dot_cnt = 0;
+    uint8_t chnl_cnt = 0;
+    uint8_t chnl_cfm_cnt = 0;
+    struct file *file_rcd_zero;
+    uint8_t chn_scal[CFG_ADC_CHANNEL] = {0};
+    int dot_sum = 0;
+
+    if ((!g_rcd_zero_diff.enable_adj) || g_adc_sync != 1 || g_rcd_init != 1)
+    {
+        return;
+    }
+
+    for (i = 0; i < UI_NUM; i++)
+    {
+        if (g_ui[i].chn_index == CFG_ADC_CHANNEL_ZERO)
+            continue; // 此通道没有配置采样类型。
+
+        chnl_cnt++;
+
+        if (i < PUB_AC_NUM)
+        {
+            // 电压
+            if (g_ui[i].e > tRunPara.dZero_U)
+            {
+                continue;
+            }
+            chnl_cfm_cnt++;
+            chn_scal[g_ui[i].chn_index] = 1;
+        }
+        else
+        {
+            // 电流
+            if (g_ui[i].e > tRunPara.dZero_I)
+            {
+                continue;
+            }
+            chnl_cfm_cnt++;
+            chn_scal[g_ui[i].chn_index] = 1;
+        }
+    }
+
+    if (!g_rcd_zero_diff.us0_init)
+    {
+        if (g_rcd_zero_diff.cfm_us0 == 0)
+        {
+            g_rcd_zero_diff.cfm_us0 = ustimer_get_origin();
+        }
+
+        if (chnl_cnt != chnl_cfm_cnt)
+        {
+            // 计时过程有通道采样值大于零漂，重新计时
+            g_rcd_zero_diff.cfm_us0 = ustimer_get_origin();
+        }
+
+        if (ustimer_get_duration(g_rcd_zero_diff.cfm_us0) >= 5000 * USTIMER_MS)
+        {
+            g_rcd_zero_diff.cfm_us0 = 0;
+            g_rcd_zero_diff.us0_init = true;
+        }
+    }
+
+    if (!g_rcd_zero_diff.us0_init)
+        return;
+
+    g_rcd_zero_diff.enable_adj = false;
+
+    for (i = 0; i < CFG_ADC_CHANNEL; i++)
+    {
+        if (chn_scal[i] != 1)
+            continue;
+
+        chnl_cnt--;
+        dot_sum = 0;
+        for (dot_cnt = 0; dot_cnt < 512; dot_cnt++)
+        {
+            dot_sum += g_adc_dots_rec[dot_cnt][i]; // 取512个点做平均
+        }
+        g_adc_dots_rec_zero_drift[i] = (s16)rt_round((float)dot_sum / 512);
+        rt_printf("zero drift[%d]=%d\r\n", i, g_adc_dots_rec_zero_drift[i]);
+    }
+
+    if (chnl_cnt == 0)
+    {
+        crc16 = CrcStr((BYTE *)g_adc_dots_rec_zero_drift, sizeof(g_adc_dots_rec_zero_drift));
+
+        file_rcd_zero = rt_file_open("/app/data/rcd_zero_diff.bin", O_CREAT | O_RDWR, 0);
+        if (IS_ERR(file_rcd_zero))
+        {
+            return;
+        }
+        pos = 0;
+        rt_file_write(file_rcd_zero, (char *)g_adc_dots_rec_zero_drift, sizeof(g_adc_dots_rec_zero_drift), &pos);
+        rt_file_write(file_rcd_zero, (char *)&crc16, sizeof(crc16), &pos);
+
+        rt_file_close(file_rcd_zero, 0);
+
+        rt_printf("录波零漂处理成功!\r\n");
+    }
+    else
+    {
+        g_rcd_zero_diff.us0_init = false;
+        rt_printf("录波零漂处理失败!有非零漂值通道\n");
+    }
+}
+
+int enable_lb_zero_adjust(void)
+{
+    g_rcd_zero_diff.enable_adj = true;
+    rt_printf("录波零漂修正开启!\r\n");
+    return 0;
+}
 
 /*------------------------------ 测试函数 -------------------------------------
 一个实体文件必须带一个本模块的测试函数来进行单元测试，如果的确不方便在本模块中

dtu/dtu_main_t536/app/record.h

@@ -65,6 +65,9 @@ int rcd_start_xdl(char *name, int sw, char **chn_name, int chn_num, int chn_leng
 int rcd_get_A_D_N(char *data, int *pA, int *pD, int *pN, int *pUI); // 获取模拟通道数，状态通道数,采样数
 
 void mutation_wave_record(int sw);
+void rec_chnl_zero_drift_handle(void);
+
+int enable_lb_zero_adjust(void);
 
 #endif //_RECORD_H_
 

dtu/dtu_main_t536/app/run_status.c

@@ -244,6 +244,18 @@ int run_status_init(void)
             prun->kzdx = 0;
         }
 
+        // 合闸回路监视
+        if ((short)g_sw[sw].di_cfg_index[SW_DI_HZHLJS] == INDEX_INVALLID)
+        {
+            prun->kzhljs_hz = 0;
+        }
+
+        // 分闸回路监视
+        if ((short)g_sw[sw].di_cfg_index[SW_DI_FZHLJS] == INDEX_INVALLID)
+        {
+            prun->kzhljs_fz = 0;
+        }
+
         // PT1瞬压无配置，置无效
         if ((short)g_sw[sw].di_cfg_index[SW_DI_PT1SY] == INDEX_INVALLID)
         {
@@ -647,6 +659,18 @@ int run_status_check(u32 dStep)
             prun->kzdx = dido_di_is_on(ecd->slot, ecd->index);
         }
 
+        if ((short)g_sw[sw].di_cfg_index[SW_DI_HZHLJS] != INDEX_INVALLID)
+        {
+            ecd = &g_equ_config_di[g_sw[sw].di_cfg_index[SW_DI_HZHLJS]];
+            prun->kzhljs_hz = dido_di_is_on(ecd->slot, ecd->index);
+        }
+
+        if ((short)g_sw[sw].di_cfg_index[SW_DI_FZHLJS] != INDEX_INVALLID)
+        {
+            ecd = &g_equ_config_di[g_sw[sw].di_cfg_index[SW_DI_FZHLJS]];
+            prun->kzhljs_fz = dido_di_is_on(ecd->slot, ecd->index);
+        }
+
         if ((short)g_sw[sw].di_cfg_index[SW_DI_PT1SY] != INDEX_INVALLID)
         {
             ecd = &g_equ_config_di[g_sw[sw].di_cfg_index[SW_DI_PT1SY]];
@@ -812,23 +836,17 @@ int run_status_check(u32 dStep)
         RunTR(&pSW->tTWCNGJ1s, bTHWCNState, dStep);
         pSW->uSWST.bFlag.bWCN = pSW->tTWCNGJ1s.boolTrip;
 
-        // 控制回路告警处理
-#if 0
-		bY = ((prun->tzw==0&&prun->hzw==0)||(prun->tzw==1&&prun->hzw==1))
-						&& ((short)g_sw[sw].di_cfg_index[SW_DI_HZWZ] != INDEX_INVALLID)
-						&& ((short)g_sw[sw].di_cfg_index[SW_DI_TZWZ] != INDEX_INVALLID)
-						&& pRunSet->tSwSet[sw].bTT_KZHL;
-
-		bY1=pR->run_stu.kzdx&& pRunSet->tSwSet[sw].bTT_KZHL;
-#else                                                                                                                                          // 控制回路断线 1、控制回路断线遥信输入 2、HQ&TQ错误态&未知态 3、开关位置错误态&未知态
+        // 控制回路告警处理 1、控制回路断线遥信输入 2、HQ&TQ错误态&未知态 3、合位合闸监视合，分位分闸监视合 4、开关位置错误态&未知态
         if (((short)g_sw[sw].di_cfg_index[SW_DI_HZWZ] != INDEX_INVALLID) && ((short)g_sw[sw].di_cfg_index[SW_DI_TZWZ] != INDEX_INVALLID))      // 配置了HQ&TQ
             bY = (((prun->tzw == 0 && prun->hzw == 0) || (prun->tzw == 1 && prun->hzw == 1)) && pRunSet->tSwSet[sw].bTT_KZHL);                 // HQ&TQ错误
         else if (((short)g_sw[sw].di_cfg_index[SW_DI_KRHW] != INDEX_INVALLID) && ((short)g_sw[sw].di_cfg_index[SW_DI_KRTW] != INDEX_INVALLID)) // 必须配置开关双位置状态
             bY = (((prun->tw == 0 && prun->hw == 0) || (prun->tw == 1 && prun->hw == 1)) && pRunSet->tSwSet[sw].bTT_KZHL);                     // 开关位置错误
+        else if (((short)g_sw[sw].di_cfg_index[SW_DI_KRHW] != INDEX_INVALLID) && ((short)g_sw[sw].di_cfg_index[SW_DI_KRTW] != INDEX_INVALLID) &&
+                 ((short)g_sw[sw].di_cfg_index[SW_DI_HZHLJS] != INDEX_INVALLID) && ((short)g_sw[sw].di_cfg_index[SW_DI_HZHLJS] != INDEX_INVALLID))
+            bY = (((prun->hw == 1 && prun->kzhljs_hz == 1) || (prun->tw == 1 && prun->kzhljs_fz == 1)) && pRunSet->tSwSet[sw].bTT_KZHL); // 开关位置错误
         else
             bY = false;
         bY1 = pR->run_stu.kzdx && pRunSet->tSwSet[sw].bTT_KZHL;
-#endif
         RunTR(&pSW->tTKZHLGJ1s, (bY || bY1), dStep);
         pSW->uSWST.bFlag.bKZHL = pSW->tTKZHLGJ1s.boolTrip;
 
@@ -1140,7 +1158,7 @@ int app_action_result(void)
             prun->gj_led = 1;
         }
 
-        for (i = 0; i < 8; i++)
+        for (i = 0; i < PROTECT_FDL_NUM; i++)
         {
             fdl |= pR->tFdl[i].sta.bFlag.bTz;
         }
@@ -1434,14 +1452,292 @@ int _create_instu_file(void)
 
     return 0;
 }
+
+struct t_run_time
+{
+    uint32_t ul_this_runtime;
+    uint32_t ul_total_runtime;
+};
+struct t_run_time mst_run_time;
+
+/* 获取本次运行 */
+uint32_t rsio_get_this_runtime(void)
+{
+    return mst_run_time.ul_this_runtime;
+}
+
+/* 获取累计运行 */
+uint32_t rsio_get_total_runtime(void)
+{
+    return mst_run_time.ul_total_runtime;
+}
+
+/* 运行计时 */
+void rsio_get_runtime(void)
+{
+    static uint8_t suc_init_flag_rt = 0;
+    static int sul_time_interval = 0;
+    uint8_t uc_en_add = 0;
+
+    if (suc_init_flag_rt == 0)
+    {
+        suc_init_flag_rt = 1;
+        memset(&mst_run_time, 0, sizeof(mst_run_time));
+        e2prom_read(EEP_RUNTIMEINFO_ADDR, (uint8_t *)&mst_run_time.ul_total_runtime, sizeof(mst_run_time.ul_total_runtime));
+    }
+
+    /* 每隔1分钟进来一次 */
+    if (0 == sul_time_interval)
+    {
+        sul_time_interval = ustimer_get_origin();
+    }
+    else
+    {
+        if (ustimer_get_duration(sul_time_interval) >= USTIMER_SEC * 60)
+        {
+            sul_time_interval = 0;
+            uc_en_add = 1;
+        }
+    }
+
+    if (uc_en_add)
+    {
+        mst_run_time.ul_this_runtime++;
+        mst_run_time.ul_total_runtime++;
+        if (mst_run_time.ul_this_runtime % (24 * 60) == 0) // 24小时写一次总运行时间
+        {
+            e2prom_write(EEP_RUNTIMEINFO_ADDR, (uint8_t *)&mst_run_time.ul_total_runtime, sizeof(mst_run_time.ul_total_runtime));
+        }
+    }
+}
+
+void rsio_clear_runtime(void)
+{
+    int ret;
+    memset(&mst_run_time, 0, sizeof(mst_run_time));
+    ret = e2prom_write(EEP_RUNTIMEINFO_ADDR, (uint8_t *)&mst_run_time.ul_total_runtime, sizeof(mst_run_time.ul_total_runtime));
+    if (ret == 0)
+        rt_printf("run time clear succeses!\r\n");
+    else
+        rt_printf("run time clear fail! ret:%d\r\n", ret);
+}
+
+struct t_sca_run
+{
+    uint8_t uc_init;
+    uint8_t uc_updata;
+    struct t_sca_data       sca[SWITCH_NUM_MAX];
+    struct t_sca_savedata   scas[SWITCH_NUM_MAX]; /* 保存的开关动作次数 */
+};
+static struct t_sca_run mst_sca;
+
+/**
+ * @brief          检测开关动作
+ * @author         lch (lch_work@foxmail.com)
+ * @version        1.0
+ * @date           20260324
+ * @param[in/out]  {int} _l_sw 开关号
+ * @return         * void
+ * @retval         none
+ * 
+ * @warning        none
+ * @note           none
+ */
+void scaio_check_sw_act(int _l_sw)
+{
+    TRELAY_T *pR = &g_tRelay[_l_sw];
+
+    if (0 != mst_sca.sca[_l_sw].timer.ul_start_jump)
+    {
+        if (ustimer_get_duration(mst_sca.sca[_l_sw].timer.ul_start_jump) >= (200 * USTIMER_MS))
+        {
+            if (pR->run_stu.sw == 2)
+            {
+                mst_sca.sca[_l_sw].flag.us_position = 0xff;
+                mst_sca.sca[_l_sw].timer.ul_start_jump = 0;
+            }
+        }
+        else
+        {
+            /* 在计时过程之中，开关已经完成了由合变分 */
+            if (2 == mst_sca.sca[_l_sw].flag.us_position && 1 == pR->run_stu.sw)
+            {
+                mst_sca.sca[_l_sw].timer.ul_start_jump = 0;
+                mst_sca.sca[_l_sw].flag.us_count_jump++;
+                mst_sca.sca[_l_sw].flag.us_position = pR->run_stu.sw;
+            }
+        }
+    }
+
+    if (0 != mst_sca.sca[_l_sw].timer.ul_start_close)
+    {
+        if (ustimer_get_duration(mst_sca.sca[_l_sw].timer.ul_start_close) >= (200 * USTIMER_MS))
+        {
+            if (pR->run_stu.sw == 1)
+            {
+                mst_sca.sca[_l_sw].flag.us_position = 0xff;
+                mst_sca.sca[_l_sw].timer.ul_start_close = 0;
+            }
+        }
+        else
+        {
+            /* 在计时过程之中，开关已经完成了由分变合 */
+            if (1 == mst_sca.sca[_l_sw].flag.us_position && 2 == pR->run_stu.sw)
+            {
+                mst_sca.sca[_l_sw].timer.ul_start_close = 0;
+                mst_sca.sca[_l_sw].flag.us_count_close++;
+                mst_sca.sca[_l_sw].flag.us_position = pR->run_stu.sw;
+            }
+        }
+    }
+}
+
+/**
+ * @brief          启动检测
+ * @version        1.0
+ * @date           20260324
+ * @param[in/out]  {int} _l_sw 开关号
+ * @param[in/out]  {uint8_t} _uc_type 动作类型
+ * @return         * void
+ * @retval         none
+ * 
+ * @warning        none
+ * @note           none
+ */
+void scaio_start_refusecheck(int _l_sw, uint8_t _uc_type)
+{
+    TRELAY_T *pR = &g_tRelay[_l_sw];
+
+    mst_sca.sca[_l_sw].flag.us_position = pR->run_stu.sw;
+    if (_uc_type)
+    {
+        if (!mst_sca.sca[_l_sw].timer.ul_start_close)
+        {
+            mst_sca.sca[_l_sw].timer.ul_start_close = ustimer_get_origin();
+        }
+    }
+    else
+    {
+        if (!mst_sca.sca[_l_sw].timer.ul_start_jump)
+        {
+            mst_sca.sca[_l_sw].timer.ul_start_jump = ustimer_get_origin();
+        }
+    }
+}
+
+/**
+ * @brief          保存开关动作次数数据
+ * @version        1.0
+ * @date           20260324
+ * @param[in/out]  * void
+ * @return         * void
+ * @retval         none
+ * 
+ * @warning        none
+ * @note           每分钟检查一次数据是否需要保存
+ */
+void scaio_save_data(void)
+{
+    static uint16_t smus_scatask_count = 0;
+    bool b_en_save = false;
+
+    /* 现在函数100ms进入一次 */
+    if (smus_scatask_count++ < 600)
+        return ;
+
+    smus_scatask_count = 0;
+
+    for (int i = 0; i < SWITCH_NUM_MAX; i++)
+    {
+        if (mst_sca.scas[i].us_count_jump != mst_sca.sca[i].flag.us_count_jump)
+        {
+            mst_sca.scas[i].us_count_jump = mst_sca.sca[i].flag.us_count_jump;
+            b_en_save = true;
+        }
+
+        if (mst_sca.scas[i].us_count_close != mst_sca.sca[i].flag.us_count_close)
+        {
+            mst_sca.scas[i].us_count_close = mst_sca.sca[i].flag.us_count_close;
+            b_en_save = true;
+        }
+    }
+
+    if (b_en_save)
+    {
+        e2prom_write(EEP_SWC_ADDR, (uint8_t *)&mst_sca.scas, sizeof(struct t_sca_savedata) * SWITCH_NUM_MAX);
+    }
+}
+
+/**
+ * @brief          初始化参数
+ */
+void scaio_factory_data(void)
+{
+    for (int i = 0; i < SWITCH_NUM_MAX; i++)
+    {
+        mst_sca.sca[i].flag.us_count_jump = mst_sca.scas[i].us_count_jump = 0;
+        mst_sca.sca[i].flag.us_count_close = mst_sca.scas[i].us_count_close = 0;
+    }
+    e2prom_write(EEP_SWC_ADDR, (uint8_t *)&mst_sca.scas, sizeof(struct t_sca_savedata) * SWITCH_NUM_MAX);
+}
+
+/**
+ * @brief          获取数据
+ * @version        1.0
+ * @date           20260324
+ * @param[in/out]  {int} _l_sw 开关号
+ * @param[in/out]  {uint8_t} _uc_type 动作类型
+ * @return         uint32_t 动作次数
+ * @retval         none
+ * 
+ * @warning        none
+ * @note           none
+ */
+uint32_t scaio_get_num(int _l_sw, uint8_t _uc_type)
+{
+    if (_uc_type)
+    {
+        return mst_sca.sca[_l_sw].flag.us_count_close;
+    }
+    else
+    {
+        return mst_sca.sca[_l_sw].flag.us_count_jump;
+    }
+}
+
+/**
+ * @brief          初始化参数
+ */
+void scaio_init_data(void)
+{
+    if (0 == mst_sca.uc_init)
+    {
+        mst_sca.uc_init = 1;
+        e2prom_read(EEP_SWC_ADDR, (uint8_t *)&mst_sca.scas, sizeof(struct t_sca_savedata) * SWITCH_NUM_MAX);
+        for (int i = 0; i < SWITCH_NUM_MAX; i++)
+        {
+            mst_sca.sca[i].flag.us_count_jump = mst_sca.scas[i].us_count_jump;
+            mst_sca.sca[i].flag.us_count_close = mst_sca.scas[i].us_count_close;
+        }
+    }
+}
+
 /*------------------------------ 测试函数 -------------------------------------
 一个实体文件必须带一个本模块的测试函数来进行单元测试，如果的确不方便在本模块中
 进行单元测试，必须在此注明实际的测试位置（例如在哪个实体文件中使用哪个测试函数）.
 */
 int runstu_printf(void)
 {
-    rt_printf("内部状态信息:\r\n");
-    rt_printf("yf=%d\r\n", g_run_stu.yf);
+    // rt_printf("内部状态信息:\r\n");
+    // rt_printf("yf=%d\r\n", g_run_stu.yf);
+
+    rt_printf("mst_run_time.ul_this_runtime %d\r\n", mst_run_time.ul_this_runtime);
+    rt_printf("mst_run_time.ul_total_runtime %d\r\n", mst_run_time.ul_total_runtime);
+    for (int i = 0; i < SWITCH_NUM_MAX; i++)
+    {
+        rt_printf("mst_sca.sca[%02d].flag.us_count_jump %d\r\n", i, mst_sca.sca[i].flag.us_count_jump);
+        rt_printf("mst_sca.sca[%02d].flag.us_count_close %d\r\n", i, mst_sca.sca[i].flag.us_count_close);
+    }
 
     return 0;
 }

dtu/dtu_main_t536/app/run_status.h

@@ -121,14 +121,14 @@ struct run_stu
 // 内部状态结构体
 typedef struct run_stu_sw
 {
-    u8 sw; // 开关位置
+    u8 sw; // 开关位置 2是合位 1是分位
     u8 hw; // 开关合位
     u8 tw; // 开关分位
     u8 hw_change;
     u8 tw_change;
 
-    u8 hzw;
-    u8 tzw;
+    u8 hzw;    // 合闸位置
+    u8 tzw;    // 跳闸位置
     u8 wcn;    // 未储能
     u8 gld;    // 隔离刀闸
     u8 jdd;    // 接地刀闸
@@ -165,10 +165,12 @@ typedef struct run_stu_sw
     u8 XT;
     u8 YT;
     u8 lock;
-    u8 exerr; // 外部异常
-    u8 pt1yy; // PT1有压
-    u8 pt2yy; // PT2有压
-    u8 kzdx;  // 控制回路断线 开入信号
+    u8 exerr;     // 外部异常
+    u8 pt1yy;     // PT1有压
+    u8 pt2yy;     // PT2有压
+    u8 kzdx;      // 控制回路断线 开入信号
+    u8 kzhljs_hz; // 合闸回路监视
+    u8 kzhljs_fz; // 分闸回路监视
     u8 chzbs;
 
     u8 bh_yx;   // 常规保护遥信点
@@ -249,8 +251,8 @@ typedef union USWST
         DWORD bDIHW : 1; // 外部开入合位
         DWORD bDITW : 1; // 外部开入跳位
 
-        DWORD bWCN : 1; // 未储能告警
-        DWORD bKZHL : 1;
+        DWORD bWCN : 1;  // 未储能告警
+        DWORD bKZHL : 1; // 控制回路断线
         DWORD bTWYL : 1; // 跳位有流告警
         DWORD bSXWL : 1; // 三相无流
         DWORD bSHJS : 1; // 手合加速
@@ -283,6 +285,31 @@ typedef struct TSWST
     DWORD wfFlagsave;
 } TSWST;
 
+struct t_sca_flag
+{
+    uint16_t    us_position;        /* 开关位置 */
+    uint16_t    us_count_jump;      /* 跳闸次数 */
+    uint16_t    us_count_close;     /* 合闸次数 */
+}; /* 标志 */
+
+struct t_sca_timer
+{
+    uint32_t    ul_start_jump;     /* 开始 */
+    uint32_t    ul_start_close;    /* 开始 */
+}; /* 计时器 */
+
+struct t_sca_data
+{
+    struct t_sca_flag          flag;
+    struct t_sca_timer         timer;
+};
+
+struct t_sca_savedata
+{
+    uint16_t    us_count_jump;      /* 跳闸次数 */
+    uint16_t    us_count_close;     /* 合闸次数 */
+};
+
 /*------------------------------ 变量声明 -------------------------------------
  */
 extern const int INSTU_NUM;
@@ -302,6 +329,17 @@ int run_status_dz_all(void);
 
 int app_action_result(void);
 int rmt_key_init(void);
+void rsio_get_runtime(void);
+void rsio_clear_runtime(void);
+uint32_t rsio_get_this_runtime(void);
+uint32_t rsio_get_total_runtime(void);
+void scaio_check_sw_act(int _l_sw);
+void scaio_start_refusecheck(int _l_sw, uint8_t _uc_type);
+void scaio_save_data(void);
+void scaio_factory_data(void);
+uint32_t scaio_get_num(int _l_sw, uint8_t _uc_type);
+void scaio_init_data(void);
+
 
 #endif //
 //========================== 本文件结束 =============================

dtu/dtu_main_t536/app/set.h

@@ -27,7 +27,7 @@
 #ifdef defined GD_AREA_ZHONGSHAN || defined GD_AREA_ZHONGSHAN_2020
 	#define MAX_SET_NUMBER 			500		// 最大定值个数
 #else
-	#define MAX_SET_NUMBER 			2000		// 最大定值个数
+	#define MAX_SET_NUMBER 			2000		// 最大定值个数 注意开关定值+公共定值不能超过这个
 #endif
 
 #ifdef SEC_SETVALUE_7
@@ -38,7 +38,7 @@
 	#define SEC_NUMBER 				5        			// 定值区个数
 #endif
 
-#define SETSIZE           		(MAX_SET_NUMBER*4)	// 每个定值区=200字节
+#define SETSIZE           		(MAX_SET_NUMBER*4)	// 每个定值区的大小（目前按照6个开关定值+1个公共定值计算）
 
 #ifdef PUB_SET_SECTION
 #define MAX_PUBSET_NUMBER		100						// 最大公共定值个数(公共定值新增备用定值，超过原60)
@@ -432,7 +432,7 @@ enum
     SET_P_WY_TT,    // A侧失电延时合闸
     SET_L_WY_TT,    // B侧失电延时合闸
     SET_GZCHECK_TT, // 合到故障分闸
-    SET_BSTZ_TT,    // 短时闭锁失压分
+    SET_BSTZ_TT,    // 短时失压闭锁分闸
     SET_FA_GL2_TT,  // 相间过流告警投入
     SET_FA_LX2_TT,  // 接地告警投入
     SET_U0TZ_TT,    // 合到零压保护
@@ -522,12 +522,11 @@ enum
     SET_GOOSET_LX_I,     // 分布式FA零序过流定值
     SET_GOOSET_LX_T,     // 分布式FA零序过流时间
     SET_GOOSET_LLC_T,    // 联络自投充电延时
+    SET_GOOSET_LL_T,     // 联络自投合闸延时
     SET_GOOSET_SDLOST_T, // 首开关失压跳闸延时
+    SET_GOOSET_GZGL_T,   // 故障隔离时限
     SET_GOOSET_GZ_I,     // 过载判断定值
     SET_GOOSET_SL_T,     // 失灵判断延时
-
-    SET_GOOSET_GZGL_T, // 故障隔离时限
-    SET_GOOSET_LL_T,   // 供电恢复时间
 #endif
 #else
     SET_GOOSE_FA_TT,        // 分布式FA控制字
@@ -558,9 +557,9 @@ enum
 #endif
 
     SET_LABLE_TQ, // 列表名 同期合闸定值
-    SET_TQ_U,     // 合环压差
-    SET_TQ_ANG,   // 合环角差
-    SET_TQ_F,     // 合环频差
+    SET_TQ_U,     // 同期允许电压差
+    SET_TQ_ANG,   // 同期允许相角差
+    SET_TQ_F,     // 同期允许频率差
 
     SET_LABLE_VOLJL,  // 列表名  自动解列控制字
     SET_VOLJL_TT,     // 电压越限解列投入
@@ -689,7 +688,7 @@ enum
     SET_CURRENT_INV_TT,  // 功率取反投退 涉及功率计算和小电流接地判断
     SET_DIR_INV_TT,      // 保护方向取反投退 过流方向计算时使用
     SET_TT_TWCN,         // 未储能告警
-    SET_TT_KZHL,         // 控制回路
+    SET_TT_KZHL,         // 控制回路检查
     SET_QYD_BS_TT,       // 气压低闭锁分合闸
     SET_PT1_LL_CHECK_TT, // PT1断线检查投退
     SET_PT2_LL_CHECK_TT, // PT2断线检查投退
@@ -727,6 +726,10 @@ enum
     SET_APT2_U,           // 电源侧PT额定二次值
     SET_BPT1_U,           // 负荷侧PT额定一次值
     SET_BPT2_U,           // 负荷侧PT额定二次值
+    SET_APT1_UZ,          // 电源侧零序PT额定一次值
+    SET_APT2_UZ,          // 电源侧零序PT额定二次值
+    SET_BPT1_UZ,          // 负荷侧零序PT额定一次值
+    SET_BPT2_UZ,          // 负荷侧零序PT额定二次值
     SET_PPT_TYPE,         // A侧PT接线方式
     SET_LPT_TYPE,         // B侧PT接线方式
 
@@ -787,9 +790,6 @@ enum
     SET_WAVE_ORDER,   // 小波卷积阶数
     SET_HILBERT,      // H 变换
     SET_TQ_FH,        // 同期合闸判断返回时间
-#ifdef FUNC_SET_FA_JS
-    SET_FA_JS, // FA合闸解锁时间
-#endif
 #ifdef VOLT_ADAPTIVE_FACTOR
     SET_ADAPTIVEFACTOR, // 自适应电压系数
 #endif
@@ -811,9 +811,13 @@ enum
     PARA_COSAUTO,            // COS自动上传
     PARA_EVPARA,             // COS自动上传
     PARA_YK_TIME,            // 遥控超时时间
+    PARA_YT_TIME,            // 遥调超时时间
     PARA_101LINKADDR,        // 101链路地址
     PARA_101APPADDR,         // 101应用地址
     PARA_101COT,             // 101传送原因
+    PARA_101INFOADDR_BYTES,  // 三字节
+	PARA_104_INTERVAL,		 // 104应答间隔
+	PARA_104_FILETRUE,		 // 104响应读文件确认
     PARA_104_Client,         // 104端口	是服务器还是客户端
     PARA_104_PORT,           // 104端口
     PARA_104_ACK_TIME,       // 104确认超时
@@ -916,11 +920,12 @@ enum
     PARA_FZPULSE,       // 分闸脉冲
     PARA_HZPULSE,       // 合闸脉冲
     PARA_U_ZERO,        // 电压零漂
+    PARA_DC_ZERO,       // 直流电压零漂
     PARA_PHASE_I_ZERO,  // 相电流零漂
     PARA_ZERO_I_ZERO,   // 零序电流零漂
-#ifdef CPU_FUXI
-    PARA_DC_ZERO, // 直流电压零漂
-#endif
+    PARA_P_ZERO,        // 功率零漂
+    PARA_F_ZERO,        // 频率零漂
+    PARA_COS_ZERO,      // 功率因数零漂
 
     PARA_LABEL_OTHERS, // 列表名 其它
     PARA_FHZPULSE,
@@ -988,8 +993,6 @@ enum
     CSTSET_DDYBS_TT,     // 低压闭锁过流
     CSTSET_U0BS_U,       // 零压闭锁零流定值
     CSTSET_DDYBS_U,      // 低压闭锁过流定值
-    CSTSET_DP_DELTAF_TT, // 低频滑差投入
-    CSTSET_DP_DELTAF,    // 低频滑差
 #ifdef PRO_AL_LOCK_HZ
     CSSET_JL_LOCK_CHZ,          // 解列闭锁重合闸
     CSSET_START_CHZ_JUDGE_FREQ, // 解列后重合闸判频率
@@ -1016,6 +1019,12 @@ enum
     CSSET_RMTTEST_TT,       // 远动测试模式
     CSSET_SOE_RESUME_COMM,  // SOE通讯续传，通讯重连时上送未确认的SOE
     CSSET_SOE_RESUME_POWER, // SOE上电续传
+    CSSET_EV_FAILURE,       // 故障事件上送
+	CSSET_EV_FAIL_PRIMARY, 	// 故障事件上送一次值
+    CSSET_EV_FAILURE_Z,     // 故障事件清零上送
+    CSSET_EV_FAILT_AD_LEN,  // 故障事件遥信地址长度
+    CSSET_PACKAGE_MUTUDATA, // 突变数据打包上送
+    CSSET_PACKAGE_MUTUTIME, // 突变数据打包时间
 #ifdef FIX_PARAM_FORMAT
     CSSET_SET_ULF8, //	固定参数上送格式 ulf-8	江苏要求
 #endif
@@ -1037,7 +1046,8 @@ enum
 #ifdef FA_PL_PJ
     CSSET_JUDGE_FREQ, // 有压判频率投退
 #endif
-    CSSET_U_PJ, // 有压判据
+    CSSET_U_PJ,         // 有压判据
+    CSSET_FA_GLFX_PJ,   // FA过流告警判负序
 
     CSTSET_WAVE_RECORD_LABEL, // 列表名 录波功能
     CSTSET_WAVE_FILETYPE,     // 文件格式
@@ -1063,7 +1073,6 @@ enum
     CSSET_SET_DC_NUM,            // 直流通道数
     CSSET_PT2_VOL,               // 负荷侧电压选择
     CSSET_DISP_ONE_TWO,          // 液晶遥测数据显示
-    CSSET_FAULT_PARA_DKY,        // 故障事件遥信地址长度
 #ifdef YC_QUANTITY
     CSSET_YC_NUM, // 设置每间隔遥参数量
 #endif
@@ -1072,7 +1081,6 @@ enum
     CSSET_JLJX,         // 计量接线方式
     CSSET_WGFS,         // 无功电能算法
 #endif
-    CSSET_SET_EV_YC_RATE,       // SOE遥测系数投退
     CSSET_SET_YC_DEAD_ZONE_ALL, // 遥测总死区有效投退
 
     CSTSET_NUM
@@ -1166,6 +1174,8 @@ typedef struct GOC_SET //
     bool bsw_fz;   // 末端开关
     bool bsw_ll;   // 联络开关
     bool bFA_slow; // 缓动 型FA
+    bool bFA_gzbs; // 过载闭锁自投投入
+    bool bFA_qdch; // 智能分布式启动重合闸
     bool bTT_gooseFA;
     bool bTT_DIR;
     bool bTT_mxTfz;    // 母线故障跳分支
@@ -1221,8 +1231,8 @@ typedef struct TSETSW
     bool bTT_chz_tq;       // 重合检同期
     bool bTT_CHZ;          // 重合闸投退
     bool bTT_TTCH_TT;      // 偷跳启动重合
+    bool bTT_ddl_lock_rc;  // 大电流闭锁重合闸
 
-    bool bTT_3U0;       // 零序过电压投退
     bool bTT_3U0Tz;     // 零序过电压保护跳闸
     bool bTT_3U0Gj;     // 零序过电压保护告警
     DWORD dBHOverU0;    // 零序过电压
@@ -1246,38 +1256,39 @@ typedef struct TSETSW
     DWORD dA_tq_delatA; // 同期角差
     DWORD dF_tq_deltaF; // 同期频差
 
-    bool bTT_jl_dy;   // 电压解列
-    DWORD dT_jl_ggdy; // 高电压解列时间
-    DWORD dT_jl_gddy; // 低电压解列时间
-    DWORD dT_jl_gdy;  // 电压解列时间
-    DWORD dT_jl_ddy;  // 电压解列时间
-
-    DWORD dU_jl_ggdy; // 高电压解列定值
-    DWORD dU_jl_gddy; // 低电压解列定值
-    DWORD dU_jl_gdy;  // 电压解列时定值
-    DWORD dU_jl_ddy;  // 电压解列时定值
-
-    DWORD dU_jl_ggdy_fh; // 高电压解列定值
-    DWORD dU_jl_gddy_fh; // 低电压解列定值
-    DWORD dU_jl_gdy_fh;  // 电压解列时定值
-    DWORD dU_jl_ddy_fh;  // 电压解列时定值
-
-    bool bTT_jl_hz;    // 频率解列
-    DWORD dT_jl_ghz;   // 高频解列时间
-    DWORD dT_jl_dhz;   // 低频解列时间
-    DWORD dT_jl_lowhz; // 频解列时间
-
-    DWORD dU_jl_ghz;   // 高频解列定值
-    DWORD dU_jl_dhz;   // 低频解列定值
-    DWORD dU_jl_lowhz; // 过低频解列定值
-
-    DWORD dU_jl_ghz_fh;   // 高频解列定值
-    DWORD dU_jl_dhz_fh;   // 低频解列定值
-    DWORD dU_jl_lowhz_fh; // 过低频解列定值
+    bool bTT_jl_dy;      // 电压解列
+    DWORD dU_jl_gddy_rs; // 电压过低解列起始范围
+    DWORD dU_jl_gddy_re; // 电压过低解列结束范围
+    DWORD dT_jl_gddy;    // 电压过低解列时间
+    DWORD dU_jl_ddy_rs;  // 低电压解列起始范围
+    DWORD dU_jl_ddy_re;  // 低电压解列结束范围
+    DWORD dT_jl_ddy;     // 低电压解列时间
+    DWORD dU_jl_gdy_rs;  // 高电压解列起始范围
+    DWORD dU_jl_gdy_re;  // 高电压解列结束范围
+    DWORD dT_jl_gdy;     // 高电压解列时间
+    DWORD dU_jl_ggdy_rs; // 电压过高解列起始范围
+    DWORD dU_jl_ggdy_re; // 电压过高解列结束范围
+    DWORD dT_jl_ggdy;    // 电压过高解列时间
+
+    bool bTT_jl_hz;      // 频率解列
+    DWORD dU_jl_gdhz_rs; // 频率过低解列起始范围
+    DWORD dU_jl_gdhz_re; // 频率过低解列结束范围
+    DWORD dT_jl_gdhz;    // 频率过低解列时间
+    DWORD dU_jl_dhz_rs;  // 低频解列起始范围
+    DWORD dU_jl_dhz_re;  // 低频解列结束范围
+    DWORD dT_jl_dhz;     // 低频解列时间
+    DWORD dU_jl_ghz_rs;  // 高频解列起始范围
+    DWORD dU_jl_ghz_re;  // 高频解列结束范围
+    DWORD dT_jl_ghz;     // 高频解列时间
+    DWORD dU_jl_gghz_rs; // 频率过高解列起始范围
+    DWORD dU_jl_gghz_re; // 频率过高解列结束范围
+    DWORD dT_jl_gghz;    // 频率过高解列时间
+
     bool bTT_hcbs_hz;     // 滑差闭锁投退
     bool bTT_hcbs_dy;     // 电压滑差闭锁功能
     DWORD dhcbs_hz;       // 频率滑差定值
     DWORD dhcbs_u;        // 电压滑差定值
+    DWORD dT_jl_charge;   // 解列充电时间
 
     bool bTT_FA;          // FA投退
     bool bTT_fa_LL;       // 分段联络模式
@@ -1300,24 +1311,25 @@ typedef struct TSETSW
     bool bTT_fa_gl2; // 过流告警
     bool bTT_fa_lx2; // 零序告警
 
-    bool bTT_fa_cybs; // 残压闭锁
-    bool bTT_fa_xbbs; // FA谐波闭锁
-    bool bTT_fa_ptdx; // 保护PT断线检查
+    bool bTT_fa_yjcybs; // 硬件残压闭锁
+    bool bTT_fa_cybs;   // 残压闭锁
+    bool bTT_fa_xbbs;   // FA谐波闭锁
+    bool bTT_fa_ptdx;   // 保护PT断线检查
 
-    bool bTT_fa_U0Tz; // 合后接地故障  零序过压投退
-    bool bTT_fa_U0Gj; // 合后接地故障  零序过压投退
+    bool bTT_fa_U0Tz; // 合后接地故障 零序过压跳闸
+    bool bTT_fa_U0Gj; // 合后接地故障 零序过压告警
 
-    DWORD dU_fa_YY;     // 有压定值
-    DWORD dU_fa_YY_fh;  // 有压定值
-    DWORD dU_fa_YY2;    // 有压定值
-    DWORD dU_fa_YY2_fh; // 有压定值
-    DWORD dT_fa_YY;     // 有压定值
+    DWORD dU_fa_YY;     // A侧有压定值
+    DWORD dU_fa_YY_fh;  // A侧有压返回定值
+    DWORD dU_fa_YY2;    // B侧有压定值
+    DWORD dU_fa_YY2_fh; // B侧有压返回定值
+    DWORD dT_fa_YY;     // 有压判定时间
 
-    DWORD dU_fa_WY;     // 无压定值
-    DWORD dU_fa_WY_fh;  // 无压定值
-    DWORD dU_fa_WY2;    // 无压定值
-    DWORD dU_fa_WY2_fh; // 无压定值
-    DWORD dT_fa_WY;     // 无压定值
+    DWORD dU_fa_WY;     // A侧无压定值
+    DWORD dU_fa_WY_fh;  // A侧无压返回定值
+    DWORD dU_fa_WY2;    // B侧无压定值
+    DWORD dU_fa_WY2_fh; // B侧无压返回定值
+    DWORD dT_fa_WY;     // 无压判定时间
 
     DWORD dT_X;     // X时间
     DWORD dT_Y;     // Y时间
@@ -1359,6 +1371,8 @@ typedef struct TSETSW
 #ifdef XDL_ZT
     bool bTT_xdlgj; // 小电流接地告警
     bool bTT_xdltz; // 小电流接地跳闸
+    bool bTT_xdl_src; // 小电流接地保护启动重合闸
+    bool bTT_xdl_hjs; // 小电流接地保护启动重合闸
     int bTT_xdlqd;  // 小电流启动类型
     DWORD dI_xdl;   // 小电流接地电流
     DWORD dI_xdl_300ma;
@@ -1456,6 +1470,15 @@ typedef struct TSETSW
     u8 bzt_dl1_ct;
     u8 bzt_dl2_ct;
 #endif
+
+    DWORD lbla_time; // 线路断线告警延时
+    DWORD lbla_mode; // 线路断线判定方式 0非全相，1加判零压， 2加判零流和对应相电压低
+    DWORD lbla_zu;   // 线路断线零压
+    DWORD lbla_zufh; // 线路断线零压返回值
+    DWORD lbla_zc;   // 线路断线零流
+    DWORD lbla_zcfh; // 线路断线零流返回值
+    DWORD lbla_du;   // 线路断线低电压
+
 } TSETSW;
 
 typedef struct VOL_SET
@@ -1479,14 +1502,18 @@ typedef struct TSET
     u8 section_zx;       // 待执行定值区
 #endif
 
-    float ct_one;                // CT额定一次值
-    float ct_two;                // CT额定二次值
-    float ct0_one;               // 零序CT额定一次值
-    float ct0_two;               // 零序CT额定二次值
-    float a_pt_one;              // 电源侧PT额定一次值
-    float a_pt_two;              // 电源侧PT额定二次值
-    float b_pt_one;              // 负荷侧PT额定一次值
-    float b_pt_two;              // 负荷侧PT额定二次值
+    u32 ct_one;                // CT额定一次值
+    u32 ct_two;                // CT额定二次值
+    u32 ct0_one;               // 零序CT额定一次值
+    u32 ct0_two;               // 零序CT额定二次值
+    u32 a_pt_one;              // 电源侧PT额定一次值
+    u32 a_pt_two;              // 电源侧PT额定二次值
+    u32 b_pt_one;              // 负荷侧PT额定一次值
+    u32 b_pt_two;              // 负荷侧PT额定二次值
+    u32 a_zpt_one;            // 电源侧零序PT额定一次值
+    u32 a_zpt_two;           // 电源侧零序PT额定二次值
+    u32 b_zpt_one;            // 负荷侧零序PT额定一次值
+    u32 b_zpt_two;           // 负荷侧零序PT额定二次值
     u8 a_side_pt_type;           // A侧PT接线方式
     u8 b_side_pt_type;           // B侧PT接线方式
     bool bTT_EDIT_YB;            // 远程运维投入
@@ -1494,9 +1521,9 @@ typedef struct TSET
 #ifdef CUSTOMIZE_BZT             // 备自投
     VOL_SET tVolLostSet;
 #endif
-    bool bTT_FDLTz[6];   // 非电量保护
-    bool bTT_FDLGj[6];   // 非电量保护
-    DWORD dTFDL[6];      // 非电量保护
+    bool bTT_FDLTz[PROTECT_FDL_NUM];   // 非电量保护
+    bool bTT_FDLGj[PROTECT_FDL_NUM];   // 非电量保护
+    DWORD dTFDL[PROTECT_FDL_NUM];      // 非电量保护
     bool bTT_GZJD;       // 经高阻接地投退
     WORD bTT_TBLTYPE;    // 小电流突变方式
     WORD bTT_FILTER;     // 小电流信号滤波方式
@@ -1504,9 +1531,6 @@ typedef struct TSET
     WORD bTT_WAVE_ORDER; // 小波分解阶数
     bool bTT_HILEBERT;   // H 变换
     DWORD dT_tq_fh;      // 同期判断返回时间
-#ifdef FUNC_SET_FA_JS
-    DWORD dT_FA_JS; // FA合闸解锁
-#endif
 #ifdef VOLT_ADAPTIVE_FACTOR
     bool bTT_AdaptiveFactor; // 投退自适应电压系数，为1时电压值按计算系数匹配10kv上送，不按转发点表配置系数
 #endif
@@ -1530,8 +1554,6 @@ typedef struct TSET
     bool bTT_DDYBS;                  // 低电压闭锁
     DWORD dU_U0BS;                   // 零压闭锁零流定值
     DWORD dU_DDYBS;                  // 低压闭锁过流定值
-    bool bKG2_DP_DELTAF;             // 低频滑差闭锁投 =1投入 =0 退出
-    DWORD dDP_DELTAF;                // 低频减载滑差定值
 
 #ifdef PRO_AL_LOCK_HZ
     bool bTT_JLlockCHZ;          // 解列闭锁重合闸
@@ -1558,6 +1580,12 @@ typedef struct TSET
     DWORD dGroupYcSize;      // 组召遥测分组大小，为0则无效
     bool bTT_SoeResumeComm;  // SOE通讯续传，通讯重连时上送未确认的SOE
     bool bTT_SoeResumePower; // SOE上电续传
+    bool bTT_EvFailure;      // 故障事件上送
+    bool bTT_EvFailprimary;  // 故障事件上送一次值
+    bool bTT_EvFailure_Z;    // 故障事件清零上送
+    bool bTT_Ev_AD_LEN;      // 故障事件遥信地址长度
+    bool bTT_Package_MutuData;  // 突变数据打包上送
+    DWORD bTT_Package_MutuTime; // 突变数据打包时间
 #ifdef FIX_PARAM_FORMAT
     bool bTT_Utf8;    // 固定参数上送格式 UTF-8
     bool bTT_Unicode; // 固定参数上送格式 UNICODE
@@ -1581,6 +1609,7 @@ typedef struct TSET
     bool bTT_judgeFreq; // 有压判频率投退
 #endif
     bool bTT_UYYmin; // 有压判据
+    bool btt_faglfx; // FA过流告警判负序
 
     DWORD lb_vol_type;            // 录波 电压选择 0 第一组 1第二组 2全部
     bool lb_xyx;                  // 虚拟遥信记录
@@ -1605,7 +1634,6 @@ typedef struct TSET
     DWORD dDc_num;                // 直流通道数量
     DWORD pt2vol;                 // 负荷侧电压选择
     bool bTT_ShowOne;             // 液晶遥测数据显示
-    bool bTT_faultparaDKY;        // 故障事件遥信地址长度
 #ifdef YC_QUANTITY
     DWORD dYC_num; // 每间隔遥参数量
 #endif
@@ -1614,7 +1642,6 @@ typedef struct TSET
     WORD wJLJX;      // 计量接线方式
     WORD wWGFS;      // 无功方式
 #endif
-    bool bTT_EV_YCRate;       // 故障事件上送一/二次值切换标志
     bool bTT_YC_DeadZone_All; // 遥测总死区有效
 
     /* 装置参数 一些数据 */
@@ -1663,12 +1690,17 @@ typedef struct RUN_PARA
     bool bEvPara;     // cos 自动上传
     DWORD dYKTime;    // 遥控超时时间
     DWORD dSM2Time;   // 加密遥控超时时间
+    DWORD dYTTime;    // 遥调超时时间
+
+    bool b101Addr2Byte;    // 101链路地址
+    bool b101App2Byte;     // 101应用地址
+    bool b101Cot2Byte;     // 101传送原因
+    bool bytes101InfoAddr; // 101信息体地址三字节
 
-    bool b101Addr2Byte; // 101链路地址
-    bool b101App2Byte;  // 101应用地址
-    bool b101Cot2Byte;  // 101传送原因
+	DWORD   d104Intervalms;	// 104应答间隔
+	bool 	b104FileSure;	// 104响应读文件确认
 
-    WORD w104Port;     // 104规约端口号，默认2404
+    WORD w104Port; // 104规约端口号，默认2404
     WORD w104AckTime;  // 104确认超时
     WORD w104TestTime; // 104测试超时
     WORD w104K;        // 104 K值,为0则K值无效。
@@ -1751,6 +1783,9 @@ typedef struct RUN_PARA
     WORD wMonhour;
 #endif
 
+    DWORD dZero_U; // 电压零漂
+    DWORD dZero_I; // 电流零漂
+
 } RUN_PARA;
 
 // 有效定值区
@@ -1823,14 +1858,6 @@ typedef struct TSETTABLE
     char szName[PARA_NAME_LEN]; // 定值名称
 } TSETTABLE;
 
-// 控制字表
-typedef struct TKGTABLE
-{
-    const BYTE byNum;     // 本组控制字位的数目(通常是1,最大值=3)
-    const BYTE sBitNo[3]; // 本组控制字各位的位号
-    const char **pNames;  // 本组控制字各种编码(按小到大)的描述
-} TKGTABLE;
-
 struct set_disp_index
 {
     int num; // 按开关重新分配后的定值总数
@@ -1850,8 +1877,7 @@ typedef struct
 
 // 远方修改定值数据类型定义
 
-#define NULL_R 0 // 无
-
+#define NULL_R 0    // 无
 #define BOOL_R 1    // 布尔		Boolean	1	1	1:true,0:false
 #define TINY_R 43   // 小整形	Tiny	43	1	-128…127
 #define UTINY_R 32  // 无符号	小整形	UTiny	32	1	0…255
@@ -1864,9 +1890,10 @@ typedef struct
 #define FLOAT_R 38  // 单精度浮点	Float	38	4	-3.4028235E+38…3.4028235E+38
 #define DOUBLE_R 39 // 双精度浮点	Double	39	8	-1.79769313486231570E+308
 #define STR_R 4     // OcterString	4	可变	OcterString
+#define STR_E 8     // EightString	8	8位位串
 
-// #define RMT_SET_NUMBER  (SWITCH_NUM_MAX*19+21+16+12)  // 开关定值+ CT变比 19  公共参数21  FTU逻辑定值 16,固定定值11
-#define RMT_SET_NUMBER 200 // 开关定值+ CT变比 19  公共参数21  FTU逻辑定值 16,固定定值11
+// 根据多间隔预留遥调缓存个数 
+#define RMT_SET_NUMBER (SWITCH_NUM_MAX * 200 + 64)
 
 // 通用定值
 enum
@@ -1942,7 +1969,7 @@ extern const TRMTSETTABLE tRmtsettable[]; //
 extern const int RMT_SET_TABLE_NUMBER;
 extern const TFIXEDSETTABLE tfixedsettable[]; // 固有参数
 extern const int FIXEDSET_TABLE_NUMBER;
-extern WORD m_runsection;
+extern WORD m_runsection;                 // 当前定值区号
 extern int g_goose_net_type;
 extern TSECTIONINFO tSecInfo;             // 定值信息(包括定值区号及有效定值区)
 extern const TSETTABLE tEquipParaTable[]; // 装置参数
@@ -2011,6 +2038,8 @@ void get_yx_ac(u8 index, u32 type);
 WORD GetCstValForwardAddr(const BYTE type, const int index);
 extern DWORD GetSetSQR(float ff, float fk);
 extern void check_shmdata_change(void);
+extern uint16_t setio_get_fixarea(void);
+extern uint16_t setio_get_fixarearange(uint8_t _uc_choose);
 
 #endif //__SET_H
 //========================== 本文件结束 =============================

dtu/dtu_main_t536/app/switch.c

@@ -201,6 +201,57 @@ const s8 * g_sw_do_name[SW_DO_NUM] =
     "开关失灵",
 #endif
 
+#if !defined(PRO_YB_LOCATION_IN_PUB)
+	"常规保护压板合",
+	"常规保护压板分",
+	"自动重合压板合",
+	"自动重合压板分",
+	"停用重合压板合",
+	"停用重合压板分",
+	"FA压板合",
+	"FA压板分",
+    "智能分布式压板合",
+    "智能分布式压板分",
+    #ifdef JZS_FUNCTION
+        "集中式压板合",
+        "集中式压板分",
+    #endif
+	"同期压板合",
+	"同期压板分",
+	"自动解列压板合",
+	"自动解列压板分",
+	"小电流接地压板合",
+	"小电流接地压板分",
+	"线路断线告警压板合",
+	"线路断线告警压板分",
+	"功能总投退压板合",
+	"功能总投退压板分",
+	"功能总出口压板合",
+	"功能总出口压板分",
+	"重合闸压板合",
+	"重合闸压板分",
+
+    #ifdef FUNC_DRIVE
+        "传动接收软压板合",
+        "传动接收软压板分",
+        "传动指令",
+    #endif
+
+    #ifdef FUNC_DRIVE_JY
+        "不停电传动功能",
+    #endif
+
+    #ifdef YK_FA_S_L_ENBLE
+        "分段/联络-合",
+        "分段/联络-分",
+    #endif	
+
+    #ifdef YK_FA_ENBLE
+        "FA遥控闭锁-合",
+        "FA遥控闭锁-分",
+    #endif
+#endif
+
 };
 
 const s8 * g_sw_led_name[SW_LED_NUM]=
@@ -508,48 +559,45 @@ const s8 * g_pub_do_name[PUB_DO_NUM] =
 #ifdef YK_FG_FAJS
 	"远方复归&FA解锁",	// 远方复归+FA解锁
 #endif
-	"重合软压板合",
-	"重合软压板分",
-#if defined BHFA_YB_YK
-	#if defined GD_AREA_ECZD_2020
-	"停用保护总软压板合",
-	"停用保护总软压板分",
-	#else
-	"功能总投入软压板合",
-	"功能总投入软压板分",
-	#endif	
-	"保护出口软压板合",
-	"保护出口软压板分",
-	"常规保护软压板合",
-	"常规保护软压板分",
-	"馈线自动化软压板合",
-	"馈线自动化软压板分",
-    "智能分布式软压板合",
-    "智能分布式软压板分",
-#else
-    #if defined GD_AREA_ECZD_2020
-	"停用保护总软压板合",
-	"停用保护总软压板分",
-	#else
-	"自动功能软压板合",
-	"自动功能软压板分",
-	#endif
-	"保护投入软压板合",
-	"保护投入软压板分",
+
+#if (PRO_YB_LOCATION_IN_PUB)
+	"常规保护压板合",
+	"常规保护压板分",
+	"自动重合压板合",
+	"自动重合压板分",
+	"停用重合压板合",
+	"停用重合压板分",
+	"FA压板合",
+	"FA压板分",
+    "智能分布式压板合",
+    "智能分布式压板分",
+#ifdef JZS_FUNCTION
+    "集中式压板合",
+    "集中式压板分",
 #endif
-	"同期合闸软压板合",
-	"同期合闸软压板分",
-	"集中式软压板-合",
-	"集中式软压板-分",
+	"同期压板合",
+	"同期压板分",
+	"自动解列压板合",
+	"自动解列压板分",
+	"小电流接地压板合",
+	"小电流接地压板分",
+	"线路断线告警压板合",
+	"线路断线告警压板分",
+	"功能总投退压板合",
+	"功能总投退压板分",
+	"功能总出口压板合",
+	"功能总出口压板分",
+	"重合闸压板合",
+	"重合闸压板分",
 
-#ifdef YK_SOFT_YB
-	"遥控软压板-合",
-	"遥控软压板-分",
+#ifdef FUNC_DRIVE
+	"传动接收软压板合",
+	"传动接收软压板分",
+	"传动指令",
 #endif
 
-#ifdef YK_FA_ENBLE
-	"FA遥控闭锁-合",
-	"FA遥控闭锁-分",
+#ifdef FUNC_DRIVE_JY
+	"不停电传动功能",
 #endif
 
 #ifdef YK_FA_S_L_ENBLE
@@ -557,22 +605,22 @@ const s8 * g_pub_do_name[PUB_DO_NUM] =
 	"分段/联络-分",
 #endif	
 
-	"自动解列软压板合",
-	"自动解列软压板分",
-
-#ifdef METERING_ENERGY
-	"遥控电度清零",
-	"遥控线损事件清零",
+#ifdef YK_FA_ENBLE
+	"FA遥控闭锁-合",
+	"FA遥控闭锁-分",
 #endif
+#endif
+	"远程运维压板合",
+	"远程运维压板分",
 
-#ifdef FUNC_DRIVE
-	"传动接收软压板合",
-	"传动接收软压板分",
-	"传动指令",
+#ifdef YK_SOFT_YB
+	"遥控软压板-合",
+	"遥控软压板-分",
 #endif
 
-#ifdef FUNC_DRIVE_JY
-	"不停电传动功能",
+#ifdef METERING_ENERGY
+	"遥控电度清零",
+	"遥控线损事件清零",
 #endif
 
 #ifdef FUNC_RESET_EQU
@@ -1365,7 +1413,8 @@ int sw_do(u32 sw, u32 index, int type)
     }
 
     // 气压低闭锁分合闸
-    if (pRunSet->tSwSet[sw].bTT_QYD_BS && (g_sw[sw].di[SW_DI_QYD_BS] == SW_DI_TYPE_ON) && (index == SW_DO_YKH || index == SW_DO_YKT || index == SW_DO_BHH || index == SW_DO_BHT))
+    if (pRunSet->tSwSet[sw].bTT_QYD_BS && (g_sw[sw].di[SW_DI_QYD_BS] == SW_DI_TYPE_ON) &&
+        (index == SW_DO_YKH || index == SW_DO_YKT || index == SW_DO_BHH || index == SW_DO_BHT))
     {
         return -2;
     }
@@ -1381,6 +1430,17 @@ int sw_do(u32 sw, u32 index, int type)
     index = g_equ_config_do[index].index;
 
     ret = _sw_do(slot, index, type);
+    
+    extern void scaio_start_refusecheck(int _l_sw, uint8_t _uc_type);
+    if (SW_DO_BHH == index || SW_DO_YKH == index) // 保护合闸 遥控合闸
+    {
+        scaio_start_refusecheck(sw, 1);
+    }
+
+    if (SW_DO_BHT == index || SW_DO_YKT == index) // 保护分闸 遥控分闸
+    {
+        scaio_start_refusecheck(sw, 0);
+    }
 
     return ret;
 }
@@ -1841,6 +1901,7 @@ void sw_cal_protect(void)
 
     // 计算最大最小值
     _sw_min_max(PUB_AC_UA1, &g_sw_pub.m2_min[0], &g_sw_pub.m2_max[0]);
+    _sw_min_max(PUB_AC_UA2, &g_sw_pub.m2_min[1], &g_sw_pub.m2_max[1]);
     _sw_min_max(PUB_AC_UAB1, &g_sw_pub.m2_min[2], &g_sw_pub.m2_max[2]);
     _sw_min_max(PUB_AC_UAB2, &g_sw_pub.m2_min[3], &g_sw_pub.m2_max[3]);
 
@@ -1859,6 +1920,12 @@ void sw_cal_protect(void)
     return;
 }
 
+static void _cal_get_freq(void)
+{
+	g_sw_pub.ac_in_acc[PUB_AC_IN_F1] += freq_get(0);  //第1路频率
+	g_sw_pub.ac_in_acc[PUB_AC_IN_F2] += freq_get(1);  //第2路频率
+}
+
 /******************************************************************************
 函数名称：	sw_cal_app
 函数版本：	01.01
@@ -1878,6 +1945,8 @@ int sw_cal_app(void)
         return 0;
     }
 
+    _cal_get_freq();
+
     // 如果没有达到累计次数，直接返回。
     g_mea_cnt++;
     if (g_mea_cnt < MEA_CAL_NUMBER)
@@ -3612,7 +3681,6 @@ void _sw_cal_average(int cal_num)
             g_sw[sw].ac_in[SW_AC_IN_CI_UNBALANCE] = 0;
         }
 
-        // TODO:
         // 功率因数，I1/I*COSφ1=COSφ ，I1基波电流有效值，I总电流有效值，COSφ1基波功率因数，COSφ含谐波电网的实际功率因数
         if (_AbsL(g_sw[sw].ac_in[SW_AC_IN_Q]) > g_unit[g_sw_ac_desc[SW_AC_IN_Q].unit].zero)
         {
@@ -3662,8 +3730,10 @@ void _sw_cal_average(int cal_num)
 
     // 其它测量值
     // 频率
-    g_sw_pub.ac_in[PUB_AC_IN_F1] = (qs16)(freq_get(0) * Q16_BASE); // 第1路频率
-    g_sw_pub.ac_in[PUB_AC_IN_F2] = (qs16)(freq_get(1) * Q16_BASE); // 第2路频率
+    g_sw_pub.ac_in[PUB_AC_IN_F1] = rt_round(g_sw_pub.ac_in_acc[PUB_AC_IN_F1] / cal_num * Q16_BASE); // 第1路频率
+    g_sw_pub.ac_in[PUB_AC_IN_F2] = rt_round(g_sw_pub.ac_in_acc[PUB_AC_IN_F2] / cal_num * Q16_BASE); // 第2路频率
+    g_sw_pub.ac_in_acc[PUB_AC_IN_F1] = 0;
+    g_sw_pub.ac_in_acc[PUB_AC_IN_F2] = 0;
 
     // 直流、温度
     {
@@ -3692,7 +3762,7 @@ void _sw_cal_average(int cal_num)
         f1 /= factor;
         if (pRunSet->dDc_num == 1)
             f1 = 0; // 只有一个通道，将第二个直流通道强制=0
-#ifdef CPU_FUXI
+
         if (f0 < tRunPara.wDC_ZERO)
         {
             f0 = 0.0;
@@ -3701,7 +3771,7 @@ void _sw_cal_average(int cal_num)
         {
             f1 = 0.0;
         }
-#endif
+
 #ifdef TMP_CHIP_AHT20
         g_sw_pub.ac_in[PUB_AC_IN_HUMI] = (qs16)(h * Q16_BASE);
 #endif
@@ -3765,7 +3835,7 @@ void _sw_cal_average(int cal_num)
     }
     // 版本号0x00010104
     {
-        float f_version = ((BYTE)((VER_NUM >> 0) & 0x0f) + ((BYTE)(VER_NUM >> 4) & 0x0f) * 10 + ((BYTE)(VER_NUM >> 8) & 0x0f) * 100 + ((BYTE)(VER_NUM >> 12) & 0x0f) * 1000 + ((BYTE)(VER_NUM >> 16) & 0x0f) * 10000) * 0.001;
+        float f_version = ((VER_NUM >> 12) & 0xff) + ((VER_NUM & 0xfff) * 0.001);
         g_sw_pub.ac_in[PUB_AC_IN_VER] = (qs16)(f_version * Q16_BASE);
     }
 

dtu/dtu_main_t536/app/switch.h

@@ -42,9 +42,9 @@ enum
 
 enum
 {
-    SW_DO_TYPE_OFF = 0,
+    SW_DO_TYPE_OFF = 0,     // 执行
     SW_DO_TYPE_ON,
-    SW_DO_TYPE_SELECT_OFF,
+    SW_DO_TYPE_SELECT_OFF,  // 预置
     SW_DO_TYPE_SELECT_ON
 };
 
@@ -137,6 +137,58 @@ enum
     SW_DO_UNSTUCK_SINGLE, // 开关失灵
 #endif
 
+#if !defined(PRO_YB_LOCATION_IN_PUB)
+    SW_BHYBTT_HZ,    // 虚遥控 常规保护压板合
+    SW_BHYBTT_FZ,    // 虚遥控 常规保护压板分
+    SW_CHYB_HZ,      // 虚遥控 自动重合压板合
+    SW_CHYB_FZ,      // 虚遥控 自动重合压板分
+    SW_TYCHYB_HZ,    // 虚遥控 停用重合压板合
+    SW_TYCHYB_FZ,    // 虚遥控 停用重合压板分
+    SW_FAYBTT_HZ,    // 虚遥控 FA压板合
+    SW_FAYBTT_FZ,    // 虚遥控 FA压板分
+    SW_GOOSEYBTT_HZ, // 虚遥控 智能分布式压板合
+    SW_GOOSEYBTT_FZ, // 虚遥控 智能分布式压板分
+    #ifdef JZS_FUNCTION
+        SW_JZS_YB_HZ, // 虚遥控 集中式压板合
+        SW_JZS_YB_FZ, // 虚遥控 集中式压板分
+    #endif
+    SW_TQ_YB_HZ,      // 虚遥控 同期压板合
+    SW_TQ_YB_FZ,      // 虚遥控 同期压板分
+    SW_JL_YB_HZ,      // 虚遥控 自动解列压板合
+    SW_JL_YB_FZ,      // 虚遥控 自动解列压板分
+    SW_XDL_YB_HZ,     // 虚遥控 小电流接地压板合
+    SW_XDL_YB_FZ,     // 虚遥控 小电流接地压板分
+    SW_LA_YB_HZ,      // 虚遥控 线路断线告警压板合
+    SW_LA_YB_FZ,      // 虚遥控 线路断线告警压板分
+
+    SW_BHYB_HZ,       // 虚遥控 功能总投退压板合
+    SW_BHYB_FZ,       // 虚遥控 功能总投退压板分
+    SW_KZYB_HZ,       // 虚遥控 功能总出口合
+    SW_KZYB_FZ,       // 虚遥控 功能总出口分
+    SW_CHRYB_HZ,      // 虚遥控 重合闸压板合
+    SW_CHRYB_FZ,      // 虚遥控 重合闸压板分
+
+    #ifdef FUNC_DRIVE
+        SW_DRIVE_YB_ON,  // 不停电传动软压板投入
+        SW_DRIVE_YB_OFF, // 不停电传动软压板退出
+        SW_DRIVE_HZ,     // 不停电传动指令
+    #endif
+
+    #ifdef FUNC_DRIVE_JY
+        SW_UNSTOP_V_DRI_HZ, // 不停电传动功能
+    #endif
+        
+    #ifdef YK_FA_S_L_ENBLE
+        SW_YK_FA_S_L_HZ, // 分段/联络-合,
+        SW_YK_FA_S_L_FZ, // 分段/联络-分,
+    #endif
+
+    #ifdef YK_FA_ENBLE
+        SW_YK_BS_FA_HZ, //	FA遥控闭锁-合,
+        SW_YK_BS_FA_FZ, //	FA遥控闭锁-分,
+    #endif
+#endif
+
     SW_DO_NUM
 };
 
@@ -392,50 +444,37 @@ enum
 #ifdef YK_FG_FAJS
     PUB_DO_RST_FAJS, // 远方复归+FA解锁
 #endif
-    PUB_CHYB_HZ, // 虚遥控，重合闸压板
-    PUB_CHYB_FZ, // 虚遥控，分闸压板
-#if defined BHFA_YB_YK
-    PUB_BHYB_HZ,      // 虚遥控，分闸压板
-    PUB_BHYB_FZ,      // 虚遥控，分闸压板
-    PUB_KZYB_HZ,      // 虚遥控，控制出口合闸压板(线路保护投停&&保护投入软压板)
-    PUB_KZYB_FZ,      // 虚遥控，控制出口分闸压板(线路保护投停&&保护投入软压板)
-    PUB_BHYBTT_HZ,    // 虚遥控，常规保护投退合闸压板(线路保护投停&&保护投入软压板)
-    PUB_BHYBTT_FZ,    // 虚遥控，常规保护投退分闸压板(线路保护投停&&保护投入软压板)
-    PUB_FAYBTT_HZ,    // 虚遥控，FA保护投退合闸压板(线路保护投停&&保护投入软压板)
-    PUB_FAYBTT_FZ,    // 虚遥控，FA保护投退分闸压板(线路保护投停&&保护投入软压板)
-    PUB_GOOSEYBTT_HZ, // 虚遥控，goose保护投退合闸压板(线路保护投停&&保护投入软压板)
-    PUB_GOOSEYBTT_FZ, // 虚遥控，goose保护投退分闸压板(线路保护投停&&保护投入软压板)
-#else
-    PUB_BHYB_HZ, // 虚遥控，分闸压板
-    PUB_BHYB_FZ, // 虚遥控，分闸压板
-    PUB_KZYB_HZ, // 虚遥控，控制出口合闸压板(线路保护投停&&保护投入软压板)
-    PUB_KZYB_FZ, // 虚遥控，控制出口分闸压板(线路保护投停&&保护投入软压板)
-#endif
 
-    PUB_TQ_YB_HZ,  // 虚遥控，同期合闸软压板
-    PUB_TQ_YB_FZ,  // 虚遥控，同期合闸软压板
-    PUB_JZS_YB_HZ, // 虚遥控，集中式软压板
-    PUB_JZS_YB_FZ, // 虚遥控，集中式软压板
-#ifdef YK_SOFT_YB
-    PUB_YK_YB_HZ, // 虚遥控，遥控软压板
-    PUB_YK_YB_FZ, // 虚遥控，遥控软压板
-#endif
-#ifdef YK_FA_ENBLE
-    PUB_YK_BS_FA_HZ, //	FA遥控闭锁-合,
-    PUB_YK_BS_FA_FZ, //	FA遥控闭锁-分,
-#endif
-#ifdef YK_FA_S_L_ENBLE
-    PUB_YK_FA_S_L_HZ, //	分段/联络-合,
-    PUB_YK_FA_S_L_FZ, //	分段/联络-分,
-#endif
-
-    PUB_JL_YB_HZ, // 虚遥控，自动解列软压板
-    PUB_JL_YB_FZ, // 虚遥控，自动解列软压板
-
-#ifdef METERING_ENERGY
-    PUB_DD_CLR,    // 虚遥控，电度清零
-    PUB_LLSOE_CLR, // 虚遥控，线损事件清零
+#if (PRO_YB_LOCATION_IN_PUB)
+    PUB_BHYBTT_HZ,    // 虚遥控 常规保护压板合
+    PUB_BHYBTT_FZ,    // 虚遥控 常规保护压板分
+    PUB_CHYB_HZ,      // 虚遥控 自动重合压板合
+    PUB_CHYB_FZ,      // 虚遥控 自动重合压板分
+    PUB_TYCHYB_HZ,    // 虚遥控 停用重合压板合
+    PUB_TYCHYB_FZ,    // 虚遥控 停用重合压板分
+    PUB_FAYBTT_HZ,    // 虚遥控 FA压板合
+    PUB_FAYBTT_FZ,    // 虚遥控 FA压板分
+    PUB_GOOSEYBTT_HZ, // 虚遥控 智能分布式压板合
+    PUB_GOOSEYBTT_FZ, // 虚遥控 智能分布式压板分
+#ifdef JZS_FUNCTION
+    PUB_JZS_YB_HZ, // 虚遥控 集中式压板合
+    PUB_JZS_YB_FZ, // 虚遥控 集中式压板分
 #endif
+    PUB_TQ_YB_HZ,      // 虚遥控 同期压板合
+    PUB_TQ_YB_FZ,      // 虚遥控 同期压板分
+    PUB_JL_YB_HZ,      // 虚遥控 自动解列压板合
+    PUB_JL_YB_FZ,      // 虚遥控 自动解列压板分
+    PUB_XDL_YB_HZ,     // 虚遥控 小电流接地压板合
+    PUB_XDL_YB_FZ,     // 虚遥控 小电流接地压板分
+    PUB_LA_YB_HZ,      // 虚遥控 线路断线告警压板合
+    PUB_LA_YB_FZ,      // 虚遥控 线路断线告警压板分
+
+    PUB_BHYB_HZ,       // 虚遥控 功能总投退压板合
+    PUB_BHYB_FZ,       // 虚遥控 功能总投退压板分
+    PUB_KZYB_HZ,       // 虚遥控 功能总出口合
+    PUB_KZYB_FZ,       // 虚遥控 功能总出口分
+    PUB_CHRYB_HZ,      // 虚遥控 重合闸压板合
+    PUB_CHRYB_FZ,      // 虚遥控 重合闸压板分
 
 #ifdef FUNC_DRIVE
     PUB_DRIVE_YB_ON,  // 不停电传动软压板投入
@@ -446,6 +485,29 @@ enum
 #ifdef FUNC_DRIVE_JY
     PUB_UNSTOP_V_DRI_HZ, // 不停电传动功能
 #endif
+    
+#ifdef YK_FA_S_L_ENBLE
+    PUB_YK_FA_S_L_HZ, // 分段/联络-合,
+    PUB_YK_FA_S_L_FZ, // 分段/联络-分,
+#endif
+
+#ifdef YK_FA_ENBLE
+    PUB_YK_BS_FA_HZ, //	FA遥控闭锁-合,
+    PUB_YK_BS_FA_FZ, //	FA遥控闭锁-分,
+#endif
+#endif
+    PUB_EDIT_PARYB_HZ, // 虚遥控 远程运维压板合
+    PUB_EDIT_PARYB_FZ, // 虚遥控 远程运维压板分
+
+#ifdef YK_SOFT_YB
+    PUB_YK_YB_HZ, // 虚遥控 遥控软压板
+    PUB_YK_YB_FZ, // 虚遥控 遥控软压板
+#endif
+
+#ifdef METERING_ENERGY
+    PUB_DD_CLR,    // 虚遥控 电度清零
+    PUB_LLSOE_CLR, // 虚遥控 线损事件清零
+#endif
 
 #ifdef FUNC_RESET_EQU
     PUB_RESET_EQU, // 重启装置
@@ -636,7 +698,7 @@ struct sw
     // 遥信值
     u8 di[SW_DI_NUM + EV_SW_NUM];
 
-    // 最大最小值
+    // 最大最小值 电流
     u32 m2_min;
     u32 m2_max;
     u32 fz_min;
@@ -674,9 +736,9 @@ struct sw_public
     // 遥信值
     u8 di[PUB_DI_NUM + EV_PUB_END - EV_PUB_START];
 
-    // 最大最小值
-    u32 m2_min[4];
-    u32 m2_max[4];
+    // 最大最小值 电压
+    u32 m2_min[4]; // 0:A侧相电压 1:B侧相电压 2:A侧线电压 3:B侧线电压
+    u32 m2_max[4]; // 0:A侧相电压 1:B侧相电压 2:A侧线电压 3:B侧线电压
 
     u32 fz_min[2];
     u32 fz_max[2];

dtu/dtu_main_t536/app/sysTime.c

@@ -37,9 +37,9 @@ void sys_time_get(struct rtc_time_t *pct)
 int sys_time_set(struct rtc_time_t *pct)
 {
     int ret = 0;
-    char pchDT[30];
+    // char pchDT[30];
     struct timespec ts;
-    SHM_TS_T shm_ts;
+    // SHM_TS_T shm_ts;
 
     if (rtc_to_timespec(pct, &ts) != 0)
     {
@@ -50,12 +50,11 @@ int sys_time_set(struct rtc_time_t *pct)
     // shm_comm_packet_write(SHM_ADDR_D_TIME, (uint8_t *)&shm_ts, sizeof(SHM_TS_T));
     // mb_notice_time_update();
 
-    sprintf(pchDT, "date -s '%04d-%02d-%02d %02d:%02d:%02d'", pct->year + 2000, pct->month, pct->day, pct->hour, pct->min, pct->ms / 1000);
-    system(pchDT);
-    system("hwclock -w");
-    system("sync");
-
-    rt_printf("设置系统时间: %s\n", pchDT);
+    // sprintf(pchDT, "date -s '%04d-%02d-%02d %02d:%02d:%02d'", pct->year + 2000, pct->month, pct->day, pct->hour, pct->min, pct->ms / 1000);
+    // system(pchDT);
+    // system("hwclock -w");
+    // system("sync");
+    // rt_printf("设置系统时间: %s\n", pchDT);
     ret = gps_set_time(&ts);
 
     return ret;

dtu/dtu_main_t536/app/timer.c

@@ -38,6 +38,7 @@ void InitTR(TIMERELAY *pTimeRelay, DWORD dTripThreshold, DWORD dRetThreshold)
     pTimeRelay->dTimerRetTimer = 0;
     pTimeRelay->dTRTThreshold = 0;
 }
+
 /**************************************************************************
 函数名称：InitTR_Time
 函数版本：1.00
@@ -57,6 +58,7 @@ void InitTR_Time(TIMERELAY *pTimeRelay, DWORD dTripThreshold, DWORD dRetThreshol
     pTimeRelay->dTripThreshold = dTripThreshold;
     pTimeRelay->dRetThreshold = dRetThreshold;
 }
+
 /**************************************************************************
 函数名称：InitTR_Time_Flag
 函数版本：1.00
@@ -94,6 +96,7 @@ void SetTR_TRTT(TIMERELAY *pTimeRelay, DWORD dTRTT)
 {
     pTimeRelay->dTRTThreshold = dTRTT;
 }
+
 /**************************************************************************
 函数名称：PreSetTime
 函数版本：1.00
@@ -112,6 +115,7 @@ void PreSetTime(TIMERELAY *pTimeRelay, DWORD dPreTime)
     pTimeRelay->dTimer = dPreTime;
     pTimeRelay->boolStart = true;
 }
+
 /**************************************************************************
 函数名称：ResetTR
 函数版本：1.00
@@ -131,6 +135,7 @@ void ResetTR(TIMERELAY *pTimeRelay)
     pTimeRelay->dTimer = 0;
     pTimeRelay->dTimerRetTimer = 0;
 }
+
 /**************************************************************************
 函数名称：RunTR
 函数版本：1.00

dtu/dtu_main_t536/app/ui/Makefile

@@ -0,0 +1,105 @@
+############################################################
+# Makefile (UI Static Library, depends on core/liblvgl.a)
+############################################################
+
+# 交叉编译器
+CC = aarch64-none-linux-gnu-gcc
+AR = aarch64-none-linux-gnu-ar
+
+LVGL_DIR_NAME ?= lvgl
+LVGL_DIR ?= ${shell pwd}/core
+
+# ===== 静态库名（替代 lvgl_app）=====
+TARGET := libui.a
+
+############################################################
+# 编译参数（保持原样）
+############################################################
+CFLAGS := -I. \
+          -I../ \
+          -Icore \
+          -Icore/lvgl \
+          -Icore/lvgl/src \
+          -Icore/lvgl_driver \
+          -Iui \
+          -Icomm \
+          -Idata \
+          -Iapp \
+          -Iapp/components \
+          -Iservice \
+          -Iui/ui_common \
+          -Iui/ui_pages \
+          -Iui/ui_theme \
+          -Iui/ui_components \
+           -O2 -std=gnu99 
+
+############################################################ -Wall
+# ⚠️ 注意：这里不再需要 LDFLAGS
+# 静态库阶段不做链接
+############################################################
+# LDFLAGS := -Lcore -llvgl -lm -lpthread
+
+############################################################
+# 源文件（保持原逻辑）
+############################################################
+SRCS := \
+    $(wildcard data/*.c) \
+    $(wildcard data/menu/*.c) \
+    $(wildcard app/*.c) \
+    $(wildcard app/*/*.c) \
+    $(wildcard comm/*.c) \
+    $(wildcard service/*.c) \
+    $(wildcard *.c) \
+    $(wildcard ui/*.c) \
+    $(wildcard ui/ui_common/*.c) \
+    $(wildcard ui/ui_pages/*.c) \
+    $(wildcard ui/ui_components/*.c) \
+    $(wildcard ui/ui_theme/*.c)
+
+# ===== 强烈建议：静态库中不要包含 main.c =====
+SRCS := $(filter-out %main.c, $(SRCS))
+
+############################################################
+# build/ 目录
+############################################################
+BUILD_DIR := build
+OBJS := $(patsubst %.c,$(BUILD_DIR)/%.o,$(SRCS))
+DIRS := $(sort $(dir $(OBJS)))
+
+############################################################
+# 主规则
+############################################################
+all: $(TARGET)
+
+############################################################
+# 生成静态库
+############################################################
+$(TARGET): $(OBJS)
+	@echo "AR  $@"
+	@$(AR) rcs $@ $^
+	@echo "\n==== Build Finished: $(TARGET) ====\n"
+
+############################################################
+# 编译 .o
+############################################################
+$(BUILD_DIR)/%.o: %.c
+	@mkdir -p $(dir $@)
+	$(CC) $(CFLAGS) -c $< -o $@
+
+############################################################
+# 清理
+############################################################
+clean:
+	@echo "Cleaning..."
+	@rm -rf $(BUILD_DIR) $(TARGET)
+	@echo "Clean done."
+
+############################################################
+# 调试
+############################################################
+print:
+	@echo "SRCS:"
+	@echo "$(SRCS)"
+	@echo
+	@echo "OBJS:"
+	@echo "$(OBJS)"

dtu/dtu_main_t536/app/ui/app/app_config.c

@@ -0,0 +1,47 @@
+#include "app_config.h"
+#include "app_version_info.h"
+#include "app_home_page.h"
+#include "app_input_pwd.h"
+#include "app_main_menu.h"
+#include "app_dev_set_show.h"
+#include "app_dev_set.h"
+#include "app_real_time_data.h"
+#include "app_fix_set.h"
+#include "app_fix_show.h"
+#include "app_debugset.h"
+#include "app_history_report.h"
+
+// 3. 静态映射数组：集中管理所有页面的事件处理函数
+const PageEventMap g_page_event_map[] = {
+    {PAGE_HOME_PAGE, app_home_page_handle_event},
+    {PAGE_MAIN_MENU, app_main_menu_handle_event},
+    {PAGE_DEV_INFO, app_version_info_handle_event},
+    {PAGE_DEV_SET_SHOW, app_dev_set_show_handle_event},
+    {PAGE_DEV_SET, app_dev_set_handle_event},
+    {PAGE_REAL_TIME_DATA , app_real_time_data_handle_event},
+    {PAGE_DEV_FIX, app_fix_set_handle_event},
+    {PAGE_DEV_FIX_SHOW, app_fix_show_handle_event},
+    {PAGE_DEBUG_TEST, app_debugset_handle_event},
+    {PAGE_HISTORY_DATA, app_history_report_handle_event},
+    // 新增页面只需在这里加一行：{新页面ID, 新页面处理函数},
+
+};
+
+const uint8_t g_page_event_map_size = sizeof(g_page_event_map) / sizeof(PageEventMap);
+
+/**
+ * @brief 是否处于组件弹出状态
+ * @return true 
+ * @return false 
+ * @date 2026-01-12
+ */
+bool  is_compenents_stats()
+{
+    UICursorState curState = ui_manager_get_cursor();
+    if (curState.cursor_pos > CURSOR_LEFT_MENU)
+    {
+        return true;
+    }
+    
+    return false;
+}

dtu/dtu_main_t536/app/ui/app/app_config.h

@@ -0,0 +1,22 @@
+#ifndef _APP_CONFIG_H
+#define _APP_CONFIG_H
+#include "../data/key_manager.h"
+#include "ui_manager.h"
+
+// 定义事件处理函数的指针类型（与现有处理函数签名保持一致）
+typedef void (*page_event_handler_t)(keyValue);
+
+// 定义“页面-处理函数”的映射结构体
+typedef struct {
+    PageType        page_id;       // 页面ID（对应原来的PAGE_XXX枚举）
+    page_event_handler_t handler;   // 该页面对应的按键事件处理函数
+} PageEventMap;
+
+extern const PageEventMap g_page_event_map[];
+
+// 可选：声明数组长度（方便其他文件遍历，避免重复计算sizeof）
+extern const uint8_t g_page_event_map_size;
+
+extern bool  is_compenents_stats();
+
+#endif

dtu/dtu_main_t536/app/ui/app/app_debugset.c

@@ -0,0 +1,718 @@
+#include "app_debugset.h"
+#include "service_debugset.h"
+#include "ui_manager.h"
+#include "app_set_var_list.h"
+#include "app_confirm.h"
+#include "components/app_input_pwd.h"
+#include "components/app_datetime_set.h"
+#include "data_config.h"
+
+// Manu_str.c 中的菜单字符串
+extern Para_OPTTypeDef Sys_set_opt[7];      // 7个系统设置项
+
+// 系统设置菜单密码验证状态
+static bool s_system_set_verified = false;
+
+// 当前正在处理的设置项索引
+static u8 s_current_setting_idx = 0xFF;
+
+// 密码修改确认相关
+static uint16_t s_new_password_temp = 0;  // 临时存储新密码
+static bool s_password_modify_pending = false;  // 标记是否有待确认的密码修改
+
+/**
+ * @brief 根据按键输入计算左侧菜单选中索引
+ * @param curstate 当前光标状态
+ * @param kval 按键值
+ * @return 新菜单索引
+ */
+static u8 app_debugset_cal_left_sel_idx(UICursorState curstate, keyValue kval)
+{
+    u8 menu_size = debugset_service_get_menu_len();
+    u8 cur_idx = curstate.left_menu_idx;
+
+    switch (kval)
+    {
+    case KEY_DATA_LEFT:
+        if (cur_idx > 7)
+            cur_idx = 8 * (cur_idx / 8) - 8;
+        else
+            cur_idx = 8 * ((menu_size - 1) / 8);
+        break;
+    case KEY_DATA_UP:
+        if (cur_idx > 0)
+            cur_idx--;
+        else
+            cur_idx = menu_size - 1;
+        break;
+    case KEY_DATA_RIGHT:
+        if (cur_idx < (menu_size - menu_size % 8))
+            cur_idx = 8 * (cur_idx / 8) + 8;
+        else
+            cur_idx = 0;
+        break;
+    case KEY_DATA_DOWN:
+        cur_idx++;
+        if (cur_idx > menu_size - 1)
+            cur_idx = 0;
+        break;
+    default:
+        break;
+    }
+    return cur_idx;
+}
+
+/**
+ * @brief 根据按键输入计算右侧数据选中索引
+ * @param curstate 当前光标状态
+ * @param kval 按键值
+ * @return 新数据项索引
+ */
+static u8 app_debugset_cal_right_sel_idx(UICursorState curstate, keyValue kval)
+{
+    u8 menu_len = debugset_service_get_items_len(curstate.left_menu_idx);
+    u8 cur_idx = curstate.right_data_idx;
+
+    if (kval == KEY_DATA_DOWN)
+    {
+        if (cur_idx < menu_len - 1)
+            cur_idx++;
+        else
+            cur_idx = 0;
+    }
+    else if (kval == KEY_DATA_UP)
+    {
+        if (cur_idx > 0)
+            cur_idx--;
+        else
+            cur_idx = menu_len - 1;
+    }
+    else if (kval == KEY_DATA_RIGHT)
+    {
+        if (cur_idx < (menu_len - menu_len % 8))
+            cur_idx = 8 * (cur_idx / 8) + 8;
+        else
+            cur_idx = 0;
+    }
+    else if (kval == KEY_DATA_LEFT)
+    {
+        if (cur_idx > 7)
+            cur_idx = 8 * (cur_idx / 8) - 8;
+        else
+            cur_idx = 8 * ((menu_len - 1) / 8);
+    }
+
+    return cur_idx;
+}
+
+/**
+ * @brief 检查当前菜单是否需要密码验证
+ * @param menu_idx 菜单索引 (0=状态信息, 1=系统设置)
+ * @return true 需要密码, false 不需要密码
+ */
+static bool app_debugset_is_password_required(u8 menu_idx)
+{
+    // 状态信息(索引0)不需要密码
+    // 系统设置(索引1)需要密码
+    return (menu_idx == DEBUGSET_MENU_SYSTEM_SET);
+}
+
+/**
+ * @brief 检查系统设置密码是否已验证
+ * @return true 已验证, false 未验证
+ */
+static bool app_debugset_is_verified(void)
+{
+    return s_system_set_verified;
+}
+
+/**
+ * @brief 设置密码验证状态
+ * @param verified 验证状态
+ */
+static void app_debugset_set_verified(bool verified)
+{
+    s_system_set_verified = verified;
+}
+
+/**
+ * @brief 处理开关类型设置（退出/投入）
+ * @param kval 按键值
+ * @return 设置结果值
+ */
+static float app_debugset_handle_switch_setting(keyValue kval)
+{
+    float val = 0;
+    
+    if (kval == KEY_DATA_ENTER)
+    {
+        // 获取当前设置值
+        val = ui_manager_comp_get_valist_spinbox_value();
+        printf("%s: Switch setting confirmed, value = %f\n", __FUNCTION__, val);
+        
+        // 调用service层保存设置
+        if (s_current_setting_idx != 0xFF)
+        {
+            debugset_service_set_item_value(s_current_setting_idx, (uint32_t)val);
+            
+            // 根据设置项执行相应操作
+            if (val == 1)  // 投入状态
+            {
+                switch (s_current_setting_idx)
+                {
+                    case SYSSET_ITEM_FACTORY_RESET:
+                        debugset_service_factory_reset();
+                        break;
+                    case SYSSET_ITEM_CLEAR_HISTORY:
+                        debugset_service_clear_history();
+                        break;
+                    case SYSSET_ITEM_CLEAR_ENERGY:
+                        debugset_service_clear_energy();
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
+    }
+    else
+    {
+        // 处理上下键切换选项
+        val = app_set_var_list_handle_event(kval);
+    }
+    
+    return val;
+}
+
+/**
+ * @brief 处理数值类型设置
+ * @param kval 按键值
+ * @return 设置结果值
+ */
+static float app_debugset_handle_number_setting(keyValue kval)
+{
+    float val = 0;
+    
+    if (kval == KEY_DATA_ENTER)
+    {
+        // 获取当前设置值
+        val = ui_manager_comp_get_valist_spinbox_value();
+        printf("%s: Number setting confirmed, value = %f\n", __FUNCTION__, val);
+        
+        // 调用service层保存设置
+        if (s_current_setting_idx != 0xFF)
+        {
+            debugset_service_set_item_value(s_current_setting_idx, (uint32_t)val);
+        }
+    }
+    else
+    {
+        // 处理上下键调整数值
+        val = app_set_var_list_handle_event(kval);
+    }
+    
+    return val;
+}
+
+/**
+ * @brief 处理时间设置
+ * @param kval 按键值
+ * @return 操作结果
+ */
+static uint32_t app_debugset_handle_datetime_setting(keyValue kval)
+{
+    uint32_t result = app_datetime_set_handle_event(kval);
+    
+    if (result == DATETIME_OP_OK)
+    {
+        // 获取设置的时间值
+        datetime_value_t new_time = app_datetime_set_get_value();
+        printf("%s: Datetime setting confirmed: %04d-%02d-%02d %02d:%02d:%02d\n", __FUNCTION__,
+               new_time.year, new_time.month, new_time.day,
+               new_time.hour, new_time.minute, new_time.second);
+        
+        // 调用service层保存时间
+        debugset_service_set_datetime(&new_time);
+    }
+    
+    return result;
+}
+
+/**
+ * @brief 处理密码设置
+ * @param kval 按键值
+ * @return 设置结果值
+ */
+static float app_debugset_handle_password_setting(keyValue kval)
+{
+    float val = 0;
+
+    if (kval == KEY_DATA_ENTER)
+    {
+        // 获取当前设置值
+        val = ui_manager_comp_get_valist_spinbox_value();
+        printf("%s: Password setting enter pressed, value = %04d\n", __FUNCTION__, (int)val);
+
+        // 验证密码范围
+        if (val >= 0 && val <= 9999)
+        {
+            // 临时存储新密码，等待用户确认
+            s_new_password_temp = (uint16_t)val;
+            s_password_modify_pending = true;
+
+            // 弹出确认对话框
+            confirm_dialog_config_t pwd_confirm_config = {
+                .title = "系统设置",
+                .message = "您确定要修改当前密码吗？"
+            };
+
+            UICursorState curstate = ui_manager_get_cursor();
+            curstate.cursor_pos = CURSOR_CONFIRM_SAVE;
+            ui_manager_cursor_set_value(curstate);
+            ui_manager_comp_create_confirm_save_with_config(&pwd_confirm_config);
+        }
+    }
+    else
+    {
+        // 处理上下键调整数值
+        val = app_set_var_list_handle_event(kval);
+    }
+
+    return val;
+}
+
+/**
+ * @brief 处理系数校准确认对话框
+ * @param kval 按键值
+ * @return 确认结果
+ */
+static bool app_debugset_handle_calibration_confirm(keyValue kval)
+{
+    bool result = false;
+    
+    if (kval == KEY_DATA_ENTER)
+    {
+        result = ui_manager_comp_get_confirm_save_result();
+        printf("%s: Calibration confirm result = %d\n", __FUNCTION__, result);
+        
+        if (result)
+        {
+            // 执行校准
+            debugset_service_calibrate();
+        }
+    }
+    else if (kval == KEY_DATA_LEFT || kval == KEY_DATA_RIGHT)
+    {
+        // 切换焦点
+        ui_manager_comp_switch_confirm_save_focus();
+    }
+    
+    return result;
+}
+
+/**
+ * @brief 处理组件级事件(密码输入、数值修改、确认保存)
+ * @param kval 按键值
+ */
+void app_debugset_process_compenents_handle_event(keyValue kval)
+{
+    UICursorState curstate = ui_manager_get_cursor();
+    float val = 0;
+    GeneralListPageConfig_t config = {0};
+    PageCtx dev_info_ctx = {0};
+    bool confirm_result = false;
+
+    switch (curstate.cursor_pos)
+    {
+    case CURSOR_INPUT_PWD:
+        // 处理密码输入
+        val = app_input_pwd_handle_event(kval);
+        if (kval == KEY_DATA_ENTER)
+        {
+            printf("%s touch enter key, left menu index = %d, pwd = %f\n", __FUNCTION__, curstate.left_menu_idx, val);
+            // 验证密码(使用与设备设置相同的密码)
+            if (val == SUPER_PWD || val == Password_opt[2].value)
+            {
+                // 密码正确,标记为已验证并显示系统设置
+                app_debugset_set_verified(true);
+                curstate.cursor_pos = CURSOR_RIGHT_DATA;
+                curstate.right_data_idx = 0;
+                ui_manager_cursor_set_value(curstate);
+                debugset_service_get_show_ui_data(ui_manager_get_page_ctx(), curstate.left_menu_idx, curstate.right_data_idx, &config, app_debugset_is_verified());
+                ui_manager_select_list_data(curstate, &config);
+            }
+            else
+            {
+                // 密码错误,返回菜单选择
+                curstate.cursor_pos = CURSOR_LEFT_MENU;
+                ui_manager_cursor_set_value(curstate);
+                debugset_service_get_show_ui_data(ui_manager_get_page_ctx(), curstate.left_menu_idx, curstate.right_data_idx, &config, app_debugset_is_verified());
+                ui_manager_select_list_data(curstate, &config);
+            }
+        }
+        else if (kval == KEY_DATA_BACK || kval == KEY_DATA_CANCEL)
+        {
+            // 取消密码输入,返回菜单选择
+            curstate.cursor_pos = CURSOR_LEFT_MENU;
+            ui_manager_cursor_set_value(curstate);
+            debugset_service_get_show_ui_data(ui_manager_get_page_ctx(), curstate.left_menu_idx, curstate.right_data_idx, &config, app_debugset_is_verified());
+            ui_manager_select_list_data(curstate, &config);
+        }
+        break;
+
+    case CURSOR_CHANGE_VAL:
+        // 处理数值修改(用于系统设置)
+        if (s_current_setting_idx != 0xFF)
+        {
+            if (debugset_service_is_switch_type(s_current_setting_idx))
+            {
+                val = app_debugset_handle_switch_setting(kval);
+            }
+            else if (debugset_service_is_number_type(s_current_setting_idx))
+            {
+                val = app_debugset_handle_number_setting(kval);
+            }
+            else if (s_current_setting_idx == SYSSET_ITEM_PASSWORD)
+            {
+                val = app_debugset_handle_password_setting(kval);
+            }
+        }
+        
+        if (kval == KEY_DATA_ENTER || kval == KEY_DATA_BACK || kval == KEY_DATA_CANCEL)
+        {
+            // 密码设置按ENTER后进入确认对话框，不在此处返回
+            if (kval == KEY_DATA_ENTER && s_current_setting_idx == SYSSET_ITEM_PASSWORD)
+            {
+                // 密码设置已弹出确认对话框，不执行返回操作
+                // 确认结果在 CURSOR_CONFIRM_SAVE 中处理
+            }
+            else
+            {
+                // 返回数据选择
+                curstate.cursor_pos = CURSOR_RIGHT_DATA;
+                ui_manager_cursor_set_value(curstate);
+                s_current_setting_idx = 0xFF;  // 清除当前设置项
+                debugset_service_get_show_ui_data(ui_manager_get_page_ctx(), curstate.left_menu_idx, curstate.right_data_idx, &config, app_debugset_is_verified());
+                ui_manager_select_list_data(curstate, &config);
+            }
+        }
+        break;
+
+    case CURSOR_SET_IP:
+        // 处理时间设置
+        if (s_current_setting_idx == SYSSET_ITEM_DATETIME)
+        {
+            uint32_t result = app_debugset_handle_datetime_setting(kval);
+            
+            if (result == DATETIME_OP_OK || result == DATETIME_OP_CANCEL || 
+                kval == KEY_DATA_BACK || kval == KEY_DATA_CANCEL)
+            {
+                // 返回数据选择
+                curstate.cursor_pos = CURSOR_RIGHT_DATA;
+                ui_manager_cursor_set_value(curstate);
+                s_current_setting_idx = 0xFF;  // 清除当前设置项
+                debugset_service_get_show_ui_data(ui_manager_get_page_ctx(), curstate.left_menu_idx, curstate.right_data_idx, &config, app_debugset_is_verified());
+                ui_manager_select_list_data(curstate, &config);
+            }
+        }
+        break;
+
+    case CURSOR_CONFIRM_SAVE:
+        // 处理确认对话框（系数校准、恢复出厂设置、清除历史记录、电度清除、密码修改）
+        if (s_current_setting_idx == SYSSET_ITEM_CALIBRATION ||
+            s_current_setting_idx == SYSSET_ITEM_FACTORY_RESET ||
+            s_current_setting_idx == SYSSET_ITEM_CLEAR_HISTORY ||
+            s_current_setting_idx == SYSSET_ITEM_CLEAR_ENERGY ||
+            s_current_setting_idx == SYSSET_ITEM_PASSWORD)
+        {
+            if (kval == KEY_DATA_ENTER)
+            {
+                confirm_result = ui_manager_comp_get_confirm_save_result();
+                printf("%s: Confirm result = %d for item %d\n", __FUNCTION__, confirm_result, s_current_setting_idx);
+
+                if (confirm_result)
+                {
+                    // 根据设置项执行相应操作
+                    switch (s_current_setting_idx)
+                    {
+                        case SYSSET_ITEM_FACTORY_RESET:
+                            debugset_service_factory_reset();
+                            break;
+                        case SYSSET_ITEM_CLEAR_HISTORY:
+                            debugset_service_clear_history();
+                            break;
+                        case SYSSET_ITEM_CLEAR_ENERGY:
+                            debugset_service_clear_energy();
+                            break;
+                        case SYSSET_ITEM_CALIBRATION:
+                            debugset_service_calibrate();
+                            break;
+                        case SYSSET_ITEM_PASSWORD:
+                            // 执行密码更新操作
+                            if (s_password_modify_pending)
+                            {
+                                debugset_service_set_password(s_new_password_temp);
+                                printf("%s: Password updated to %04d\n", __FUNCTION__, s_new_password_temp);
+                                s_password_modify_pending = false;
+                                s_new_password_temp = 0;
+                            }
+                            break;
+                        default:
+                            break;
+                    }
+                }
+                else
+                {
+                    // 用户取消密码修改，清除临时状态
+                    if (s_current_setting_idx == SYSSET_ITEM_PASSWORD && s_password_modify_pending)
+                    {
+                        printf("%s: Password modification cancelled\n", __FUNCTION__);
+                        s_password_modify_pending = false;
+                        s_new_password_temp = 0;
+                    }
+                }
+
+                // 返回数据选择
+                curstate.cursor_pos = CURSOR_RIGHT_DATA;
+                ui_manager_cursor_set_value(curstate);
+                s_current_setting_idx = 0xFF;  // 清除当前设置项
+                debugset_service_get_show_ui_data(ui_manager_get_page_ctx(), curstate.left_menu_idx, curstate.right_data_idx, &config, app_debugset_is_verified());
+                ui_manager_select_list_data(curstate, &config);
+            }
+            else if (kval == KEY_DATA_BACK || kval == KEY_DATA_CANCEL)
+            {
+                // 取消，返回数据选择
+                // 如果是密码修改，清除临时状态
+                if (s_current_setting_idx == SYSSET_ITEM_PASSWORD && s_password_modify_pending)
+                {
+                    printf("%s: Password modification cancelled by back/cancel key\n", __FUNCTION__);
+                    s_password_modify_pending = false;
+                    s_new_password_temp = 0;
+                }
+
+                curstate.cursor_pos = CURSOR_RIGHT_DATA;
+                ui_manager_cursor_set_value(curstate);
+                s_current_setting_idx = 0xFF;
+                debugset_service_get_show_ui_data(ui_manager_get_page_ctx(), curstate.left_menu_idx, curstate.right_data_idx, &config, app_debugset_is_verified());
+                ui_manager_select_list_data(curstate, &config);
+            }
+            else if (kval == KEY_DATA_LEFT || kval == KEY_DATA_RIGHT)
+            {
+                // 切换焦点
+                ui_manager_comp_switch_confirm_save_focus();
+            }
+        }
+        break;
+
+    default:
+        break;
+    }
+}
+
+
+
+/**
+ * @brief 出厂调试页面主事件处理函数
+ * @param kval 按键值
+ */
+void app_debugset_handle_event(keyValue kval)
+{
+    UICursorState curstate = ui_manager_get_cursor();
+    PageCtx dev_info_ctx = {0};
+    GeneralListPageConfig_t config = {0};
+
+    // 首先处理组件级事件
+    if (curstate.cursor_pos > CURSOR_RIGHT_DATA)
+    {
+        app_debugset_process_compenents_handle_event(kval);
+        return;
+    }
+
+    switch (kval)
+    {
+    case KEY_DATA_BACK:
+        if (curstate.cursor_pos == CURSOR_LEFT_MENU)
+        {
+            // 检查是否有未保存的更改
+            // TODO: 如需要可添加差异检查
+            // 目前直接返回主菜单
+            ui_manager_switch_to_main_menu(MAIN_MENU_DEBUG_TEST);
+            // 离开页面时重置验证状态
+            app_debugset_set_verified(false);
+        }
+        else if (curstate.cursor_pos == CURSOR_RIGHT_DATA)
+        {
+            // 返回左侧菜单
+            curstate.cursor_pos = CURSOR_LEFT_MENU;
+            curstate.right_data_idx = 0;
+            ui_manager_cursor_set_value(curstate);
+            debugset_service_get_show_ui_data(ui_manager_get_page_ctx(), curstate.left_menu_idx, curstate.right_data_idx, &config, app_debugset_is_verified());
+            ui_manager_select_list_data(curstate, &config);
+        }
+        break;
+
+    case KEY_DATA_ENTER:
+        if (curstate.cursor_pos == CURSOR_LEFT_MENU)
+        {
+            // 检查此菜单是否需要密码
+            if (app_debugset_is_password_required(curstate.left_menu_idx))
+            {
+                if (!app_debugset_is_verified())
+                {
+                    // 显示密码输入对话框
+                    curstate.cursor_pos = CURSOR_INPUT_PWD;
+                    ui_manager_cursor_set_value(curstate);
+                    ui_manager_comp_create_input_pwd();
+                }
+                else
+                {
+                    // 已验证,直接进入数据
+                    curstate.cursor_pos = CURSOR_RIGHT_DATA;
+                    curstate.right_data_idx = 0;
+                    ui_manager_cursor_set_value(curstate);
+                    debugset_service_get_show_ui_data(ui_manager_get_page_ctx(), curstate.left_menu_idx, curstate.right_data_idx, &config, app_debugset_is_verified());
+                    ui_manager_select_list_data(curstate, &config);
+                }
+            }
+            else
+            {
+                // 不需要密码,直接进入数据
+                curstate.cursor_pos = CURSOR_RIGHT_DATA;
+                curstate.right_data_idx = 0;
+                ui_manager_cursor_set_value(curstate);
+                debugset_service_get_show_ui_data(ui_manager_get_page_ctx(), curstate.left_menu_idx, curstate.right_data_idx, &config, app_debugset_is_verified());
+                ui_manager_select_list_data(curstate, &config);
+            }
+        }
+        else if (curstate.cursor_pos == CURSOR_RIGHT_DATA)
+        {
+            printf("%s touch enter!!\n", __FUNCTION__);
+
+            // 仅在系统设置菜单(索引1)且已验证时允许修改
+            if (curstate.left_menu_idx == DEBUGSET_MENU_SYSTEM_SET && app_debugset_is_verified())
+            {
+                u8 item_idx = curstate.right_data_idx;
+                s_current_setting_idx = item_idx;
+
+                if (item_idx == SYSSET_ITEM_DATETIME)
+                {
+                    // 系统时间设置 - 使用datetime组件
+                    datetime_value_t curr_datetime;
+                    debugset_service_get_datetime(&curr_datetime);
+
+                    curstate.cursor_pos = CURSOR_SET_IP;  // 复用IP设置的光标状态
+                    ui_manager_cursor_set_value(curstate);
+                    ui_manager_comp_create_datetime_set(&curr_datetime);
+                }
+                else if (item_idx == SYSSET_ITEM_CALIBRATION)
+                {
+                    // 系数校准 - 使用确认对话框（自定义标题和内容）
+                    confirm_dialog_config_t calib_config = {
+                        .title = "系统设置",
+                        .message = "确定是否一键校准"
+                    };
+                    curstate.cursor_pos = CURSOR_CONFIRM_SAVE;
+                    ui_manager_cursor_set_value(curstate);
+                    ui_manager_comp_create_confirm_save_with_config(&calib_config);
+                }
+                else if (item_idx == SYSSET_ITEM_FACTORY_RESET)
+                {
+                    // 恢复出厂设置 - 使用确认对话框
+                    confirm_dialog_config_t reset_config = {
+                        .title = "系统设置",
+                        .message = "确定是否恢复出厂设置"
+                    };
+                    curstate.cursor_pos = CURSOR_CONFIRM_SAVE;
+                    ui_manager_cursor_set_value(curstate);
+                    ui_manager_comp_create_confirm_save_with_config(&reset_config);
+                }
+                else if (item_idx == SYSSET_ITEM_CLEAR_HISTORY)
+                {
+                    // 清除历史记录 - 使用确认对话框
+                    confirm_dialog_config_t clear_history_config = {
+                        .title = "系统设置",
+                        .message = "确定是否清除历史记录"
+                    };
+                    curstate.cursor_pos = CURSOR_CONFIRM_SAVE;
+                    ui_manager_cursor_set_value(curstate);
+                    ui_manager_comp_create_confirm_save_with_config(&clear_history_config);
+                }
+                else if (item_idx == SYSSET_ITEM_CLEAR_ENERGY)
+                {
+                    // 电度清除 - 使用确认对话框
+                    confirm_dialog_config_t clear_energy_config = {
+                        .title = "系统设置",
+                        .message = "确定是否清除电度"
+                    };
+                    curstate.cursor_pos = CURSOR_CONFIRM_SAVE;
+                    ui_manager_cursor_set_value(curstate);
+                    ui_manager_comp_create_confirm_save_with_config(&clear_energy_config);
+                }
+                else
+                {
+                    // 其他设置项 - 使用set_valist组件
+                    UiSetValueOptDef set_opt = {0};
+                    sysset_op_result_t result = debugset_service_create_ui_config(item_idx, &set_opt);
+
+                    if (result == SYSSET_OP_SUCCESS)
+                    {
+                        curstate.cursor_pos = CURSOR_CHANGE_VAL;
+                        ui_manager_cursor_set_value(curstate);
+                        ui_manager_comp_create_set_valist(&set_opt);
+                    }
+                    else
+                    {
+                        printf("%s: Failed to create UI config for item %d, result=%d\n",
+                               __FUNCTION__, item_idx, result);
+                    }
+                }
+            }
+        }
+        break;
+
+    case KEY_DATA_UP:
+    case KEY_DATA_DOWN:
+    case KEY_DATA_LEFT:
+    case KEY_DATA_RIGHT:
+        if (curstate.cursor_pos == CURSOR_LEFT_MENU)
+        {
+            curstate.left_menu_idx = app_debugset_cal_left_sel_idx(curstate, kval);
+            // 切换离开系统设置时重置验证
+            if (curstate.left_menu_idx != DEBUGSET_MENU_SYSTEM_SET)
+            {
+                app_debugset_set_verified(false);
+            }
+        }
+        else if (curstate.cursor_pos == CURSOR_RIGHT_DATA)
+        {
+            curstate.right_data_idx = app_debugset_cal_right_sel_idx(curstate, kval);
+        }
+
+        ui_manager_cursor_set_value(curstate);
+        debugset_service_get_show_ui_data(ui_manager_get_page_ctx(), curstate.left_menu_idx, curstate.right_data_idx, &config, app_debugset_is_verified());
+        ui_manager_select_list_data(curstate, &config);
+        break;
+
+    default:
+        break;
+    }
+}
+
+/**
+ * @brief 创建出厂调试页面列表数据
+ * @param ctx 页面上下文
+ * @param menu_sel_idx 选中菜单索引 (0=状态信息, 1=系统设置)
+ * @param item_sel_idx 菜单内选中项索引
+ */
+void app_debugset_create_list_data(PageCtx *ctx, u8 menu_sel_idx, u8 item_sel_idx)
+{
+    GeneralListPageConfig_t config = {0};
+
+    // 创建新列表时重置验证状态(进入页面)
+    app_debugset_set_verified(false);
+    s_current_setting_idx = 0xFF;
+
+    debugset_service_get_show_ui_data(ctx, menu_sel_idx, item_sel_idx, &config, app_debugset_is_verified());
+
+    ui_manager_gerneral_list(ctx, &config);
+}

dtu/dtu_main_t536/app/ui/app/app_debugset.h

@@ -0,0 +1,21 @@
+#ifndef _APP_DEBUGSET_H
+#define _APP_DEBUGSET_H
+
+#include "../data/key_manager.h"
+#include "ui_config.h"
+
+/**
+ * @brief 处理出厂调试页面事件
+ * @param kval 按键值
+ */
+void app_debugset_handle_event(keyValue kval);
+
+/**
+ * @brief 创建出厂调试页面列表数据
+ * @param ctx 页面上下文
+ * @param menu_sel_idx 选中菜单索引 (0=状态信息, 1=系统设置)
+ * @param item_sel_idx 菜单内选中项索引
+ */
+void app_debugset_create_list_data(PageCtx *ctx, u8 menu_sel_idx, u8 item_sel_idx);
+
+#endif // _APP_DEBUGSET_H

dtu/dtu_main_t536/app/ui/app/app_dev_set.c

@@ -0,0 +1,373 @@
+#include "app_dev_set.h"
+#include "ui_manager.h"
+#include "data_config.h"
+#include "components/app_set_var_list.h"
+#include "app_ip_address.h"
+#include "service_dev_set.h"
+
+/**
+ * @brief 计算左侧菜单
+ * @param  curstate         参数
+ * @param  kval             参数
+ * @return u8 
+ * @date 2026-01-20
+ */
+u8 app_ds_cal_left_sel_idx(UICursorState curstate, PwdType ptype , keyValue kval)
+{
+    u8 menu_size=0;
+    u8 cur_idx = curstate.left_menu_idx; // 获取当前下标
+
+    if (ptype == UI_PWD_TYPE_NORMAL)
+    {
+        menu_size = ds_service_get_menu_len_by_page(PAGE_DEV_SET_SHOW);
+    }
+    else if (ptype == UI_PWD_TYPE_SUPER)
+    {
+        menu_size = ds_service_get_menu_len_by_page(PAGE_DEV_SET);
+    }
+    
+    switch (kval)
+    {
+    case KEY_DATA_LEFT:
+        if (cur_idx > 7)
+            cur_idx = 8 * (cur_idx / 8) - 8;
+        else
+            cur_idx = 8 * ((menu_size - 1) / 8);
+        break;
+    case KEY_DATA_UP:
+        if (cur_idx > 0)
+            cur_idx--;
+        else
+            cur_idx = menu_size - 1;
+        break;
+    case KEY_DATA_RIGHT:
+        if (cur_idx < (menu_size - menu_size % 8))
+            cur_idx = 8 * (cur_idx / 8) + 8;
+        else
+            cur_idx = 0;
+    case KEY_DATA_DOWN:
+        cur_idx ++;
+        if (cur_idx > menu_size -1)
+            cur_idx = 0;
+        
+    default:
+        break;
+    }
+    return  cur_idx;
+}
+
+/**
+ * @brief 计算光标所处位置
+ * @param  curstate         光标数据
+ * @param  kval             键盘值
+ * @return u8 
+ * @date 2026-01-12
+ */
+u8 app_ds_cal_right_sel_idx(UICursorState curstate, PwdType ptype , keyValue kval)
+{
+    u8 itemsize=0;
+    u8 cur_idx = curstate.right_data_idx; // 获取当前下标
+
+    if (ptype == UI_PWD_TYPE_NORMAL)    //普通用户
+    {
+        itemsize = ds_service_get_items_len_by_page(PAGE_DEV_SET_SHOW , curstate.left_menu_idx);
+    }
+    else if (ptype == UI_PWD_TYPE_SUPER)    //系统用户
+    {
+        itemsize = ds_service_get_items_len_by_page(PAGE_DEV_SET , curstate.left_menu_idx);
+    }
+
+    if (kval == KEY_DATA_DOWN)
+    {
+        if (cur_idx < itemsize - 1)
+            cur_idx++;
+
+        else
+            cur_idx = 0;
+    }
+    else if (kval == KEY_DATA_UP)
+    {
+        if (cur_idx > 0)
+            cur_idx--;
+        else
+            cur_idx = itemsize - 1;
+    }
+    else if (kval == KEY_DATA_RIGHT)
+    {
+        if (cur_idx < (itemsize - itemsize % 8))
+            cur_idx = 8 * (cur_idx / 8) + 8;
+        else
+            cur_idx = 0;
+    }
+    else if (kval == KEY_DATA_LEFT)
+    {
+        if (cur_idx > 7)
+            cur_idx = 8 * (cur_idx / 8) - 8;
+        else
+            cur_idx = 8 * ((itemsize - 1) / 8);
+    }
+
+    return cur_idx;
+}
+
+/**
+ * @brief 获取当前所选数据
+ * @param  curstate         光标数据
+ * @return Para_OPTTypeDef 
+ * @date 2026-01-12
+ */
+// Para_OPTTypeDef app_dev_set_get_manu_data(UICursorState curstate)
+// {
+//     Para_OPTTypeDef *manu ;
+//     switch (curstate.left_menu_idx)      //通过左侧选项判断使用哪个数组显示数据
+//     {
+//     case SUB_DEV_OPT: // 设备参数
+//         if (ui_manager_get_cur_pwdtype() == UI_PWD_TYPE_SUPER)
+//         {
+//             manu = Device_parset_opt;
+//         }
+//         else
+//         {
+//             manu = Dev_usrset_opt;
+//         }
+//         break;
+//     case SUB_COM_OPT:
+//         manu = Serial_Statute_opt;
+//         break;
+
+//     case SUB_COMSTATUTE_OPT:
+//         manu = Statute_par_opt;
+//         break;
+//     default:
+//         manu = Device_parset_opt;
+//         break;
+//     }
+
+//     return manu[curstate.right_data_idx];
+// }
+DataModule app_ds_get_module_type(void)
+{
+    if (ui_manager_get_cur_pwdtype() == UI_PWD_TYPE_SUPER)
+    {
+        return MODULE_DEV_SET;
+    }
+    else
+    {
+        return MODULE_DEV_SET_SHOW;
+    }
+}
+
+/**
+ * @brief  装置设置页面处理组件点击事件
+ * @param  kval             键盘值
+ * @date 2026-01-12
+ */
+void app_ds_process_compenents_handle_event(keyValue kval)
+{
+    UICursorState curstate = ui_manager_get_cursor();
+    float fval = 0;
+    uint8_t u8val = 0;
+    uint32_t u32val = 0;
+    GeneralListPageConfig_t config = {0};
+    PageCtx dev_info_ctx = {0};
+    switch (curstate.cursor_pos)
+    {
+    case CURSOR_CHANGE_VAL:
+        fval = app_set_var_list_handle_event(kval);
+        if (kval == KEY_DATA_ENTER) //
+        {            
+            //修改数据
+            ds_service_modify_menu_data(app_ds_get_module_type() ,curstate.left_menu_idx , curstate.right_data_idx , fval); 
+            curstate.cursor_pos = CURSOR_RIGHT_DATA;
+            ui_manager_cursor_set_value(curstate);
+            ds_service_get_show_ui_data(ui_manager_get_page_ctx() , curstate.left_menu_idx , curstate.right_data_idx, &config);
+            ui_manager_select_list_data(curstate , &config);
+        }
+        else if (kval == KEY_DATA_BACK || kval == KEY_DATA_CANCEL)
+        {
+            //返回或者取消则返回菜单界面
+            curstate.cursor_pos = CURSOR_RIGHT_DATA;
+            ui_manager_cursor_set_value(curstate);
+            ds_service_get_show_ui_data(ui_manager_get_page_ctx() , curstate.left_menu_idx , curstate.right_data_idx, &config);
+            ui_manager_select_list_data(curstate , &config);
+        }   
+        break;
+    case CURSOR_SET_IP:
+        u8val = app_ip_address_handle_event(kval);
+        
+        if (kval == KEY_DATA_ENTER)
+        {
+            // printf("%s val = %d \n", __FUNCTION__ , val);
+            switch (u8val)
+            {
+            case IP_ADDRESS_OP_OK:
+                
+                u32val = ui_manager_comp_get_ip_address_value();
+                ds_service_modify_menu_data_ip(app_ds_get_module_type(), curstate.left_menu_idx, curstate.right_data_idx, u32val);
+                curstate.cursor_pos = CURSOR_RIGHT_DATA;
+                ui_manager_cursor_set_value(curstate);
+                ds_service_get_show_ui_data(ui_manager_get_page_ctx() , curstate.left_menu_idx , curstate.right_data_idx, &config);
+                ui_manager_select_list_data(curstate , &config);
+                break;
+            case IP_ADDRESS_OP_CANCEL:
+                curstate.cursor_pos = CURSOR_RIGHT_DATA;
+                ui_manager_cursor_set_value(curstate);
+                ds_service_get_show_ui_data(ui_manager_get_page_ctx(), curstate.left_menu_idx, curstate.right_data_idx, &config);
+                ui_manager_select_list_data(curstate, &config);
+                break;
+            default:
+                break;
+            }
+        }
+        else if (kval == KEY_DATA_CANCEL || kval == KEY_DATA_BACK)
+        {
+            curstate.cursor_pos = CURSOR_RIGHT_DATA;
+            ui_manager_cursor_set_value(curstate);
+            ds_service_get_show_ui_data(ui_manager_get_page_ctx() , curstate.left_menu_idx , curstate.right_data_idx, &config);
+            ui_manager_select_list_data(curstate , &config);
+        }
+        break;
+
+    case CURSOR_CONFIRM_SAVE:   //确认保存
+        u8val = app_confirm_handle_event(kval);
+        if (kval == KEY_DATA_ENTER)
+        {
+            // 确认保存
+            if (u8val)
+            {
+                // 确认保存
+                ds_set_data_to_system(app_ds_get_module_type());
+                printf("%s confirm save\n", __FUNCTION__);
+            }
+            else 
+            {
+                // 取消保存
+                ds_service_restore_default_values(app_ds_get_module_type());
+                printf("%s cancel save\n", __FUNCTION__);
+            }
+            // ui_manager_comp_show_confirm_save(false);
+            ui_manager_switch_to_main_menu(MAIN_MENU_DEV_SET); //回去菜单页
+        }
+        else if (kval == KEY_DATA_BACK || kval == KEY_DATA_CANCEL)
+        {
+            // ui_manager_comp_show_confirm_save(false);
+            // 返回或取消，返回菜单界面
+            curstate.cursor_pos = CURSOR_LEFT_MENU;
+            ui_manager_cursor_set_value(curstate);
+            ds_service_get_show_ui_data(ui_manager_get_page_ctx() , curstate.left_menu_idx , curstate.right_data_idx, &config);
+        }
+        break;
+        
+    default:
+        break;
+    }
+}
+
+
+/**
+ * @brief  装置设置页面处理页面点击事件
+ * @param  kval             键盘值
+ * @date 2026-01-12
+ */
+void app_dev_set_handle_event(keyValue kval)
+{
+    UICursorState curstate = ui_manager_get_cursor();
+    PageCtx dev_info_ctx = {0};
+    GeneralListPageConfig_t config = {0};
+
+    if (curstate.cursor_pos > CURSOR_RIGHT_DATA)
+    {
+        app_ds_process_compenents_handle_event(kval);
+        return;
+    }
+
+    switch (kval)
+    {
+    case KEY_DATA_BACK:
+        if (curstate.cursor_pos == CURSOR_LEFT_MENU)    
+        {
+            // 检查是否有数据差异
+            if (ds_service_check_diff())
+            {
+                // 有差异，显示确认保存弹窗
+                curstate.cursor_pos = CURSOR_CONFIRM_SAVE;
+                ui_manager_cursor_set_value(curstate);
+                ui_manager_comp_create_confirm_save();
+            }
+            else
+            {
+                ui_manager_switch_to_main_menu(MAIN_MENU_DEV_SET); // 回去菜单页
+            }
+
+        }
+        else if (curstate.cursor_pos == CURSOR_RIGHT_DATA)
+        {
+            curstate.cursor_pos = CURSOR_LEFT_MENU; //光标回左边
+            curstate.right_data_idx = 0;            //下标值清空
+            ui_manager_cursor_set_value(curstate);
+            ds_service_get_show_ui_data(ui_manager_get_page_ctx() , curstate.left_menu_idx , curstate.right_data_idx, &config);
+            ui_manager_select_list_data(curstate , &config);
+        }
+        break;
+    case KEY_DATA_ENTER:  //确认键                          
+        if (curstate.cursor_pos == CURSOR_LEFT_MENU)
+        {
+            //按确定进去数据区
+            curstate.cursor_pos = CURSOR_RIGHT_DATA;
+            ui_manager_cursor_set_value(curstate);
+            ds_service_get_show_ui_data(ui_manager_get_page_ctx() , curstate.left_menu_idx , curstate.right_data_idx, &config);
+            ui_manager_select_list_data(curstate , &config);
+        }
+        else if(curstate.cursor_pos = CURSOR_RIGHT_DATA)
+        {
+
+            UiSetValueOptDef set_opt = {0};
+            ds_service_get_sel_setval_data(ui_manager_get_page_ctx() , &set_opt);
+
+            if(set_opt.type == UISETOPT_TYPE_LIST || set_opt.type == UISETOPT_TYPE_NUMBER)
+            {
+                curstate.cursor_pos = CURSOR_CHANGE_VAL;
+                ui_manager_cursor_set_value(curstate);
+                ui_manager_comp_create_set_valist(&set_opt);
+            }
+            else if (set_opt.type == UISETOPT_TYPE_IP)
+            {
+                curstate.cursor_pos = CURSOR_SET_IP;
+                ui_manager_cursor_set_value(curstate);
+                ui_manager_comp_create_ip_address(set_opt.curr_ip);
+            }
+        }
+        break;
+    case KEY_DATA_DOWN:     //下键
+    case KEY_DATA_RIGHT:    //右键
+    case KEY_DATA_UP:       //上键
+    case KEY_DATA_LEFT:     //左键
+        //计算下标
+        if (curstate.cursor_pos == CURSOR_LEFT_MENU)
+        {   
+            curstate.left_menu_idx = app_ds_cal_left_sel_idx(curstate, ui_manager_get_cur_pwdtype() , kval);
+        }
+        else if(curstate.cursor_pos = CURSOR_RIGHT_DATA)
+        {
+            curstate.right_data_idx = app_ds_cal_right_sel_idx(curstate, ui_manager_get_cur_pwdtype() , kval);
+        }
+
+        ui_manager_cursor_set_value(curstate);
+        ds_service_get_show_ui_data(ui_manager_get_page_ctx() , curstate.left_menu_idx , curstate.right_data_idx, &config);
+        ui_manager_select_list_data(curstate , &config);
+
+        break;
+    default:
+        break;
+    }
+}
+
+
+void app_dev_set_create_list_data(PageCtx *ctx , u8 manu_sel_idx , u8 item_sel_idex)
+{
+    GeneralListPageConfig_t config = {0};
+    
+    ds_service_get_show_ui_data(ctx, 0, 0, &config);
+
+    ui_manager_gerneral_list(ctx , &config);
+}

dtu/dtu_main_t536/app/ui/app/app_dev_set.h

@@ -0,0 +1,10 @@
+#ifndef _APP_DEV_SET_H
+#define _APP_DEV_SET_H
+#include "../data/key_manager.h"
+#include "ui_config.h"
+
+void app_dev_set_handle_event(keyValue kval);
+
+void app_dev_set_create_list_data(PageCtx *ctx , u8 manu_sel_idx , u8 item_sel_idex);
+
+#endif

dtu/dtu_main_t536/app/ui/app/app_dev_set_show.c

@@ -0,0 +1,113 @@
+#include "app_dev_set_show.h"
+#include "ui_manager.h"
+#include "data_config.h"
+#include "service_dev_set.h"
+
+/**
+ * @brief 计算光标所处位置
+ * @param  curstate         光标数据
+ * @param  kval             键盘值
+ * @return u8 
+ * @date 2026-01-12
+ */
+u8 app_dss_cal_right_sel_idx(UICursorState curstate, PwdType ptype , keyValue kval)
+{
+    u8 itemsize=0;
+    u8 cur_idx = curstate.right_data_idx; // 获取当前下标
+
+    //获取数据项数据
+    itemsize = ds_service_get_items_len_by_page(PAGE_DEV_SET_SHOW , curstate.left_menu_idx);
+    
+    switch (kval)
+    {
+    case KEY_DATA_DOWN:
+    case KEY_DATA_RIGHT:
+        if (cur_idx < (itemsize - itemsize % 8))
+            cur_idx = 8 * (cur_idx / 8) + 8;
+        else
+            cur_idx = 0;
+        
+        break;
+    case KEY_DATA_UP:
+    case KEY_DATA_LEFT:
+        if (cur_idx > 7)
+            cur_idx = 8 * (cur_idx / 8) - 8;
+        else
+            cur_idx = 8 * ((itemsize - 1) / 8);
+
+        break;
+    default:
+        break;
+    }
+    return cur_idx;
+}
+
+/**
+ * @brief 装置参数查看页面处理点击事件
+ * @param  kval             参数
+ * @date 2026-01-12
+ */
+void app_dev_set_show_handle_event(keyValue kval)
+{
+    UICursorState curstate = ui_manager_get_cursor();
+    PageCtx dev_info_ctx = {0};
+    GeneralListPageConfig_t config = {0};
+    switch (kval)
+    {
+    case KEY_DATA_BACK:
+        if (curstate.cursor_pos == CURSOR_LEFT_MENU)        //光标在左边
+        {
+            ui_manager_switch_to_main_menu(MAIN_MENU_DEV_SET_SHOW);     //回到首页
+        }
+        else if (curstate.cursor_pos == CURSOR_RIGHT_DATA)  //光标在右边
+        {
+            curstate.cursor_pos = CURSOR_LEFT_MENU;
+            ui_manager_cursor_set_value(curstate);
+            ds_service_get_show_ui_data(ui_manager_get_page_ctx() , curstate.left_menu_idx , curstate.right_data_idx, &config);
+            ui_manager_select_list_data(curstate , &config);
+        }
+        break;
+    case KEY_DATA_ENTER:
+        if (curstate.cursor_pos == CURSOR_LEFT_MENU)
+        {
+            //按确定进去数据区
+            curstate.cursor_pos = CURSOR_RIGHT_DATA;
+            ui_manager_cursor_set_value(curstate);
+            ds_service_get_show_ui_data(ui_manager_get_page_ctx() , curstate.left_menu_idx , curstate.right_data_idx, &config);
+            ui_manager_select_list_data(curstate , &config);
+        }
+        break;
+    case KEY_DATA_DOWN:
+    case KEY_DATA_RIGHT:
+    case KEY_DATA_UP:
+    case KEY_DATA_LEFT:
+        //该页面只有一个菜单，所以左边菜单不需要做操作
+        if (curstate.cursor_pos == CURSOR_RIGHT_DATA)
+        {
+            curstate.right_data_idx = app_dss_cal_right_sel_idx(curstate, ui_manager_get_cur_pwdtype() , kval);
+            ui_manager_cursor_set_value(curstate);
+            ds_service_get_show_ui_data(ui_manager_get_page_ctx()  , curstate.left_menu_idx , curstate.right_data_idx, &config);
+            ui_manager_select_list_data(curstate , &config);
+        }
+        
+        break;
+    default:
+        break;
+    }
+}
+
+/**
+ * @brief  创建装置参数查看页面列表数据
+ * @param  ctx              参数
+ * @param  manu_sel_idx     参数
+ * @param  item_sel_idex    参数
+ * @date 2026-01-12
+ */
+void app_dev_set_show_create_list_data(PageCtx *ctx , u8 manu_sel_idx , u8 item_sel_idex)
+{
+    GeneralListPageConfig_t config = {0};
+    
+    ds_service_get_show_ui_data(ctx, 0, 0, &config);
+
+    ui_manager_gerneral_list(ctx , &config);
+}

dtu/dtu_main_t536/app/ui/app/app_dev_set_show.h

@@ -0,0 +1,11 @@
+#ifndef _APP_DEV_SET_SHOW_H
+#define _APP_DEV_SET_SHOW_H
+#include "../data/key_manager.h"
+#include "ui_config.h"
+
+void app_dev_set_show_handle_event(keyValue kval);
+
+void app_dev_set_show_create_list_data(PageCtx *ctx , u8 manu_sel_idx , u8 item_sel_idex);
+
+
+#endif

dtu/dtu_main_t536/app/ui/app/app_devinfo_page.c

@@ -0,0 +1,17 @@
+#include "app_devinfo_page.h"
+#include "ui_manager.h"
+
+void app_devinfo_page_handle_event(keyValue kval)
+{
+    //printf("%s kval : %d\n", __FUNCTION__, kval);
+    PageCtx dev_info_ctx = {0};
+    switch (kval)
+    {
+    case KEY_DATA_BACK:
+        ui_manager_switch_to_main_menu(MAIN_MENU_DEV_INFO);     //»Øµ½Ê×Ò³
+        break;
+    
+    default:
+        break;
+    }
+}

dtu/dtu_main_t536/app/ui/app/app_devinfo_page.h

@@ -0,0 +1,8 @@
+#ifndef _APP_DEVINFO_PAGE_H
+#define _APP_DEVINFO_PAGE_H
+#include "../data/key_manager.h"
+
+
+void app_devinfo_page_handle_event(keyValue kval);
+
+#endif

dtu/dtu_main_t536/app/ui/app/app_fix_set.c

@@ -0,0 +1,307 @@
+#include "app_fix_set.h"
+#include "service_fix_set.h"
+#include "ui_manager.h"
+#include "app_set_var_list.h"
+#include "app_confirm.h"
+
+/**
+ * @brief 计算左侧菜单
+ * @param  curstate         参数
+ * @param  kval             参数
+ * @return u8 
+ * @date 2026-01-20
+ */
+u8 app_fs_cal_left_sel_idx(UICursorState curstate, PwdType ptype , keyValue kval)
+{
+    u8 menu_size=0;
+    u8 cur_idx = curstate.left_menu_idx; // 获取当前下标
+
+    if (ptype == UI_PWD_TYPE_NORMAL)
+    {
+        menu_size = fs_service_get_menu_len_by_page(PAGE_DEV_FIX_SHOW);
+    }
+    else if (ptype == UI_PWD_TYPE_SUPER)
+    {
+        menu_size = fs_service_get_menu_len_by_page(PAGE_DEV_FIX);
+    }
+    
+    switch (kval)
+    {
+    case KEY_DATA_LEFT:
+        if (cur_idx > 7)
+            cur_idx = 8 * (cur_idx / 8) - 8;
+        else
+            cur_idx = 8 * ((menu_size - 1) / 8);
+        break;
+    case KEY_DATA_UP:
+        if (cur_idx > 0)
+            cur_idx--;
+        else
+            cur_idx = menu_size - 1;
+        break;
+    case KEY_DATA_RIGHT:
+        if (cur_idx < (menu_size - menu_size % 8))
+            cur_idx = 8 * (cur_idx / 8) + 8;
+        else
+            cur_idx = 0;
+    case KEY_DATA_DOWN:
+        cur_idx ++;
+        if (cur_idx > menu_size -1)
+            cur_idx = 0;
+        
+    default:
+        break;
+    }
+    return  cur_idx;
+}
+/**
+ * @brief 计算光标所处位置
+ * @param  curstate         光标数据
+ * @param  kval             键盘值
+ * @return u8 
+ * @date 2026-01-12
+ */
+u8 app_fs_cal_right_sel_idx(UICursorState curstate, PwdType ptype  , keyValue kval)
+{
+    u8 menu_len=0;
+    u8 cur_idx = curstate.right_data_idx; // 获取当前下标
+
+
+    
+    if (ptype == UI_PWD_TYPE_NORMAL)    //普通用户
+    {
+        menu_len = fs_service_get_items_len_by_page(PAGE_DEV_FIX_SHOW , curstate.left_menu_idx);
+    }
+    else if (ptype == UI_PWD_TYPE_SUPER)    //系统用户
+    {
+        menu_len = fs_service_get_items_len_by_page(PAGE_DEV_FIX , curstate.left_menu_idx);
+    }
+
+    if (kval == KEY_DATA_DOWN)
+    {
+        if (cur_idx < menu_len - 1)
+            cur_idx++;
+
+        else
+            cur_idx = 0;
+    }
+    else if (kval == KEY_DATA_UP)
+    {
+        if (cur_idx > 0)
+            cur_idx--;
+        else
+            cur_idx = menu_len - 1;
+    }
+    else if (kval == KEY_DATA_RIGHT)
+    {
+        if (cur_idx < (menu_len - menu_len % 8))
+            cur_idx = 8 * (cur_idx / 8) + 8;
+        else
+            cur_idx = 0;
+    }
+    else if (kval == KEY_DATA_LEFT)
+    {
+        if (cur_idx > 7)
+            cur_idx = 8 * (cur_idx / 8) - 8;
+        else
+            cur_idx = 8 * ((menu_len - 1) / 8);
+    }
+
+    return cur_idx;
+}
+
+DataModule app_fs_get_module_type(void)
+{
+    if (ui_manager_get_cur_pwdtype() == UI_PWD_TYPE_SUPER)
+    {
+        return MODULE_DEV_FIX;
+    }
+    else
+    {
+        return MODULE_DEV_FIX_SHOW;
+    }
+}
+
+/**
+ * @brief  装置设置页面处理组件点击事件
+ * @param  kval             键盘值
+ * @date 2026-01-12
+ */
+void app_fs_process_compenents_handle_event(keyValue kval)
+{
+    UICursorState curstate = ui_manager_get_cursor();
+    float val = 0;
+    GeneralListPageConfig_t config = {0};
+    PageCtx dev_info_ctx = {0};
+    switch (curstate.cursor_pos)
+    {
+    case CURSOR_CHANGE_VAL:     //设置值
+        val = app_set_var_list_handle_event(kval);
+        if (kval == KEY_DATA_ENTER) //确认修改
+        {
+            printf("%s touch enter key , left menu index = %d , val = %f\n", __FUNCTION__, curstate.left_menu_idx, val);
+            //修改数据
+            fs_service_modify_menu_data(app_fs_get_module_type() ,curstate.left_menu_idx , curstate.right_data_idx , val); 
+            curstate.cursor_pos = CURSOR_RIGHT_DATA;
+            ui_manager_cursor_set_value(curstate);
+            fs_service_get_show_ui_data(ui_manager_get_page_ctx() , curstate.left_menu_idx , curstate.right_data_idx, &config);
+            ui_manager_select_list_data(curstate , &config);
+        }
+        else if (kval == KEY_DATA_BACK || kval == KEY_DATA_CANCEL) 
+        {
+            //返回或者取消则返回菜单界面
+            curstate.cursor_pos = CURSOR_RIGHT_DATA;
+            ui_manager_cursor_set_value(curstate);
+            fs_service_get_show_ui_data(ui_manager_get_page_ctx() , curstate.left_menu_idx , curstate.right_data_idx, &config);
+            ui_manager_select_list_data(curstate , &config);
+        }
+        
+        break;
+    case CURSOR_CONFIRM_SAVE:   //确认保存
+        val = app_confirm_handle_event(kval);
+        if (kval == KEY_DATA_ENTER)
+        {
+            // 确认保存
+            if (val)
+            {
+                // 确认保存
+                fs_set_data_to_system(app_fs_get_module_type());
+                printf("%s confirm save\n", __FUNCTION__);
+            }
+            else 
+            {
+                // 取消保存
+                fs_service_restore_default_values(app_fs_get_module_type());
+                printf("%s cancel save\n", __FUNCTION__);
+            }
+            // ui_manager_comp_show_confirm_save(false);
+            ui_manager_switch_to_main_menu(MAIN_MENU_DEV_FIX); //回去菜单页
+        }
+        else if (kval == KEY_DATA_BACK || kval == KEY_DATA_CANCEL)
+        {
+            // ui_manager_comp_show_confirm_save(false);
+            // 返回或取消，返回菜单界面
+            curstate.cursor_pos = CURSOR_LEFT_MENU;
+            ui_manager_cursor_set_value(curstate);
+            fs_service_get_show_ui_data(ui_manager_get_page_ctx() , curstate.left_menu_idx , curstate.right_data_idx, &config);
+        }
+        break;
+    default:
+        break;
+    }
+}
+
+/**
+ * @brief  装置设置页面处理页面点击事件
+ * @param  kval             键盘值
+ * @date 2026-01-12
+ */
+void app_fix_set_handle_event(keyValue kval)
+{
+    UICursorState curstate = ui_manager_get_cursor();
+    PageCtx dev_info_ctx = {0};
+    GeneralListPageConfig_t config = {0};
+
+    if (curstate.cursor_pos > CURSOR_RIGHT_DATA)
+    {
+        app_fs_process_compenents_handle_event(kval);
+        return;
+    }
+
+    switch (kval)
+    {
+    case KEY_DATA_BACK: //返回
+        if (curstate.cursor_pos == CURSOR_LEFT_MENU)
+        {
+            // 检查是否有数据差异
+            if (fs_service_check_diff())
+            {
+                // 有差异，显示确认保存弹窗
+                curstate.cursor_pos = CURSOR_CONFIRM_SAVE;
+                ui_manager_cursor_set_value(curstate);
+                ui_manager_comp_create_confirm_save();
+            }
+            else
+            {
+                // 无差异，直接返回菜单页
+                ui_manager_switch_to_main_menu(MAIN_MENU_DEV_FIX); //回去菜单页
+            }
+        }
+        else if (curstate.cursor_pos == CURSOR_RIGHT_DATA)
+        {
+            curstate.cursor_pos = CURSOR_LEFT_MENU; //光标回左边
+            curstate.right_data_idx = 0;            //下标值清空
+            ui_manager_cursor_set_value(curstate);
+            fs_service_get_show_ui_data(ui_manager_get_page_ctx() , curstate.left_menu_idx , curstate.right_data_idx, &config);
+            ui_manager_select_list_data(curstate , &config);
+        }
+        break;
+        break;
+    case KEY_DATA_ENTER: //确定
+        if (curstate.cursor_pos == CURSOR_LEFT_MENU)
+        {
+            //按确定进去数据区
+            curstate.cursor_pos = CURSOR_RIGHT_DATA;
+            ui_manager_cursor_set_value(curstate);
+            fs_service_get_show_ui_data(ui_manager_get_page_ctx() , curstate.left_menu_idx , curstate.right_data_idx, &config);
+            ui_manager_select_list_data(curstate , &config);
+        }
+        else if(curstate.cursor_pos = CURSOR_RIGHT_DATA)
+        {
+            printf("%s touch enter!!\n", __FUNCTION__);
+
+            // 检查菜单是否启用
+            if (!fs_service_is_menu_enabled(ui_manager_get_page_ctx(), curstate.left_menu_idx))
+            {
+                fs_service_get_show_ui_data(ui_manager_get_page_ctx() , curstate.left_menu_idx , curstate.right_data_idx, &config);
+                ui_manager_select_list_data(curstate , &config);
+                break;
+            }
+
+            // 检查是否为"不停电传动投入"软压板，设置为只读
+            if (fs_service_is_trasw_yb_selected(ui_manager_get_page_ctx()))
+            {
+                printf("%s: SET_TRASW_YB is read-only, cannot modify\n", __FUNCTION__);
+                fs_service_get_show_ui_data(ui_manager_get_page_ctx() , curstate.left_menu_idx , curstate.right_data_idx, &config);
+                ui_manager_select_list_data(curstate , &config);
+                break;
+            }
+
+            UiSetValueOptDef set_opt = {0};
+            fs_service_get_sel_setval_data(ui_manager_get_page_ctx() , &set_opt); 
+            curstate.cursor_pos = CURSOR_CHANGE_VAL;
+            ui_manager_cursor_set_value(curstate);
+            ui_manager_comp_create_set_valist(&set_opt);
+        }
+        break;
+    case KEY_DATA_UP:   //上
+    case KEY_DATA_DOWN: //下
+    case KEY_DATA_LEFT: //左
+    case KEY_DATA_RIGHT://右
+
+        if (curstate.cursor_pos == CURSOR_LEFT_MENU)
+        {   
+            curstate.left_menu_idx = app_fs_cal_left_sel_idx(curstate, ui_manager_get_cur_pwdtype() , kval);
+        }
+        else if(curstate.cursor_pos = CURSOR_RIGHT_DATA)
+        {
+            curstate.right_data_idx = app_fs_cal_right_sel_idx(curstate, ui_manager_get_cur_pwdtype() , kval);
+        }
+
+        ui_manager_cursor_set_value(curstate);
+        fs_service_get_show_ui_data(ui_manager_get_page_ctx() , curstate.left_menu_idx , curstate.right_data_idx, &config);
+        ui_manager_select_list_data(curstate , &config);
+        break;    
+    default:
+        break;
+    }
+}
+
+void app_fix_set_create_list_data(PageCtx *ctx , u8 menu_sel_idx , u8 item_sel_idex)
+{
+    GeneralListPageConfig_t config = {0};
+
+    fs_service_get_show_ui_data(ctx , menu_sel_idx , item_sel_idex, &config);
+
+    ui_manager_gerneral_list(ctx, &config);
+}

dtu/dtu_main_t536/app/ui/app/app_fix_set.h

@@ -0,0 +1,10 @@
+#ifndef _APP_FIX_SET_H
+#define _APP_FIX_SET_H
+#include "../data/key_manager.h"
+#include "ui_config.h"
+
+void app_fix_set_handle_event(keyValue kval);
+
+void app_fix_set_create_list_data(PageCtx *ctx , u8 menu_sel_idx , u8 item_sel_idex);
+
+#endif  //_APP_FIX_SET_H

dtu/dtu_main_t536/app/ui/app/app_fix_show.c

@@ -0,0 +1,174 @@
+#include "app_fix_show.h"
+#include "service_fix_set.h"
+#include "ui_manager.h"
+
+
+/**
+ * @brief 计算左侧菜单
+ * @param  curstate         参数
+ * @param  kval             参数
+ * @return u8 
+ * @date 2026-01-20
+ */
+u8 app_fshow_cal_left_sel_idx(UICursorState curstate , keyValue kval)
+{
+    u8 menu_size=0;
+    u8 cur_idx = curstate.left_menu_idx; // 获取当前下标
+
+    menu_size = fs_service_get_menu_len_by_page(PAGE_DEV_FIX_SHOW);
+    printf("%s menu size = %d \n", __FUNCTION__,menu_size);
+    switch (kval)
+    {
+    case KEY_DATA_LEFT:
+        if (cur_idx > 7)
+            cur_idx = 8 * (cur_idx / 8) - 8;
+        else
+            cur_idx = 8 * ((menu_size - 1) / 8);
+        break;
+    case KEY_DATA_UP:
+        if (cur_idx > 0)
+            cur_idx--;
+        else
+            cur_idx = menu_size - 1;
+        break;
+    case KEY_DATA_RIGHT:
+        if (cur_idx < (menu_size - menu_size % 8))
+            cur_idx = 8 * (cur_idx / 8) + 8;
+        else
+            cur_idx = 0;
+    case KEY_DATA_DOWN:
+        cur_idx ++;
+        if (cur_idx > menu_size -1)
+            cur_idx = 0;
+        
+    default:
+        break;
+    }
+    return  cur_idx;
+}
+/**
+ * @brief 计算光标所处位置
+ * @param  curstate         光标数据
+ * @param  kval             键盘值
+ * @return u8 
+ * @date 2026-01-12
+ */
+u8 app_fshow_cal_right_sel_idx(UICursorState curstate , keyValue kval)
+{
+    u8 menu_len=0;
+    u8 cur_idx = curstate.right_data_idx; // 获取当前下标
+
+    menu_len = fs_service_get_items_len_by_page(PAGE_DEV_FIX_SHOW , curstate.left_menu_idx);
+
+    if (kval == KEY_DATA_DOWN)
+    {
+        if (cur_idx < menu_len - 1)
+            cur_idx++;
+
+        else
+            cur_idx = 0;
+    }
+    else if (kval == KEY_DATA_UP)
+    {
+        if (cur_idx > 0)
+            cur_idx--;
+        else
+            cur_idx = menu_len - 1;
+    }
+    else if (kval == KEY_DATA_RIGHT)
+    {
+        if (cur_idx < (menu_len - menu_len % 8))
+            cur_idx = 8 * (cur_idx / 8) + 8;
+        else
+            cur_idx = 0;
+    }
+    else if (kval == KEY_DATA_LEFT)
+    {
+        if (cur_idx > 7)
+            cur_idx = 8 * (cur_idx / 8) - 8;
+        else
+            cur_idx = 8 * ((menu_len - 1) / 8);
+    }
+
+    return cur_idx;
+}
+
+void app_fix_show_handle_event(keyValue kval)
+{
+    UICursorState curstate = ui_manager_get_cursor();
+    PageCtx dev_info_ctx = {0};
+    GeneralListPageConfig_t config = {0};
+
+    if (curstate.cursor_pos > CURSOR_RIGHT_DATA)
+    {
+        app_ds_process_compenents_handle_event(kval);
+        return;
+    }
+
+    switch (kval)
+    {
+    case KEY_DATA_BACK: //返回
+        if (curstate.cursor_pos == CURSOR_LEFT_MENU)
+        {
+            ui_manager_switch_to_main_menu(MAIN_MENU_DEV_FIX_SHOW); //回去菜单页
+        }
+        else if (curstate.cursor_pos == CURSOR_RIGHT_DATA)
+        {
+            curstate.cursor_pos = CURSOR_LEFT_MENU; //光标回左边
+            curstate.right_data_idx = 0;            //下标值清空
+            ui_manager_cursor_set_value(curstate);
+            fs_service_get_show_ui_data(ui_manager_get_page_ctx() , curstate.left_menu_idx , curstate.right_data_idx, &config);
+            ui_manager_select_list_data(curstate , &config);
+        }
+        break;
+        break;
+    case KEY_DATA_ENTER: //确定
+        if (curstate.cursor_pos == CURSOR_LEFT_MENU)
+        {
+            //按确定进去数据区
+            curstate.cursor_pos = CURSOR_RIGHT_DATA;
+            ui_manager_cursor_set_value(curstate);
+            fs_service_get_show_ui_data(ui_manager_get_page_ctx() , curstate.left_menu_idx , curstate.right_data_idx, &config);
+            ui_manager_select_list_data(curstate , &config);
+        }
+        else if(curstate.cursor_pos = CURSOR_RIGHT_DATA)
+        {
+            if (!fs_service_is_menu_enabled(ui_manager_get_page_ctx(), curstate.left_menu_idx))
+            {
+                fs_service_get_show_ui_data(ui_manager_get_page_ctx() , curstate.left_menu_idx , curstate.right_data_idx, &config);
+                ui_manager_select_list_data(curstate , &config);
+                break;
+            }
+        }
+        break;
+    case KEY_DATA_UP:   //上
+    case KEY_DATA_DOWN: //下
+    case KEY_DATA_LEFT: //左
+    case KEY_DATA_RIGHT://右
+        if (curstate.cursor_pos == CURSOR_LEFT_MENU)
+        {
+            curstate.left_menu_idx = app_fshow_cal_left_sel_idx(curstate , kval);
+        }
+        else if(curstate.cursor_pos = CURSOR_RIGHT_DATA)
+        {
+            curstate.right_data_idx = app_fshow_cal_right_sel_idx(curstate , kval);
+        }
+
+        ui_manager_cursor_set_value(curstate);
+        fs_service_get_show_ui_data(ui_manager_get_page_ctx() , curstate.left_menu_idx , curstate.right_data_idx, &config);
+        ui_manager_select_list_data(curstate , &config);
+        break;    
+    default:
+        break;
+    }
+}
+
+void app_fix_show_create_list_data(PageCtx *ctx , u8 menu_sel_idx , u8 item_sel_idex)
+{
+    printf("%s \n", __FUNCTION__);
+    GeneralListPageConfig_t config = {0};
+
+    fs_service_get_show_ui_data(ctx , menu_sel_idx , item_sel_idex, &config);
+
+    ui_manager_gerneral_list(ctx, &config);
+}

dtu/dtu_main_t536/app/ui/app/app_fix_show.h

@@ -0,0 +1,10 @@
+#ifndef _APP_FIX_SHOW_H
+#define _APP_FIX_SHOW_H
+#include "../data/key_manager.h"
+#include "ui_config.h"
+
+void app_fix_show_handle_event(keyValue kval);
+
+void app_fix_show_create_list_data(PageCtx *ctx , u8 menu_sel_idx , u8 item_sel_idex);
+
+#endif  //_APP_FIX_SHOW_H

dtu/dtu_main_t536/app/ui/app/app_history_report.c

@@ -0,0 +1,255 @@
+#include "app_history_report.h"
+#include "ui/ui_manager.h"
+#include "service/service_history_report.h"
+#include "data/data_history_report.h"
+#include <stdio.h>
+
+/* ============================ 私有变量 ============================= */
+
+static HistoryReportPageConfig s_page_config = {0};
+static uint8_t s_current_menu_idx = 0;
+static uint32_t s_current_page_idx = 0;   // 当前页码索引（从0开始）
+static bool s_cursor_in_right = false;
+
+/* ============================ 私有函数声明 ============================= */
+
+static void refresh_page(void);
+static void switch_menu(uint8_t new_idx);
+static void switch_page(uint32_t new_page);
+static void move_to_next_page(void);
+static void move_to_prev_page(void);
+
+// 判断是否为多记录类型
+static bool is_multi_record_type(uint8_t menu_idx);
+
+/* ============================ 接口函数实现 ============================= */
+
+/**
+ * @brief 创建历史报告页面数据
+ */
+void app_history_report_create_list_data(PageCtx *ctx, uint8_t menu_sel_idx, uint32_t record_idx)
+{
+    if (ctx == NULL) {
+        return;
+    }
+
+    // 初始化service层
+    history_report_service_init();
+
+    // 初始化状态
+    s_current_menu_idx = menu_sel_idx;
+    s_current_page_idx = 0;  // 页码从0开始
+    s_cursor_in_right = false;
+
+    // 获取页面数据
+    history_report_service_get_page_data((HistoryReportType)s_current_menu_idx,
+                                          s_current_page_idx,
+                                          &s_page_config);
+    s_page_config.cursor_in_right = s_cursor_in_right;
+    ui_manager_history_report_create(ctx, &s_page_config);
+}
+
+/**
+ * @brief 处理历史报告页面按键事件
+ */
+void app_history_report_handle_event(keyValue kval)
+{
+    switch (kval) {
+        case KEY_DATA_UP:
+            if (s_cursor_in_right) {
+                // 光标在右侧，上一页
+                move_to_prev_page();
+            } else {
+                // 光标在左侧，切换到上一菜单项
+                if (s_current_menu_idx > 0) {
+                    switch_menu(s_current_menu_idx - 1);
+                } else {
+                    switch_menu(HISTORY_REPORT_MENU_NUM - 1);
+                }
+            }
+            break;
+
+        case KEY_DATA_DOWN:
+            if (s_cursor_in_right) {
+                // 光标在右侧，下一页
+                move_to_next_page();
+            } else {
+                // 光标在左侧，切换到下一菜单项
+                if (s_current_menu_idx < HISTORY_REPORT_MENU_NUM - 1) {
+                    switch_menu(s_current_menu_idx + 1);
+                } else {
+                    switch_menu(0);
+                }
+            }
+            break;
+
+        case KEY_DATA_LEFT:
+            if (s_cursor_in_right) {
+                // 光标在右侧，上一页
+                move_to_prev_page();
+            } else {
+                // 左侧菜单循环切换
+                if (s_current_menu_idx > 0) {
+                    switch_menu(s_current_menu_idx - 1);
+                } else {
+                    switch_menu(HISTORY_REPORT_MENU_NUM - 1);
+                }
+            }
+            break;
+
+        case KEY_DATA_RIGHT:
+            if (!s_cursor_in_right) {
+                // 从左侧进入右侧内容区
+                s_cursor_in_right = true;
+                s_page_config.cursor_in_right = true;
+                refresh_page();
+            } else {
+                // 光标在右侧，下一页
+                move_to_next_page();
+            }
+            break;
+
+        case KEY_DATA_ENTER:
+            if (!s_cursor_in_right) {
+                // 从左侧进入右侧内容区
+                s_cursor_in_right = true;
+                s_page_config.cursor_in_right = true;
+                refresh_page();
+            }
+            // 光标在右侧时，ENTER键暂无特殊操作
+            break;
+
+        case KEY_DATA_BACK:
+            if (s_cursor_in_right) {
+                // 从右侧返回左侧菜单
+                s_cursor_in_right = false;
+                s_page_config.cursor_in_right = false;
+                refresh_page();
+            } else {
+                // 返回主菜单
+                ui_manager_switch_to_main_menu(MAIN_MENU_HISTORY_DATA);
+            }
+            break;
+
+        default:
+            break;
+    }
+}
+
+/* ============================ 私有函数实现 ============================= */
+
+/**
+ * @brief 判断是否为多记录类型（每页显示两条记录）
+ */
+static bool is_multi_record_type(uint8_t menu_idx)
+{
+    return (menu_idx == HISTORY_REPORT_SOE ||
+            menu_idx == HISTORY_REPORT_REMOTE ||
+            menu_idx == HISTORY_REPORT_SETTING);
+}
+
+/**
+ * @brief 刷新页面
+ */
+static void refresh_page(void)
+{
+    // 重新获取页面数据
+    history_report_service_get_page_data((HistoryReportType)s_current_menu_idx,
+                                          s_current_page_idx,
+                                          &s_page_config);
+
+    // 设置光标位置
+    s_page_config.cursor_in_right = s_cursor_in_right;
+
+    // 获取当前光标状态
+    UICursorState curstate = ui_manager_get_cursor();
+
+    // 通过ui_manager刷新历史报告页面
+    ui_manager_history_report_refresh(curstate, &s_page_config);
+}
+
+/**
+ * @brief 切换菜单
+ */
+static void switch_menu(uint8_t new_idx)
+{
+    if (new_idx >= HISTORY_REPORT_MENU_NUM) {
+        return;
+    }
+
+    s_current_menu_idx = new_idx;
+    s_current_page_idx = 0;  // 切换菜单时重置页码
+
+    // 构建页面上下文
+    PageCtx ctx = {0};
+    ctx.cur_page = PAGE_HISTORY_DATA;
+    ctx.cursor_state.cursor_pos = s_cursor_in_right ? CURSOR_RIGHT_DATA : CURSOR_LEFT_MENU;
+    ctx.cursor_state.left_menu_idx = s_current_menu_idx;
+    ctx.cursor_state.right_data_idx = 0;
+
+    // 获取页面数据并创建页面
+    history_report_service_get_page_data((HistoryReportType)s_current_menu_idx,
+                                          s_current_page_idx,
+                                          &s_page_config);
+    s_page_config.cursor_in_right = s_cursor_in_right;
+    ui_manager_history_report_create(&ctx, &s_page_config);
+}
+
+/**
+ * @brief 切换页面
+ */
+static void switch_page(uint32_t new_page)
+{
+    uint32_t total_pages = history_report_service_get_total_pages((HistoryReportType)s_current_menu_idx);
+
+    if (total_pages == 0) {
+        return;
+    }
+
+    if (new_page >= total_pages) {
+        new_page = 0;  // 循环到第一页
+    }
+
+    s_current_page_idx = new_page;
+    refresh_page();
+}
+
+/**
+ * @brief 移动到下一页
+ */
+static void move_to_next_page(void)
+{
+    uint32_t total_pages = history_report_service_get_total_pages((HistoryReportType)s_current_menu_idx);
+
+    if (total_pages == 0) {
+        return;
+    }
+
+    uint32_t new_page = s_current_page_idx + 1;
+    if (new_page >= total_pages) {
+        new_page = 0;  // 循环到第一页
+    }
+
+    switch_page(new_page);
+}
+
+/**
+ * @brief 移动到上一页
+ */
+static void move_to_prev_page(void)
+{
+    uint32_t total_pages = history_report_service_get_total_pages((HistoryReportType)s_current_menu_idx);
+
+    if (total_pages == 0) {
+        return;
+    }
+
+    uint32_t new_page;
+    if (s_current_page_idx == 0) {
+        new_page = total_pages - 1;  // 循环到最后一页
+    } else {
+        new_page = s_current_page_idx - 1;
+    }
+
+    switch_page(new_page);
+}

dtu/dtu_main_t536/app/ui/app/app_history_report.h

@@ -0,0 +1,21 @@
+#ifndef _APP_HISTORY_REPORT_H_
+#define _APP_HISTORY_REPORT_H_
+
+#include "data/key_manager.h"
+#include "ui/ui_config.h"
+
+/**
+ * @brief 处理历史报告页面按键事件
+ * @param kval 按键值
+ */
+void app_history_report_handle_event(keyValue kval);
+
+/**
+ * @brief 创建历史报告页面数据
+ * @param ctx 页面上下文
+ * @param menu_sel_idx 菜单选择索引
+ * @param record_idx 记录索引
+ */
+void app_history_report_create_list_data(PageCtx *ctx, uint8_t menu_sel_idx, uint32_t record_idx);
+
+#endif /* _APP_HISTORY_REPORT_H_ */

dtu/dtu_main_t536/app/ui/app/app_home_page.c

@@ -0,0 +1,334 @@
+#include "app_home_page.h"
+#include "../ui/ui_manager.h"
+#include "../ui/ui/ui_pages/ui_home_page.h"
+#include "../service/service_home_page.h"
+#include "../data/data_home_page.h"
+#include "core/lvgl/lvgl.h"
+#include <math.h>
+
+/* ====================================================================================================================
+ * 文件名称: app_home_page.c
+ * 文件职责: 首页App层实现 - 事件处理，协调Service和UI，管理页面生命周期
+ * 架构位置: APP层 (Controller)
+ * ==================================================================================================================== */
+
+/* 定时刷新配置宏 */
+#define HP_REFRESH_PERIOD_MS   500U        /* 遥测数据刷新周期（毫秒） */
+#define HP_TIME_REFRESH_PERIOD_MS   1000U        /* 时间刷新周期（毫秒） */
+#define HP_VALUE_TOLERANCE      0.01f      /* 浮点数比较容差 */
+
+/* 静态变量定义 */
+static lv_task_t *s_hp_refresh_task = NULL;  /* LVGL定时器句柄 */
+static lv_task_t *s_time_refresh_task = NULL;  /* 时间刷新定时器句柄 */
+static HomePageRawData s_last_raw_data = {0};  /* 上一次遥测数据缓存 */
+
+/**
+ * @brief  将组类型转换为索引
+ * @param  group  组类型
+ * @return 索引值 0-4
+ */
+static uint8_t hp_group_to_index(HomePageGroupType group)
+{
+    switch (group)
+    {
+    case HP_GROUP_MCB:
+        return 0;
+    case HP_GROUP_LCB:
+        return 1;
+    case HP_GROUP_LOAD_I:
+        return 2;
+    case HP_GROUP_ZERO_I:
+        return 3;
+    case HP_GROUP_DEV_INFO:
+        return 4;
+    default:
+        return 0;
+    }
+}
+
+/* ============================================================================
+ * 自动刷新功能实现
+ *
+ * 一、核心用途
+ *    实现首页数据的自动刷新，无需用户操作即可更新显示内容。
+ *
+ * 二、双定时器架构
+ *    - 数据定时器(500ms): 非设备信息组使用，刷新电压/电流等遥测数据
+ *    - 时间定时器(1000ms): 设备信息组专用，仅刷新系统时间显示
+ *    两定时器互斥工作，组切换时自动切换。
+ *
+ * 三、触发条件
+ *    1. 当前页面必须是PAGE_HOME_PAGE（页面退出后定时器自动失效）
+ *    2. 数据定时器额外检查：数据变化量 > 0.01（容差过滤）
+ *
+ * 四、关键变量
+ *    s_hp_refresh_task    - 数据定时器句柄
+ *    s_time_refresh_task  - 时间定时器句柄
+ *    s_last_raw_data      - 上次遥测数据缓存（用于变化检测）
+ *
+ * 五、调用关系
+ *    app_home_page_create()     → hp_start_auto_refresh() 或 hp_start_time_refresh()
+ *    app_home_page_handle_event() → LEFT/RIGHT切换定时器，ENTER停止全部
+ *    app_home_page_destroy()    → hp_stop_auto_refresh() + hp_stop_time_refresh()
+ *
+ * 六、异常处理
+ *    - 重复创建防护：启动前检查句柄是否为NULL
+ *    - 页外回调防护：回调函数首行检查ui_manager_get_curpage()
+ *    - 内存泄漏防护：stop时删除任务并置NULL，destroy时调用全部stop
+ *
+ * ============================================================================ */
+
+/* 前置声明 */
+static bool hp_data_changed(const HomePageRawData *current);
+static void hp_update_cache(const HomePageRawData *current);
+static void hp_time_refresh_timer_cb(lv_task_t *task);
+static void hp_start_time_refresh(void);
+static void hp_stop_time_refresh(void);
+
+/**
+ * @brief LVGL定时器回调函数
+ * @param task LVGL任务句柄（未使用但保留接口）
+ * @note 在LVGL任务上下文中执行，可直接操作UI
+ */
+static void hp_refresh_timer_cb(lv_task_t *task)
+{
+    // printf("%s called!\n", __FUNCTION__);
+    (void)task;
+
+    if (ui_manager_get_curpage() != PAGE_HOME_PAGE) {
+        return;
+    }
+
+    HomePageRawData raw_data;
+    if (!data_home_page_get_raw(&raw_data)) {
+        return;
+    }
+
+    if (!hp_data_changed(&raw_data)) {
+        return;
+    }
+
+    hp_update_cache(&raw_data);
+
+    HomePageViewConfig config;
+    HomePageGroupType current_group = home_page_service_get_current_group();
+
+    if (home_page_service_get_config(current_group, &config)) {
+        home_page_ui_refresh(&config);
+    }
+}
+
+/**
+ * @brief 启动自动刷新定时器
+ * @note 页面创建时调用，避免重复创建
+ */
+static void hp_start_auto_refresh(void)
+{
+    if (s_hp_refresh_task != NULL) {
+        return;
+    }
+
+    printf("%s create task!\n", __FUNCTION__);
+    s_hp_refresh_task = lv_task_create(hp_refresh_timer_cb,
+                                       HP_REFRESH_PERIOD_MS,
+                                       LV_TASK_PRIO_LOW,
+                                       NULL);
+}
+
+/**
+ * @brief 停止自动刷新定时器
+ * @note 页面退出时调用，防止内存泄漏
+ */
+static void hp_stop_auto_refresh(void)
+{
+    printf("%s stop auto refresh task!\n", __FUNCTION__);
+    if (s_hp_refresh_task != NULL) {
+        lv_task_del(s_hp_refresh_task);
+        s_hp_refresh_task = NULL;
+    }
+}
+
+/**
+ * @brief 时间刷新LVGL定时器回调
+ * @param task LVGL任务句柄
+ * @note 仅在设备信息组时更新时间显示
+ */
+static void hp_time_refresh_timer_cb(lv_task_t *task)
+{
+    (void)task;
+
+    if (ui_manager_get_curpage() != PAGE_HOME_PAGE) {
+        return;
+    }
+
+    HomePageGroupType current_group = home_page_service_get_current_group();
+    if (current_group != HP_GROUP_DEV_INFO) {
+        return;
+    }
+
+    HomePageViewConfig config;
+    if (home_page_service_get_config(current_group, &config)) {
+        home_page_ui_refresh(&config);
+    }
+}
+
+/**
+ * @brief 启动时间刷新定时器
+ * @note 仅在设备信息组时使用
+ */
+static void hp_start_time_refresh(void)
+{
+    if (s_time_refresh_task != NULL) {
+        return;
+    }
+
+    printf("%s create task!\n", __FUNCTION__);
+    s_time_refresh_task = lv_task_create(hp_time_refresh_timer_cb,
+                                         HP_TIME_REFRESH_PERIOD_MS,
+                                         LV_TASK_PRIO_LOW,
+                                         NULL);
+}
+
+/**
+ * @brief 停止时间刷新定时器
+ */
+static void hp_stop_time_refresh(void)
+{
+    printf("%s stop time refresh task!\n", __FUNCTION__);
+    if (s_time_refresh_task != NULL) {
+        lv_task_del(s_time_refresh_task);
+        s_time_refresh_task = NULL;
+    }
+}
+
+/**
+ * @brief 检查数据是否有变化
+ * @param current 当前数据
+ * @return true-有变化, false-无变化
+ * @note 使用容差比较浮点数，避免微小抖动导致频繁刷新
+ */
+static bool hp_data_changed(const HomePageRawData *current)
+{
+    for (uint8_t i = 0; i < HP_TELEMET_NUM; i++) {
+        float diff = fabs(current->telemet[i].value - s_last_raw_data.telemet[i].value);
+        if (diff > HP_VALUE_TOLERANCE) {
+            return true;
+        }
+    }
+    return false;
+}
+
+/**
+ * @brief 更新缓存数据
+ * @param current 当前数据
+ */
+static void hp_update_cache(const HomePageRawData *current)
+{
+    s_last_raw_data = *current;
+}
+
+void app_home_page_create(void)
+{
+    /* 初始化Service层 */
+    home_page_service_init();
+    
+    /* 初始化缓存数据 */
+    data_home_page_get_raw(&s_last_raw_data);
+    
+    /* 获取当前组配置 */
+    HomePageViewConfig config;
+    HomePageGroupType current_group = home_page_service_get_current_group();
+    
+    if (home_page_service_get_config(current_group, &config))
+    {
+        /* 创建UI */
+        home_page_ui_create(&config);
+    }
+
+    /* 根据当前组启动对应的定时器 */
+    if (current_group == HP_GROUP_DEV_INFO) {
+        hp_start_time_refresh();
+    } else {
+        hp_start_auto_refresh();
+    }
+}
+
+void app_home_page_handle_event(keyValue kval)
+{
+    HomePageGroupType new_group;
+    HomePageViewConfig config;
+    
+    switch (kval)
+    {
+    case KEY_DATA_RIGHT:
+        /* 切换到下一组 */
+        new_group = home_page_service_next_group();
+        
+        /* 重置缓存，确保新组数据能立即显示 */
+        data_home_page_get_raw(&s_last_raw_data);
+        
+        /* 获取新配置并刷新UI */
+        if (home_page_service_get_config(new_group, &config))
+        {
+            home_page_ui_refresh(&config);
+        }
+        
+        /* 切换定时器 */
+        if (new_group == HP_GROUP_DEV_INFO) {
+            hp_stop_auto_refresh();
+            hp_start_time_refresh();
+        } else {
+            hp_stop_time_refresh();
+            hp_start_auto_refresh();
+        }
+        break;
+        
+    case KEY_DATA_LEFT:
+        /* 切换到上一组 */
+        new_group = home_page_service_prev_group();
+        
+        /* 重置缓存，确保新组数据能立即显示 */
+        data_home_page_get_raw(&s_last_raw_data);
+        
+        /* 获取新配置并刷新UI */
+        if (home_page_service_get_config(new_group, &config))
+        {
+            home_page_ui_refresh(&config);
+        }
+        
+        /* 切换定时器 */
+        if (new_group == HP_GROUP_DEV_INFO) {
+            hp_stop_auto_refresh();
+            hp_start_time_refresh();
+        } else {
+            hp_stop_time_refresh();
+            hp_start_auto_refresh();
+        }
+        break;
+        
+    case KEY_DATA_ENTER:
+        /* 切换到主菜单前先停止所有定时器 */
+        hp_stop_auto_refresh();
+        hp_stop_time_refresh();
+        /* 切换到主菜单 */
+        ui_manager_switch_to_main_menu(0);
+        break;
+        
+    default:
+        break;
+    }
+}
+
+void app_home_page_destroy(void)
+{
+    /* 停止所有定时器 */
+    hp_stop_auto_refresh();
+    hp_stop_time_refresh();
+    /* 销毁UI */
+    home_page_ui_destroy();
+}
+
+uint8_t app_home_page_get_current_group_index(void)
+{
+    return hp_group_to_index(home_page_service_get_current_group());
+}

dtu/dtu_main_t536/app/ui/app/app_home_page.h

@@ -0,0 +1,44 @@
+#ifndef _APP_HOME_PAGE_H
+#define _APP_HOME_PAGE_H
+
+#include "../data/key_manager.h"
+#include <stdint.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ====================================================================================================================
+ * 文件名称: app_home_page.h
+ * 文件职责: 首页App层头文件 - 事件处理，协调Service和UI，管理页面生命周期
+ * 架构位置: APP层 (Controller)
+ * ==================================================================================================================== */
+
+/**
+ * @brief  页面创建（供ui_manager调用）
+ */
+void app_home_page_create(void);
+
+/**
+ * @brief  事件处理（供按键处理调用）
+ * @param  kval  按键值
+ */
+void app_home_page_handle_event(keyValue kval);
+
+/**
+ * @brief  页面销毁（供ui_manager调用）
+ */
+void app_home_page_destroy(void);
+
+/**
+ * @brief  获取当前显示组索引
+ * @return 当前组索引 0-4
+ */
+uint8_t app_home_page_get_current_group_index(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _APP_HOME_PAGE_H */

dtu/dtu_main_t536/app/ui/app/app_main_menu.c

@@ -0,0 +1,473 @@
+#include "app_main_menu.h"
+#include "../ui/ui_manager.h"
+#include "app_config.h"
+#include "app_input_pwd.h"
+#include "data_config.h"
+#include "app_real_time_data.h"
+#include "app_dev_set_show.h"
+#include "app_fix_set.h"
+#include "app_fix_show.h"
+#include "app_debugset.h"
+#include "app_history_report.h"
+#include "app_version_info.h"
+#include <stdio.h>
+
+/* ============================================================================
+ * 菜单映射表优化设计说明
+ * ----------------------------------------------------------------------------
+ * 优化目标：使用映射表（结构体数组）替代原有的 switch-case 结构，提升代码
+ *          可维护性和扩展性，同时保持密码验证等安全逻辑的正确性。
+ *
+ * 设计要点：
+ * 1. 集中配置：所有菜单项的配置集中在 s_menu_mapping 数组中
+ * 2. 直接映射：通过菜单索引直接访问配置，时间复杂度 O(1)
+ * 3. 密码验证：需要密码的菜单项通过 pwd_callback 回调处理验证后逻辑
+ * 4. 类型安全：使用函数指针类型定义，编译期检查参数匹配
+ * 5. 常量存储：映射表使用 const 修饰，存储在 ROM 中节省 RAM
+ * ============================================================================ */
+
+/* 菜单页面创建函数类型定义 - 统一所有页面创建函数的签名 */
+typedef void (*MenuPageCreateFunc)(PageCtx *ctx, uint8_t arg1, uint8_t arg2);
+
+/* 密码验证回调函数类型定义 - 处理密码输入后的页面跳转和权限设置 */
+typedef void (*PwdVerifiedCallback)(PageCtx *ctx, int pwd_val);
+
+/* 菜单映射表项结构体 - 定义单个菜单项的完整配置 */
+typedef struct {
+    PageType            page_type;        /* 页面类型枚举，用于页面上下文 */
+    CursorPosition      cursor_pos;       /* 默认光标位置 */
+    uint8_t             left_menu_idx;    /* 左侧菜单默认选中索引 */
+    uint8_t             right_data_idx;   /* 右侧数据默认选中索引 */
+    MenuPageCreateFunc  create_func;      /* 页面创建函数指针，NULL 表示无需跳转 */
+    bool                need_password;    /* 是否需要密码验证 */
+    PwdVerifiedCallback pwd_callback;     /* 密码验证通过后的回调函数 */
+} MenuMappingItem;
+
+/* 静态函数前向声明 */
+static void process_component_event(keyValue kval);
+static void switch_to_subpage(uint8_t idx);
+static void handle_direction_key(keyValue kval);
+static void update_selection(uint8_t new_idx);
+static void convert_service_to_ui_config(UIMainMenuConfig *ui_config, const MainMenuPageConfig *service_config);
+
+/* 密码验证回调函数声明 - 用于需要密码的菜单项 */
+static void on_dev_set_pwd_verified(PageCtx *ctx, int pwd_val);
+static void on_dev_fix_pwd_verified(PageCtx *ctx, int pwd_val);
+
+/* 全局状态变量 */
+static uint8_t s_sel_idx = 0;
+static UIMainMenuConfig s_ui_config = {0};
+
+/* ============================================================================
+ * 菜单映射表定义
+ * ----------------------------------------------------------------------------
+ * 说明：
+ * 1. 使用指定初始化器语法 [索引] = { ... }，提高可读性和可维护性
+ * 2. MAIN_MENU_DEV_SET 和 MAIN_MENU_DEV_FIX 需要密码验证
+ * 3. 其他菜单项直接跳转，无需密码
+ * 4. 若某菜单项暂时无实际页面，可将 create_func 设为 NULL
+ * ============================================================================ */
+static const MenuMappingItem s_menu_mapping[MAIN_MENU_NUM] = {
+    /* [装置参数] - 需要密码验证 */
+    [MAIN_MENU_DEV_SET] = {
+        .page_type      = PAGE_DEV_SET,
+        .cursor_pos     = CURSOR_LEFT_MENU,
+        .left_menu_idx  = 0,
+        .right_data_idx = 0,
+        .create_func    = NULL,  /* 密码验证后通过回调创建页面 */
+        .need_password  = true,
+        .pwd_callback   = on_dev_set_pwd_verified
+    },
+
+    /* [定值设置] - 需要密码验证 */
+    [MAIN_MENU_DEV_FIX] = {
+        .page_type      = PAGE_DEV_FIX,
+        .cursor_pos     = CURSOR_LEFT_MENU,
+        .left_menu_idx  = 0,
+        .right_data_idx = 0,
+        .create_func    = NULL,  /* 密码验证后通过回调创建页面 */
+        .need_password  = true,
+        .pwd_callback   = on_dev_fix_pwd_verified
+    },
+
+    /* [装置参数查看] - 无需密码 */
+    [MAIN_MENU_DEV_SET_SHOW] = {
+        .page_type      = PAGE_DEV_SET_SHOW,
+        .cursor_pos     = CURSOR_LEFT_MENU,
+        .left_menu_idx  = 0,
+        .right_data_idx = 0,
+        .create_func    = (MenuPageCreateFunc)app_dev_set_show_create_list_data,
+        .need_password  = false,
+        .pwd_callback   = NULL
+    },
+
+    /* [定值查看] - 无需密码 */
+    [MAIN_MENU_DEV_FIX_SHOW] = {
+        .page_type      = PAGE_DEV_FIX_SHOW,
+        .cursor_pos     = CURSOR_LEFT_MENU,
+        .left_menu_idx  = 0,
+        .right_data_idx = 0,
+        .create_func    = (MenuPageCreateFunc)app_fix_show_create_list_data,
+        .need_password  = false,
+        .pwd_callback   = NULL
+    },
+
+    /* [实时数据] - 无需密码 */
+    [MAIN_MENU_REAL_TIME_DATA] = {
+        .page_type      = PAGE_REAL_TIME_DATA,
+        .cursor_pos     = CURSOR_LEFT_MENU,
+        .left_menu_idx  = 0,
+        .right_data_idx = 0,
+        .create_func    = (MenuPageCreateFunc)app_rtd_create_list_data,
+        .need_password  = false,
+        .pwd_callback   = NULL
+    },
+
+    /* [历史数据] - 无需密码 */
+    [MAIN_MENU_HISTORY_DATA] = {
+        .page_type      = PAGE_HISTORY_DATA,
+        .cursor_pos     = CURSOR_LEFT_MENU,
+        .left_menu_idx  = 0,
+        .right_data_idx = 0,
+        .create_func    = (MenuPageCreateFunc)app_history_report_create_list_data,
+        .need_password  = false,
+        .pwd_callback   = NULL
+    },
+
+    /* [调试测试] - 无需密码 */
+    [MAIN_MENU_DEBUG_TEST] = {
+        .page_type      = PAGE_DEBUG_TEST,
+        .cursor_pos     = CURSOR_LEFT_MENU,
+        .left_menu_idx  = 0,
+        .right_data_idx = 0,
+        .create_func    = (MenuPageCreateFunc)app_debugset_create_list_data,
+        .need_password  = false,
+        .pwd_callback   = NULL
+    },
+
+    /* [版本信息] - 无需密码 */
+    [MAIN_MENU_DEV_INFO] = {
+        .page_type      = PAGE_DEV_INFO,
+        .cursor_pos     = CURSOR_LEFT_MENU,
+        .left_menu_idx  = 0,
+        .right_data_idx = 0,
+        .create_func    = (MenuPageCreateFunc)app_version_info_create_page,
+        .need_password  = false,
+        .pwd_callback   = NULL
+    }
+};
+
+void app_main_menu_create_page(PageCtx *ctx, uint8_t selected_idx)
+{
+    if (ctx == NULL) {
+        return;
+    }
+
+    main_menu_service_init();
+
+    s_sel_idx = selected_idx;
+
+    MainMenuPageConfig service_config = {0};
+    main_menu_service_get_page_config(&service_config, s_sel_idx);
+    convert_service_to_ui_config(&s_ui_config, &service_config);
+
+    ui_main_menu_record_type((UIMainMenuType)s_sel_idx);
+
+    UICursorState cursor_state = {0};
+    cursor_state.cursor_pos = CURSOR_LEFT_MENU;
+    cursor_state.left_menu_idx = s_sel_idx;
+    ui_manager_cursor_set_value(cursor_state);
+
+    ui_manager_main_menu_create(ctx, &s_ui_config);
+}
+
+void app_main_menu_handle_event(keyValue kval)
+{
+    UICursorState cursor_state = ui_manager_get_cursor();
+    if (cursor_state.cursor_pos > CURSOR_RIGHT_DATA) {
+        process_component_event(kval);
+        return;
+    }
+
+    switch (kval) {
+        case KEY_DATA_UP:
+        case KEY_DATA_DOWN:
+        case KEY_DATA_LEFT:
+        case KEY_DATA_RIGHT:
+            handle_direction_key(kval);     // 处理方向键
+            break;
+
+        case KEY_DATA_ENTER:
+            switch_to_subpage(s_sel_idx);   // 进入子页面
+            break;
+
+        case KEY_DATA_BACK:
+            ui_manager_switch_page(NULL);   // 返回首页
+            break;
+
+        default:
+            break;
+    }
+}
+
+static void convert_service_to_ui_config(UIMainMenuConfig *ui_config, const MainMenuPageConfig *service_config)
+{
+    if (ui_config == NULL || service_config == NULL) {
+        return;
+    }
+
+    uint8_t i;
+    for (i = 0; i < MAIN_MENU_NUM && i < UI_MAIN_MENU_NUM; i++) {
+        ui_config->items[i].name = service_config->items[i].name;
+        ui_config->items[i].need_password = service_config->items[i].need_password;
+        ui_config->items[i].type = (UIMainMenuType)service_config->items[i].type;
+    }
+    ui_config->selected_idx = service_config->selected_idx;
+}
+
+static void handle_direction_key(keyValue kval)
+{
+    uint8_t new_idx = s_sel_idx;
+
+    switch (kval) {
+        case KEY_DATA_UP:
+            if (s_sel_idx < 4) {
+                new_idx = s_sel_idx + 4;
+            } else {
+                new_idx = s_sel_idx - 4;
+            }
+            break;
+
+        case KEY_DATA_DOWN:
+            if (s_sel_idx < 4) {
+                new_idx = s_sel_idx + 4;
+            } else {
+                new_idx = s_sel_idx - 4;
+            }
+            break;
+
+        case KEY_DATA_LEFT:
+            if (s_sel_idx == 0) {
+                new_idx = 7;
+            } else if (s_sel_idx == 4) {
+                new_idx = 3;
+            } else {
+                new_idx = s_sel_idx - 1;
+            }
+            break;
+
+        case KEY_DATA_RIGHT:
+            if (s_sel_idx == 3) {
+                new_idx = 4;
+            } else if (s_sel_idx == 7) {
+                new_idx = 0;
+            } else {
+                new_idx = s_sel_idx + 1;
+            }
+            break;
+
+        default:
+            return;
+    }
+
+    update_selection(new_idx);
+}
+
+static void update_selection(uint8_t new_idx)
+{
+    if (new_idx >= MAIN_MENU_NUM) {
+        return;
+    }
+
+    s_sel_idx = new_idx;
+    s_ui_config.selected_idx = new_idx;
+
+    UICursorState cursor_state = ui_manager_get_cursor();
+    cursor_state.left_menu_idx = s_sel_idx;
+    ui_manager_cursor_set_value(cursor_state);
+
+    ui_manager_select_index(s_sel_idx);
+}
+
+/* ============================================================================
+ * 密码验证回调函数实现
+ * ----------------------------------------------------------------------------
+ * 说明：以下回调函数在密码验证通过后被调用，负责：
+ * 1. 根据密码值设置权限类型（超级密码/普通密码）
+ * 2. 创建对应的设置页面
+ * 3. 保持与原代码完全一致的权限判断逻辑
+ * ============================================================================ */
+
+/**
+ * @brief 装置参数菜单密码验证回调
+ * @param ctx   页面上下文指针，已预填充基础信息
+ * @param pwd_val 用户输入的密码值
+ *
+ * 说明：对应原代码中 menu_idx == MAIN_MENU_DEV_SET 的处理逻辑
+ *       超级密码(SUPER_PWD)赋予超级用户权限，其他正确密码赋予普通权限
+ */
+static void on_dev_set_pwd_verified(PageCtx *ctx, int pwd_val)
+{
+    if (ctx == NULL) {
+        return;
+    }
+
+    /* 根据密码值设置权限类型 - 与原代码逻辑保持一致 */
+    if (pwd_val == SUPER_PWD) {
+        ctx->pwd_type = UI_PWD_TYPE_SUPER;
+    } else if (pwd_val == Password_opt[2].value) {
+        ctx->pwd_type = UI_PWD_TYPE_NORMAL;
+    } else {
+        /* 密码错误时默认无权限，实际场景应在调用前验证密码正确性 */
+        ctx->pwd_type = UI_PWD_TYPE_NONE;
+    }
+
+    /* 创建设置页面 */
+    app_dev_set_show_create_list_data(ctx, 0, 0);
+}
+
+/**
+ * @brief 定值设置菜单密码验证回调
+ * @param ctx   页面上下文指针，已预填充基础信息
+ * @param pwd_val 用户输入的密码值
+ *
+ * 说明：对应原代码中 menu_idx == MAIN_MENU_DEV_FIX 的处理逻辑
+ */
+static void on_dev_fix_pwd_verified(PageCtx *ctx, int pwd_val)
+{
+    if (ctx == NULL) {
+        return;
+    }
+
+    /* 根据密码值设置权限类型 - 与原代码逻辑保持一致 */
+    if (pwd_val == SUPER_PWD) {
+        ctx->pwd_type = UI_PWD_TYPE_SUPER;
+    } else if (pwd_val == Password_opt[2].value) {
+        ctx->pwd_type = UI_PWD_TYPE_NORMAL;
+    } else {
+        ctx->pwd_type = UI_PWD_TYPE_NONE;
+    }
+
+    /* 创建定值设置页面 */
+    app_fix_set_create_list_data(ctx, 0, 0);
+}
+
+/* ============================================================================
+ * 菜单跳转核心函数
+ * ----------------------------------------------------------------------------
+ * 说明：使用映射表替代原有的 switch-case 结构，实现 O(1) 的菜单跳转
+ * 处理流程：
+ * 1. 边界检查 - 确保索引有效性
+ * 2. 密码检查 - 需要密码时切换到密码输入界面
+ * 3. 页面创建 - 从映射表获取配置并创建页面
+ * ============================================================================ */
+
+/**
+ * @brief 切换到指定菜单子页面
+ * @param idx 菜单索引，对应 MenuType 枚举值
+ *
+ * 说明：
+ * - 若菜单项需要密码验证，则保存当前状态并切换到密码输入界面
+ * - 若无需密码，直接从映射表获取配置并创建目标页面
+ * - 所有页面上下文参数均从映射表获取，避免硬编码
+ */
+static void switch_to_subpage(uint8_t idx)
+{
+    /* 边界检查：确保索引在有效范围内 */
+    if (idx >= MAIN_MENU_NUM) {
+        return;
+    }
+
+    /* 获取映射表项 - 常量指针确保不会意外修改配置 */
+    const MenuMappingItem *item = &s_menu_mapping[idx];
+
+    /* 密码验证检查：需要密码时切换到密码输入界面 */
+    if (item->need_password) {
+        UICursorState state = ui_manager_get_cursor();
+        state.cursor_pos = CURSOR_INPUT_PWD;
+        state.left_menu_idx = idx;
+        ui_manager_cursor_set_value(state);
+        ui_manager_comp_create_input_pwd();
+        return;
+    }
+
+    /* 无需密码验证，直接创建目标页面 */
+    PageCtx ctx = {0};
+
+    /* 从映射表填充页面上下文 - 避免硬编码，提高可维护性 */
+    ctx.cur_page = item->page_type;
+    ctx.cursor_state.cursor_pos = item->cursor_pos;
+    ctx.cursor_state.left_menu_idx = item->left_menu_idx;
+    ctx.cursor_state.right_data_idx = item->right_data_idx;
+
+    /* 调用页面创建函数 */
+    if (item->create_func != NULL) {
+        item->create_func(&ctx, 0, 0);
+    }
+    /* 注意：若 create_func 为 NULL 且无需密码，表示该菜单项暂无可跳转页面 */
+}
+
+/* ============================================================================
+ * 组件事件处理函数
+ * ----------------------------------------------------------------------------
+ * 说明：处理密码输入等组件级事件
+ * 优化点：使用映射表替代硬编码的菜单索引判断，提高可扩展性
+ * ============================================================================ */
+
+/**
+ * @brief 处理组件级事件（如密码输入）
+ * @param kval 按键值
+ *
+ * 处理流程：
+ * 1. 检查当前光标状态是否为密码输入模式
+ * 2. 获取密码输入值和目标菜单索引
+ * 3. 根据按键类型执行相应操作：
+ *    - ENTER：验证密码并通过回调创建页面
+ *    - BACK/CANCEL：返回主菜单
+ *
+ * 安全说明：密码验证回调函数内部负责权限设置，本函数仅负责流程控制
+ */
+static void process_component_event(keyValue kval)
+{
+    UICursorState state = ui_manager_get_cursor();
+
+    /* 仅处理密码输入状态下的事件 */
+    if (state.cursor_pos != CURSOR_INPUT_PWD) {
+        return;
+    }
+
+    uint8_t menu_idx = state.left_menu_idx;
+
+    /* 边界检查：确保菜单索引有效 */
+    if (menu_idx >= MAIN_MENU_NUM) {
+        return;
+    }
+
+    /* 获取映射表项 */
+    const MenuMappingItem *item = &s_menu_mapping[menu_idx];
+
+    /* 确认该菜单项确实需要密码验证（防御性编程） */
+    if (!item->need_password) {
+        return;
+    }
+    int pwd_val = app_input_pwd_handle_event(kval);
+    
+    if (kval == KEY_DATA_ENTER) {
+        
+
+        /* 构建页面上下文 - 从映射表获取配置避免硬编码 */
+        PageCtx ctx = {0};
+        ctx.cur_page = item->page_type;
+        ctx.cursor_state.cursor_pos = item->cursor_pos;
+        ctx.cursor_state.left_menu_idx = item->left_menu_idx;
+        ctx.cursor_state.right_data_idx = item->right_data_idx;
+
+        /* 调用密码验证回调函数 - 由回调负责权限设置和页面创建 */
+        if (item->pwd_callback != NULL) {
+            item->pwd_callback(&ctx, pwd_val);
+        }
+    } else if (kval == KEY_DATA_BACK || kval == KEY_DATA_CANCEL) {
+        /* 取消密码输入，返回主菜单 */
+        ui_manager_switch_to_main_menu(menu_idx);
+    }
+}