7085 lines
440 KiB
C
7085 lines
440 KiB
C
/*
|
||
* 104子站示例:总召、计数量、校时、读、遥控、突发、扫描、系统命令、参数、可选210文件和211升级。
|
||
* 两种召唤共用IEC104_Interrogation.c状态机,各自有独立实例和业务事件。
|
||
* 每轮Slave_Poll -> NextEvent逐条交付 -> 参数/校时已执行确认 -> 遥控/读/系统命令/发布 -> 召唤/新校时/参数 -> 空闲扫描;所有调用串行。
|
||
* 总召每批4点;8个单点、8个双点和8个遥测的基础流程共8个ASDU,默认再追加32个参数ASDU。
|
||
* QOI=21读取单点及双点遥信,22只读遥测,其余分组由应用拒绝;分组点表策略不写进协议库。
|
||
* 同一连接至多一个未终结总召,忙时不区分QOI均否定;任务满时拒绝/计数丢弃新请求,保留当前连接。
|
||
* 总召模块处理WAIT、STOPDT及断线;应用读取业务事件,选择类型并显式交付ASDU。
|
||
* 主站COT=8由总召模块匹配并回复COT=9;示例只按原请求身份清理已开始的取数,不另发撤销确认。
|
||
* 计数量使用8个模拟计数器;读取快照,冻结/复位由经过事件校验的同步动作入口执行。
|
||
* 对时默认只更新模拟UTC基准;--clock system显式选择实际时钟,协议仍使用单调时钟。
|
||
* 单/双点、升降和设定值均先选择后执行;位串仅在显式扩展模式下直接执行;同一实例只占一个事务,结果/返回信息/Complete分步推进。
|
||
* 模拟输出同步更新点值;FINISHED只清理返校/输出标志,不恢复已执行的点值,也不代表真实设备已经空闲。
|
||
* 系统复位须在首次STOP/断开前肯定确认已按时获ACK;之后会话结束也保留重建请求。
|
||
* 宿主进程和硬件均不重启。
|
||
* 不支持的其他命令当场提交COT=44否定应答,复用发送层HIGH;容量不足只丢本条并计数。
|
||
* 默认变化上送配合30秒背景刷新,COT=1周期由CLI显式启用;扫描经IDLE交接,不占HIGH/NORMAL队列。
|
||
* 扫描周期是名义起点网格;发送忙时保留本轮游标,STOP或重连后按新会话网格开始,不补发旧快照。
|
||
* 默认启用32点三类型参数,--no-parameter可关闭;站总召追加32个单对象,全部扩展关闭。
|
||
* 默认100ms采样有界遥测工况,遥信保持稳定;--simulation stress保留交替变位压力输入。
|
||
* 参数驱动应用一阶平滑、量程OV和变化门限;总召/读/扫描共用处理值,--config可选保存INI参数。
|
||
* --remote-parameter演示五套不同设置;切区选择已保存配置,预置仅暂存,固化后由当前区取值展示。
|
||
* --file-service显式开启文件服务;TEMP写入仅COMMIT后可见,--config可保存远程定值与TEMP快照。
|
||
* --software-upgrade须同时启用文件服务;upgrade.bin使用独立64KB候选,ACK后模拟激活并更新版本。
|
||
* 文件数据BUSY时保留当前通知,在有界本地推进后重试;其间不读取后续通知,COMMIT仍等待通知读空。
|
||
* 默认127.0.0.1:2404、CA=1;构建命令和主站读点步骤见docs/examples/IEC104子站示例.md。
|
||
*/
|
||
/*
|
||
* 文件内导航(搜索方括号标记;Suite:示例程序):
|
||
* 公共声明之后依次集中九类业务实现,再放跨业务初始化、调度和生命周期,最后为CLI/main。
|
||
* 同一业务的专属初始化、取值/动作、事件消费及步进放在连续分区;ExampleApp保持共享汇总布局。
|
||
* Example_Init统一创建必需模块并处理失败回退,属于跨业务编排;可选模块各有独立初始化入口。
|
||
* 函数定义位置不决定调用次序,运行顺序以Example_Step和main为准。
|
||
* 阅读各业务时先看ExampleApp内对应STATE字段,再看本分区,最后核对公共Handle_Event/Step/Cancel。
|
||
* 各分区集中本业务处理及必要的跨业务衔接;连接通知和退出顺序由公共区统一编排,不能因某模块HANDLED就停止分派。
|
||
* 突发区的定时采样产生COT=3变化事件;PERIODIC_SCAN区才是--cyclic-ms/--background-ms启用的COT=1/2扫描。
|
||
* [COMMON/BASE] 公共基础:依赖与示例编译选项
|
||
* [COMMON/POINTS] 公共点表:总召、读命令、遥控和突发共用的地址与初值
|
||
* [COMMON/STATE] 公共上下文:业务句柄、专属状态及共享运行值
|
||
* [SPONTANEOUS/QUEUE] 突发上送:应用变化队列、遥控补报占位与周期采样
|
||
* [GI/DATA] 总召业务 Type100:分组取值、批次提交与数据游标
|
||
* [GI/STEP] 总召步进:协议推进、事件消费与状态刷新
|
||
* [CI/INIT] 计数量初始化:独立实例、广播状态区与模拟计数器
|
||
* [CI/DATA] 计数量业务 Type101:冻结复位、读取快照与批次提交
|
||
* [CI/STEP] 计数量步进:协议推进、事件消费与状态刷新
|
||
* [CLOCK/INIT] 校时初始化:配置复制与实例绑定
|
||
* [CLOCK/ACTION] 校时业务 Type103:时间基准、设时动作与确认推进
|
||
* [CLOCK/STEP] 校时步进:确认提交、动作执行与状态刷新
|
||
* [COMMAND/POINTS] 遥控配置:逐点类型、直接执行与选择执行策略
|
||
* [COMMAND/ACTION] 遥控与遥调:点号映射、动作结果及返回信息
|
||
* [READ/LOOKUP] 读命令 Type102:同步查点与有界执行
|
||
* [PARAMETER/INIT] 参数点表:32个独立地址,三种值类型,默认只启用标准功能
|
||
* [PARAMETER/CONFIG] 参数业务校验与可选文件恢复、合并保存和失败退避
|
||
* [PARAMETER/ACTION] 参数装载与单点周期启停:应用校验并更新测量处理配置
|
||
* [PERIODIC_SCAN/INIT] 扫描初始化:应用持有点表,模块复制组配置
|
||
* [PERIODIC_SCAN/LOOKUP] 空闲扫描共用应用当前值,不建立变化队列
|
||
* [SYSTEM_COMMAND/ACTION] Type104/107回显、Type70初始化结束、Type105复位许可与本站事件清除
|
||
* [REMOTE_PARAMETER] Type200–203五套设置、当前配置展示、整批暂存及清理
|
||
* [FILE_SERVICE] Type210目录快照、内存只读文件、TEMP事务和BUSY接入
|
||
* [SOFTWARE_UPGRADE] Type211控制、设备owner与候选、激活任务及版本发布
|
||
* [COMMON/INIT] 公共初始化:运行值、站点注册、必需模块创建及失败回退
|
||
* [COMMON/SCHEDULING] 公共调度:取消、等待时间与Slave通知分派
|
||
* [COMMON/LOOP] 公共主循环:协调所有业务并读空Slave通知
|
||
* [COMMON/LIFECYCLE] 跨业务生命周期:终结排空、协议重建与引用归还
|
||
* [COMMON/DESTROY] 初始化失败及正常退出共用的资源释放
|
||
* [CLI/HELPERS] 程序入口辅助:平台依赖、退出信号、参数解析与帮助
|
||
* [ENTRY/MAIN] 程序入口:配置、启动、事件循环、统计与有序退出
|
||
*/
|
||
/* ============================================================================
|
||
* [COMMON/BASE] 公共基础:依赖与示例编译选项
|
||
* ============================================================================ */
|
||
#include "IEC104_Interrogation.h"
|
||
#include "IEC104_CounterInterrogation.h"
|
||
#include "IEC104_ClockSynchronization.h"
|
||
#include "IEC104_Command.h"
|
||
#include "IEC104_Read.h"
|
||
#include "IEC104_SystemCommand.h"
|
||
#include "IEC104_Startup.h"
|
||
#include "IEC104_Spontaneous.h"
|
||
#include "IEC104_PeriodicScan.h"
|
||
#include "IEC104_Parameter.h"
|
||
#include "IEC104_RemoteParameter.h"
|
||
#include "IEC104_FileService.h"
|
||
#include "IEC104_SoftwareUpgrade.h"
|
||
#include "iec104_example_config.h"
|
||
#include "iec104_example_points.h"
|
||
#include "iec104_example_recording.h"
|
||
#include "iec104_example_history.h"
|
||
#include "iec104_example_energy_freeze.h"
|
||
#include "iec104_example_energy_meter.h"
|
||
#include "iec104_example_user_log.h"
|
||
#include "iec104_example_upgrade.h"
|
||
#include "IEC104_Net.h"
|
||
#include "IEC60870_Clock.h"
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <limits.h>
|
||
#include <float.h>
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
#include "iec104_dtu_profile.h"
|
||
#include "iec104_dtu_measurement.h"
|
||
#include "iec104_dtu_protection.h"
|
||
#include <math.h>
|
||
#endif
|
||
|
||
#ifndef EXAMPLE_EVENT_BUDGET
|
||
#define EXAMPLE_EVENT_BUDGET 32U
|
||
#endif
|
||
#ifndef EXAMPLE_USER_LOG_REPORT_FAULT
|
||
#define EXAMPLE_USER_LOG_REPORT_FAULT(result) fprintf(stderr, "ULOG persistence failed: %d\n", (int)(result))
|
||
#endif
|
||
#define EXAMPLE_READ_BUDGET 4U
|
||
#define EXAMPLE_COUNTER_COUNT 8U
|
||
#define EXAMPLE_SCALED_MIN (-10000)
|
||
#define EXAMPLE_SCALED_MAX 10000
|
||
/* Type5的VTI位置占有符号7位,另一位是暂态标志;本例按此范围拒绝越限升降。
|
||
* 两组各8个独立模拟点,点数同时约束命令地址映射与运行值数组。 */
|
||
#define EXAMPLE_STEP_MIN (-64)
|
||
#define EXAMPLE_STEP_MAX 63
|
||
#define EXAMPLE_STEP_COUNT 8U
|
||
#define EXAMPLE_BITSTRING_COUNT 8U
|
||
/* 主示例的演示工况默认值,不是协议库默认或现场整定值。
|
||
* 655是Type110线上有符号整数,比例为655/32768;乘固定幅值10000约为199.89,
|
||
* 因测量值是整数,归一化与标度门限都在变化量达到200时触发。
|
||
* SAMPLE控制输入采样,BACKGROUND控制COT2刷新,两者都不是COT3固定发送周期。 */
|
||
#define EXAMPLE_THRESHOLD_SCALED 200
|
||
#define EXAMPLE_THRESHOLD_NORMALIZED 655
|
||
#define EXAMPLE_SAMPLE_MS 100U
|
||
#define EXAMPLE_BACKGROUND_MS 30000U
|
||
#define EXAMPLE_CONFIG_SAVE_MS 500U
|
||
#define EXAMPLE_CONFIG_RETRY_MS 5000U
|
||
#define EXAMPLE_CLOCK_REFRESH_MS 60000U
|
||
#define EXAMPLE_PUBLICATION_CAPACITY 32U
|
||
#define EXAMPLE_GI_TOTAL_TIMEOUT_MS 120000U
|
||
#define EXAMPLE_CI_TOTAL_TIMEOUT_MS 120000U
|
||
#define EXAMPLE_FILE_BYTES 4096U
|
||
#define EXAMPLE_UPGRADE_BYTES 65536U
|
||
#define EXAMPLE_UPGRADE_DELAY_MS 20U
|
||
#define EXAMPLE_FILE_DIRECTORY_ITEMS 2U
|
||
#ifndef EXAMPLE_COMMAND_ACTION_RESULT
|
||
#define EXAMPLE_COMMAND_ACTION_RESULT(app) IEC104_COMMAND_ACTION_STARTED
|
||
#endif
|
||
#ifndef EXAMPLE_COMMAND_DEVICE_RESULT
|
||
#define EXAMPLE_COMMAND_DEVICE_RESULT(app) IEC104_COMMAND_RESULT_SUCCEEDED
|
||
#endif
|
||
#ifndef EXAMPLE_SYSTEM_COMMAND_REPORT_FAULT
|
||
/* 测试可把这条预期诊断换成计数;生产仍写stderr,业务是否继续由Step的返回值决定。 */
|
||
#define EXAMPLE_SYSTEM_COMMAND_REPORT_FAULT(app) \
|
||
((void)fputs("System command: application events cleared, transport clear failed; negative reply pending.\n", stderr))
|
||
#endif
|
||
|
||
/* ============================================================================
|
||
* [COMMON/POINTS] 公共点表:总召、读命令、遥控和突发共用的地址与初值
|
||
* ============================================================================ */
|
||
/* 模拟遥信点表:ioa为24位信息对象地址,value为0/1,quality为SIQ品质位(这里均为0)。
|
||
* 表项只保存数据源:总召编码为Type1,变位、读回复和遥控反馈编码为带CP56的Type30。
|
||
* 此表提供地址、初值和品质;运行值保存在各ExampleApp中,遥控与总召共用同一数据源。 */
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
#define example_signals dtu_signals
|
||
#define example_measurements dtu_measurements
|
||
#define EXAMPLE_DOUBLE_COUNT 16U
|
||
#define EXAMPLE_COMMAND_COUNT (DTU_COMMAND_COUNT + EXAMPLE_MEASUREMENT_COUNT + EXAMPLE_STEP_COUNT + EXAMPLE_BITSTRING_COUNT)
|
||
#define EXAMPLE_MEASUREMENT_TYPE IEC60870_ASDU_M_ME_NC_1
|
||
typedef IEC60870_MeasuredValueShort_t ExampleMeasurementObject;
|
||
#else
|
||
#define EXAMPLE_DOUBLE_COUNT EXAMPLE_SIGNAL_COUNT
|
||
#define EXAMPLE_COMMAND_COUNT (2U * EXAMPLE_SIGNAL_COUNT + EXAMPLE_MEASUREMENT_COUNT + EXAMPLE_STEP_COUNT + EXAMPLE_BITSTRING_COUNT)
|
||
#define EXAMPLE_MEASUREMENT_TYPE IEC60870_ASDU_M_ME_NB_1
|
||
typedef IEC60870_MeasuredValueScaled_t ExampleMeasurementObject;
|
||
static const struct { uint32_t ioa; uint8_t value, quality; } example_signals[] = {
|
||
{EXAMPLE_IOA_SINGLE_BASE, 0, 0}, {EXAMPLE_IOA_SINGLE_BASE + 1U, 1, 0},
|
||
{EXAMPLE_IOA_SINGLE_BASE + 2U, 0, 0}, {EXAMPLE_IOA_SINGLE_BASE + 3U, 1, 0},
|
||
{EXAMPLE_IOA_SINGLE_BASE + 4U, 1, 0}, {EXAMPLE_IOA_SINGLE_BASE + 5U, 0, 0},
|
||
{EXAMPLE_IOA_SINGLE_BASE + 6U, 1, 0}, {EXAMPLE_IOA_SINGLE_BASE + 7U, 0, 0}
|
||
};
|
||
/* 模拟遥测点表:ioa为信息对象地址,value为原始有符号16位标度值,quality为QDS品质位。
|
||
* 编码为不带时标的Type=11;本示例不定义物理单位和倍率,负数也按有符号值传输。 */
|
||
static const struct { uint32_t ioa; int16_t value; uint8_t quality; } example_measurements[] = {
|
||
{EXAMPLE_IOA_MEASUREMENT_BASE, 2300, 0}, {EXAMPLE_IOA_MEASUREMENT_BASE + 1U, 2310, 0},
|
||
{EXAMPLE_IOA_MEASUREMENT_BASE + 2U, 2290, 0}, {EXAMPLE_IOA_MEASUREMENT_BASE + 3U, 5000, 0},
|
||
{EXAMPLE_IOA_MEASUREMENT_BASE + 4U, -125, 0}, {EXAMPLE_IOA_MEASUREMENT_BASE + 5U, 0, 0},
|
||
{EXAMPLE_IOA_MEASUREMENT_BASE + 6U, 1234, 0}, {EXAMPLE_IOA_MEASUREMENT_BASE + 7U, 42, 0}
|
||
};
|
||
#endif
|
||
/* 点数直接取数组长度;分批游标使用size_t,不另维护可能与点表不一致的手写数量。 */
|
||
#define EXAMPLE_SIGNAL_COUNT (sizeof(example_signals) / sizeof(example_signals[0]))
|
||
#define EXAMPLE_MEASUREMENT_COUNT (sizeof(example_measurements) / sizeof(example_measurements[0]))
|
||
#define EXAMPLE_SCAN_POINT_COUNT EXAMPLE_MEASUREMENT_COUNT
|
||
#define EXAMPLE_PARAMETER_COUNT (4U * EXAMPLE_MEASUREMENT_COUNT)
|
||
|
||
/* 应用运行值的地址映射;命令许可和执行方式在Example_Init_Command中逐点明确配置。
|
||
* first_ioa是命令地址,ioa-first_ioa是该类运行值下标,不能把命令地址当作监视点地址。
|
||
* 基础与带时标类型共用同一物理点;此表仅用于查找运行值,不生成命令点策略。
|
||
* 扩展点表时须同步这里的类型/范围、对应运行值及动作/返回/读取分支。 */
|
||
static const struct { uint32_t first_ioa; size_t count; uint16_t type_mask; } example_command_groups[] = {
|
||
#ifndef IEC104_EXAMPLE_DTU_PROFILE
|
||
{EXAMPLE_IOA_COMMAND_SINGLE_BASE, EXAMPLE_SIGNAL_COUNT, IEC104_COMMAND_TYPE_BIT(45U) | IEC104_COMMAND_TYPE_BIT(58U)},
|
||
#endif
|
||
{EXAMPLE_IOA_COMMAND_DOUBLE_BASE, EXAMPLE_DOUBLE_COUNT, IEC104_COMMAND_TYPE_BIT(46U) | IEC104_COMMAND_TYPE_BIT(59U)},
|
||
{EXAMPLE_IOA_COMMAND_STEP_BASE, EXAMPLE_STEP_COUNT, IEC104_COMMAND_TYPE_BIT(47U) | IEC104_COMMAND_TYPE_BIT(60U)},
|
||
{EXAMPLE_IOA_COMMAND_SETPOINT_BASE, EXAMPLE_MEASUREMENT_COUNT, IEC104_COMMAND_TYPE_BIT(49U) | IEC104_COMMAND_TYPE_BIT(62U)},
|
||
{EXAMPLE_IOA_COMMAND_BITSTRING_BASE, EXAMPLE_BITSTRING_COUNT, IEC104_COMMAND_TYPE_BIT(51U) | IEC104_COMMAND_TYPE_BIT(64U)}
|
||
};
|
||
|
||
/* ============================================================================
|
||
* [COMMON/STATE] 公共上下文:业务句柄、专属状态及共享运行值
|
||
* ============================================================================ */
|
||
/* 当前取数站的应用游标;首个NEED_DATA才初始化,协议库不登记或冻结业务IOA列表。
|
||
* parameter_index独立于遥测游标,只有站总召且已启用参数时从0开始,其余置末尾跳过。 */
|
||
typedef struct { size_t single_index, double_index, scaled_index, parameter_index; } ExampleGiData;
|
||
|
||
/* 应用测量链:原始输入、滤波状态和已提交变化基准分开保存;协议模块不解释这些参数。 */
|
||
typedef struct {
|
||
double filtered;
|
||
uint64_t updated_ms;
|
||
int16_t raw, submitted_value;
|
||
uint8_t quality, submitted_quality;
|
||
int8_t range, submitted_range; /* -1低于下限,0在范围内,1高于上限。 */
|
||
} ExampleMeasurement;
|
||
|
||
/* 补报标记保留应用队列次序直到命令结束;CP56 SOE原文已进入独立发送缓存,标记不再持有补报义务。
|
||
* 其他类型仍用此快照生成补报;动作未改变点值时只保留配对标记,不创建虚构SOE。 */
|
||
typedef struct {
|
||
IEC104_SpontaneousChange_t change;
|
||
uint64_t instance_id, transaction_id;
|
||
bool placeholder, has_change, accepted; /* accepted仅表示返回信息已被发送层接手;FINISHED才决定补报。 */
|
||
bool time_tag_cleared; /* QRP=2清除后,占位解析也不得重新生成CP56形态。 */
|
||
int8_t measurement_range; /* 与快照同时固定,参数后来变化不能改写已排队的范围侧。 */
|
||
} ExamplePublication;
|
||
|
||
/* 远程参数的应用候选值;*_set 区分“本批未写”与合法零值。
|
||
* 点表在整次读取期间保持不变,与标准Parameter的测量参数表不共用地址或运行值。
|
||
* 固化在本事件循环同步发布;指定--config时须先成功保存完整配置快照。 */
|
||
typedef struct {
|
||
float deadband, x_time;
|
||
uint16_t reset_seconds;
|
||
bool deadband_set, x_time_set, reset_set;
|
||
} ExampleRemoteValues;
|
||
|
||
/* 当前选用配置的值快照;按区号现取,避免另存一份活动配置后切区/固化遗漏同步。
|
||
* 供示例配置展示使用,不连接保护算法或故障指示灯硬件;X时间演示单位为秒。 */
|
||
typedef struct {
|
||
uint16_t area, reset_seconds;
|
||
float deadband, x_time;
|
||
} ExampleRemoteSettings;
|
||
|
||
typedef struct {
|
||
bool active; /* 表示本应用确有暂存;协议COLLECTING/COMPLETE由模块独立管理。 */
|
||
IEC104_RemoteParameterRequest_t owner; /* 首帧身份纯值副本;元素借用字段保存时清空。 */
|
||
ExampleRemoteValues values; /* 每帧完整校验后才替换,固化成功后统一清空。 */
|
||
} ExampleRemoteStage;
|
||
|
||
/* 文件句柄只在本应用内解释;每次成功OPEN分配递增token,旧清理不能误碰新资源。
|
||
* owner按值保存来源,name等回调借用指针清零;TEMP区与协议模块的固定数据段环互相独立。 */
|
||
typedef struct {
|
||
bool active;
|
||
IEC104_FileServiceRequest_t owner;
|
||
} ExampleFileResource;
|
||
|
||
typedef struct {
|
||
uint8_t name[IEC104_FILE_SERVICE_MAX_DIRECTORY_NAME];
|
||
uint8_t name_length;
|
||
uint32_t size;
|
||
IEC60870_CP56Time2a_t time;
|
||
} ExampleFileDirectoryEntry;
|
||
|
||
typedef struct {
|
||
ExampleFileResource directory, read, stage; /* 三种资源独立计寿命,不能因协议队列为空就释放。 */
|
||
uintptr_t next_handle; /* 协议复位时保留,旧handle永远不能匹配下一次OPEN。 */
|
||
ExampleFileDirectoryEntry entries[EXAMPLE_FILE_DIRECTORY_ITEMS]; /* 本次目录打开时复制的稳定清单。 */
|
||
size_t entry_count;
|
||
bool directory_exists, read_temp, present; /* 目录存在性 / 已提交区读锁 / 已有提交文件,三者不互相替代。 */
|
||
const uint8_t *read_data; /* ROM或被读锁保护的file_bytes,不指向回调栈。 */
|
||
unsigned read_recording; /* 当前读会话的数据源:0=普通文件,1=录波CFG,2=录波DAT;CLOSE_READ清零。 */
|
||
bool directory_history, read_history; /* 历史文件快照由独立适配器持有,不借用演示目录的两项数组。 */
|
||
ExampleHistoryEntry history_entry; /* list回调返回后协议仍需编码名称,因此不能使用局部数组。 */
|
||
bool directory_energy, read_energy; /* FRZ/FLOWREV由独立适配器保存不可变下载副本。 */
|
||
ExampleEnergyFreezeEntry energy_entry;
|
||
bool directory_user_log, read_user_log; /* 日志目录与下载各自持有冻结副本,按原资源身份关闭。 */
|
||
ExampleUserLogEntry user_log_entry; /* list返回后名称仍有效,不借用回调栈。 */
|
||
uint32_t read_size, stage_size, stage_received, file_size;
|
||
uint8_t stage_name[IEC104_FILE_SERVICE_MAX_FILE_NAME];
|
||
uint8_t file_name[IEC104_FILE_SERVICE_MAX_FILE_NAME];
|
||
uint8_t stage_name_length, file_name_length;
|
||
IEC60870_CP56Time2a_t startup_time, file_time;
|
||
uint8_t stage_bytes[EXAMPLE_FILE_BYTES]; /* write只写此区;ABORT使其无效,不要求擦除旧字节。 */
|
||
uint8_t file_bytes[EXAMPLE_FILE_BYTES]; /* COMMIT发布区;读锁持有期间禁止替换。 */
|
||
} ExampleFileStore;
|
||
|
||
/* 应用映像记录只在进程启动初始化;普通105和协议重建不能将其恢复为初值。 */
|
||
typedef struct { uint32_t version, crc; } ExampleImage;
|
||
static ExampleImage example_image = {1U, 0xCBF43926U};
|
||
|
||
/* VERIFYING预留给有界验证接入;RAM模式累计CRC,持久模式由后端同步读回,COMMIT发布验证结局。 */
|
||
typedef enum {
|
||
EXAMPLE_UPGRADE_EMPTY = 0, EXAMPLE_UPGRADE_RECEIVING, EXAMPLE_UPGRADE_VERIFYING,
|
||
EXAMPLE_UPGRADE_VERIFIED, EXAMPLE_UPGRADE_INVALID, EXAMPLE_UPGRADE_FROZEN
|
||
} ExampleUpgradeState;
|
||
|
||
/* 一个示例设备由所有Slave共享;设备owner及候选归属独立于ExampleApp和协议实例。
|
||
* 取消仅使候选失效,FileService尚欠最终回调时保留handle和存储,避免迟到写误碰新文件。
|
||
* 示例CRC同步完成,无后台线程;生产验证必须另持引用和token后再异步回交结果。 */
|
||
typedef struct {
|
||
void *context; /* 取得owner的ExampleApp;文件和激活任务收尾前其身份必须保持稳定。 */
|
||
/* owned跨协议会话存在;invalidated先撤销资格,committed/verified仅描述当前transfer。
|
||
* reserved在END接受时固定任务;taken表示授权已领取,候选改由应用激活任务持有。 */
|
||
bool owned, invalidated, committed, verified, reserved, taken;
|
||
bool persistent_handoff; /* Take之后即锁定:授权落盘失败也可能已提交,退出只释放内存归属。 */
|
||
/* 前两项全进程单调递增,后两项在OPEN时捕获;不能只靠可重建的协议会话序号匹配。 */
|
||
uint64_t owner_token, transfer_token, file_owner_token, file_transfer_token;
|
||
IEC104_SoftwareUpgradeRequest_t owner; /* START身份值副本,后续END/撤销须匹配原站点及会话。 */
|
||
ExampleFileResource file; /* 升级写handle;取消后仍保留到COMMIT/ABORT最终回调。 */
|
||
ExampleUpgradeState state;
|
||
/* size/received包含包头,rolling_crc仅累计负载且尚未最终异或;后两项在COMMIT校验后发布。 */
|
||
uint32_t size, received, rolling_crc, target_version, payload_crc;
|
||
/* END预留的不可变描述,不在Take成功后才分配;taken_ms仅在实际领取时采样。 */
|
||
struct {
|
||
uint64_t owner_token, transfer_token, taken_ms;
|
||
uint32_t version, crc, size;
|
||
} activation;
|
||
unsigned long succeeded, failed; /* 应用激活结局,区别于211确认或ACK已经成功。 */
|
||
uint8_t bytes[EXAMPLE_UPGRADE_BYTES]; /* 仅RAM模拟使用;持久模式逐段写盘,不向此区复制。 */
|
||
} ExampleUpgradeDevice;
|
||
static ExampleUpgradeDevice example_upgrade_device;
|
||
|
||
typedef struct {
|
||
/* [STATE/COMMON] 共享服务和站点身份;所有业务借用 */
|
||
IEC104_Slave_t *slave; /* main拥有;本上下文仅借用。 */
|
||
IEC104_Station_t station; /* 应用拥有的固定地址站点节点,供各业务共用CA和context。 */
|
||
/* [STATE/GI] 总召实例与调度快照 */
|
||
IEC104_Interrogation_t *interrogation; /* 库内不透明总召任务对象。 */
|
||
IEC104_InterrogationStatus_t gi; /* 只读快照,用于调度等待及统计。 */
|
||
/* [STATE/CI] 计数量实例与调度快照 */
|
||
IEC104_Interrogation_t *counter; /* 独立计数量实例,与总召共用Slave,不共用任务和广播状态区。 */
|
||
IEC104_InterrogationStatus_t ci; /* 计数量调度及统计快照,每次推进后重新查询。 */
|
||
/* [STATE/CLOCK] 校时实例与调度快照 */
|
||
IEC104_ClockSynchronization_t *clock; /* Type103读/设时共用一个模块,复用Slave及站点表。 */
|
||
IEC104_ClockSynchronizationStatus_t cs; /* 读/设时待执行、回复及期限快照;两种回调分别累计次数。 */
|
||
/* [STATE/COMMAND_HANDLE] 遥控实例;事务状态见下方COMMAND字段 */
|
||
IEC104_Command_t *command; /* CLI启用;仅总召的旧测试可以不创建遥控实例。 */
|
||
/* [STATE/READ] 读命令实例与调度快照 */
|
||
IEC104_Read_t *read; /* 队首单点读取,共用总召/遥控运行值。 */
|
||
IEC104_ReadStatus_t rd;
|
||
/* [STATE/PERIODIC_SCAN] 可选空闲扫描;模块借用这24行点表至Destroy,不能用初始化函数的栈数组代替。
|
||
* 点表只描述地址、类型和归属,创建后不改;实际值仍从下方运行值数组现取。 */
|
||
IEC104_PeriodicScan_t *periodic_scan;
|
||
IEC104_PeriodicScanPoint_t scan_points[EXAMPLE_SCAN_POINT_COUNT];
|
||
uint32_t point_period_ms[EXAMPLE_SCAN_POINT_COUNT]; /* 参数启停所需的点级周期;Create后只经扫描setter写。 */
|
||
uint8_t point_retry_pending[(EXAMPLE_SCAN_POINT_COUNT + 7U) / 8U]; /* 借给扫描模块独占的重试位图,应用不读写。 */
|
||
uint32_t parameter_cyclic_ms; /* 恢复周期;借出的周期数组只经扫描setter修改。 */
|
||
/* [STATE/PARAMETER] 点表创建后只读;当前值仅由本事件循环写入,模块和总召只读。 */
|
||
IEC104_Parameter_t *parameter; /* main默认创建,只启用标准功能;可显式关闭,运行中不换点表。 */
|
||
IEC104_ParameterStatus_t parameter_status; /* 调度与统计快照;排队与当前可执行分别看pending/ready。 */
|
||
IEC104_ParameterPoint_t parameter_points[EXAMPLE_PARAMETER_COUNT]; /* 4类各EXAMPLE_MEASUREMENT_COUNT行,按独立IOA升序。 */
|
||
IEC104_ParameterValue_t parameter_values[EXAMPLE_PARAMETER_COUNT]; /* 与点表等长;确认/总召共读,写入串行。 */
|
||
/* [STATE/REMOTE_PARAMETER] 200–203独立运行值;--config启用时纳入统一配置文件。 */
|
||
IEC104_RemoteParameter_t *remote_parameter; /* 通用入口由--remote-parameter开启,DTU入口默认开启。 */
|
||
IEC104_RemoteParameterStatus_t remote_status; /* 调度及退出诊断快照,不是暂存或确认送达凭证。 */
|
||
uint16_t remote_area, remote_reset_seconds[5]; /* 当前选择与五套已固化值;202按SN读取,不隐式切区。 */
|
||
float remote_deadband, remote_x_time[5]; /* 电流死区不分区,X时间定值按SN分区。 */
|
||
ExampleRemoteStage remote_stage; /* 每实例唯一暂存;归属有效期间app地址与含义保持不变。 */
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
DtuSettings dtu_settings; /* 五区已固化值;当前动作区与SN0公共参数由定值适配选择。 */
|
||
DtuSettingsStage dtu_stage; /* 唯一预置影子,不作为读参数、采样判据或其他业务保存的来源。 */
|
||
DtuSettings *dtu_config_candidate; /* 仅同步保存期间借用提交候选,返回后立即清空;不转移所有权。 */
|
||
#endif
|
||
/* [STATE/FILE_SERVICE] 仅--file-service创建协议对象;静态应用区可经--config保存为文件快照。 */
|
||
IEC104_FileService_t *file_service;
|
||
IEC104_FileServiceStatus_t file_status;
|
||
ExampleFileStore files; /* TEMP已提交区在STOP/105复位后保留,暂存由COMMIT/ABORT释放。 */
|
||
ExampleRecording *recording; /* 可选的主机模拟录波;借用调用者的冻结存储,须存活至文件读会话全部结束。 */
|
||
ExampleHistory *history; /* 可选持久历史;协议重建不清空,进程退出且文件会话结束后关闭。 */
|
||
ExampleEnergyFreeze *energy; /* energy.store与计量状态在QRP1协议重建时保留。 */
|
||
ExampleEnergyMeter *energy_meter;
|
||
bool energy_failed;
|
||
bool history_failed; /* 已接收事件保存失败时停止示例,不能静默丢失后继续宣称保存成功。 */
|
||
uint64_t history_utc_ms, history_base_ms; /* 启动时独立读取有效墙钟;不把协议未同步状态变成已校时。 */
|
||
ExampleUserLog *user_log; /* 独立 ulog.store;协议重建保留,文件会话收尾后关闭。 */
|
||
uint64_t user_log_utc_ms, user_log_base_ms; /* 有效墙钟与单调基准;成功校时才替换。 */
|
||
bool user_log_failed, user_log_connected, user_log_fault; /* 写失败锁存;后两项按本Slave通信通道去重。 */
|
||
/* [STATE/SOFTWARE_UPGRADE] 协议实例按Slave独立,候选及设备owner使用上方共享存储。 */
|
||
IEC104_SoftwareUpgrade_t *software_upgrade;
|
||
IEC104_SoftwareUpgradeStatus_t upgrade_status; /* 只读调度快照,不能用session_active代替owner检查。 */
|
||
ExampleUpgrade *upgrade_store; /* 显式持久模式借用;整个进程持有目录锁,不借用RAM候选区。 */
|
||
bool upgrade_store_failed; /* 存储故障锁存后退出;已经授权的任务留给下次启动恢复。 */
|
||
bool quiescing, restart_quiesced; /* 领取后停普通业务;收尾完成后可有界等待激活延时。 */
|
||
/* [STATE/CONFIG] 唯一配置路径借用main的argv至退出;标准参数、远程定值和TEMP共用整份快照,NULL保持纯内存行为。
|
||
* dirty只针对32项参数,QPA3启停、测量值和发送状态不入文件;协议复位保留待保存配置。 */
|
||
const char *config_path;
|
||
bool config_dirty, config_failed;
|
||
uint64_t config_wait_started_ms; /* 首次修改或最近失败的时刻;后续修改不无限推迟保存。 */
|
||
uint32_t config_wait_ms; /* 正常合并500ms,失败退避5000ms;与协议确认期限互不替代。 */
|
||
/* [STATE/SYSTEM_COMMAND] 系统命令及协议实例复位;ACK后只置请求,主循环外统一收尾。 */
|
||
IEC104_SystemCommand_t *system_command; /* 104/105/107请求及70轮次的库内对象,不执行宿主复位。 */
|
||
IEC104_SystemCommandStatus_t system_command_status; /* 每次Step/等待前刷新,不能沿用查询失败的旧快照。 */
|
||
/* [STATE/STARTUP] 初始化 -> 全部CA真实总召 -> NORMAL/IDLE放行。
|
||
* identity区分Slave实例及TCP代次,activation还区分同TCP内STOP/START;两者须来自原ACTIVATED。
|
||
* enabled为接入配置,locked为集合借用,initialized/open是当前轮阶段;Reset只保留enabled。
|
||
* 逐站完成票据保存在Slave站点元数据,不复制事件缓存;NORMAL原文仍由发送层持有。 */
|
||
IEC104_Startup_t startup; /* 统一启动协调;复用原轮次状态,不另存遥信或站点数组。 */
|
||
bool restart_requested; /* Take_Reset或Take_Restart已交出授权;离开正常Step后才执行收尾。 */
|
||
unsigned long system_command_faults, protocol_restarts; /* 应用侧部分失败数/成功重建协议实例次数。 */
|
||
/* [STATE/SPONTANEOUS] 突发模块及应用发布队列 */
|
||
IEC104_Spontaneous_t *spontaneous;
|
||
ExamplePublication publications[EXAMPLE_PUBLICATION_CAPACITY];
|
||
size_t publication_count;
|
||
unsigned long publication_dropped, publication_invalid;
|
||
bool publication_waiting;
|
||
uint8_t publication_forms[IEC104_SPONTANEOUS_KIND_COUNT]; /* 与Create时按值复制的形态配置一致。 */
|
||
/* [STATE/COMMAND_PUBLICATION] 遥控与突发交界:动作产生的变化与补报状态 */
|
||
IEC104_SpontaneousChange_t command_change;
|
||
bool command_action_called, command_has_change;
|
||
/* 单个遥控SOE的发送层身份;应用数组中的旧占位仅负责阻挡较晚普通发布。
|
||
* serial为0表示动作没有实际变化;覆盖或QRP2清除后仍保留身份直到FINISHED,禁止重建旧事件。 */
|
||
IEC104_SoeTicket_t command_soe_ticket;
|
||
uint64_t command_soe_instance, command_soe_transaction;
|
||
bool command_soe_active;
|
||
/* [STATE/SAMPLING] 模拟源与发送策略独立;只由同一应用循环推进,无独立采样任务。 */
|
||
uint32_t events_interval_ms; /* 0停模拟;非零为两次采样之间的名义毫秒数。 */
|
||
uint64_t events_last_ms; /* 实际采样的单调时刻;延迟后不逐个补跑错过的节拍。 */
|
||
size_t events_index; /* field:0..119波形相位;stress:0..7点号,遥信/遥测各采一次才递增。 */
|
||
bool events_measurement, events_field; /* 前者仅供stress选择遥测拍;后者选择模拟模式,QRP1也保留。 */
|
||
/* [STATE/COMMAND] 遥控点表、工作事件、原站引用及返回信息 */
|
||
IEC104_CommandPoint_t command_points[EXAMPLE_COMMAND_COUNT]; /* Create前填完,直到Destroy均只读且地址稳定。 */
|
||
IEC104_CommandStatus_t command_status; /* 推进后/等待前刷新;计时、通知和应答状态只供调度及统计。 */
|
||
IEC104_CommandEvent_t command_event; /* 工作事件可跨WAIT保留,执行收尾继续使用原EXECUTE身份。 */
|
||
IEC104_Station_t *command_station; /* 应用额外引用:首个工作事件先Acquire,再保存context;FINISHED后Release。 */
|
||
uint64_t command_instance, command_transaction; /* 保留事务归属;SELECT/EXECUTE共用,FINISHED须先核对再清理。 */
|
||
/* pending仅表示工作事件尚待Accept/Reject;waiting表示上次接口WAIT,避免把待重试状态当作可立即推进。
|
||
* selected/output是模拟返校及输出的副作用标志,不代替协议阶段;真实设备忙状态应独立维护。 */
|
||
bool command_pending, command_waiting, command_selected, command_output;
|
||
unsigned command_step; /* 0等待事件/终结,1报告设备结果,2返回信息,3关闭返回阶段。 */
|
||
IEC60870_Asdu_t command_return; /* 借用下面的固定缓冲;WAIT未接手,必须连同事件保留到OK或STALE。 */
|
||
/* 本例默认地址长度下,最大Type30/31返回为6字节头+3字节IOA+1字节状态+7字节时标。
|
||
* Submit_Return_Info返回WAIT时仍借用此缓冲,不能复用总召/读命令的存储覆盖原帧。 */
|
||
uint8_t command_return_bytes[17]; /* 单帧持久存储,长度按上面的最大返回对象核算。 */
|
||
IEC60870_CP56Time2a_t command_action_time; /* 与command_change的动作值配对;返回WAIT期间不重新取时。 */
|
||
/* [STATE/POINT_VALUES] 总召、读命令、遥控与突发共享的当前点值 */
|
||
/* 总召、分组与读命令共用当前值,FINISHED不重置运行值。通用入口按8点命令组映射;
|
||
* DTU单点使用稀疏源映射,双点为16个开关反馈,遥控和自动过流工况均可更新相关遥信。 */
|
||
uint8_t signal_values[EXAMPLE_SIGNAL_COUNT], double_values[EXAMPLE_DOUBLE_COUNT];
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
/* 工况/延时用单调时间;pending按表下标占位,每点只保留待发的最新值/时刻。 */
|
||
uint64_t dtu_started_ms;
|
||
uint64_t dtu_signal_pending, dtu_signal_time[EXAMPLE_SIGNAL_COUNT];
|
||
uint64_t dtu_energy_last_ms;
|
||
double dtu_energy_wh[EXAMPLE_COUNTER_COUNT], dtu_energy_frozen_wh[EXAMPLE_COUNTER_COUNT];
|
||
DtuMeasurementInput dtu_input;
|
||
DtuMeasurementFrame dtu_frame;
|
||
DtuProtection dtu_protection;
|
||
DtuProtectionOutput dtu_protection_output;
|
||
uint8_t dtu_digital[DTU_PROTECTION_SIGNAL_COUNT]; /* 原始逻辑;取反只用于监视输出。 */
|
||
uint8_t dtu_digital_candidate[DTU_PROTECTION_SIGNAL_COUNT];
|
||
uint8_t dtu_digital_output[DTU_PROTECTION_SIGNAL_COUNT];
|
||
uint64_t dtu_digital_since[DTU_PROTECTION_SIGNAL_COUNT];
|
||
uint64_t dtu_pulse_until[EXAMPLE_DOUBLE_COUNT];
|
||
uint64_t dtu_command_due_ms, dtu_activation_since, dtu_activation_day;
|
||
bool dtu_activation, dtu_activation_scheduled;
|
||
const char *dtu_input_path, *dtu_recording_directory;
|
||
uint16_t dtu_recording_sequence;
|
||
uint32_t dtu_recording_pending;
|
||
bool dtu_sample_valid;
|
||
int16_t dtu_submitted[EXAMPLE_MEASUREMENT_COUNT];
|
||
double dtu_recording_before[8], dtu_recording_after[8];
|
||
IEC60870_CP56Time2a_t dtu_recording_time;
|
||
uint16_t dtu_recording_before_digital, dtu_recording_after_digital;
|
||
#endif
|
||
/* 两组值仅由命令执行修改,供Type102和命令返回读取;未加入总召/周期扫描点表。
|
||
* 每个ExampleApp独立持有,普通STOP/重连保留;应用初始化及模拟协议重建时清零。 */
|
||
int8_t step_values[EXAMPLE_STEP_COUNT]; /* 0x6021..0x6028控制1201..1208,每次升/降一档,初值0。 */
|
||
uint32_t bitstring_values[EXAMPLE_BITSTRING_COUNT]; /* 0x6041..0x6048控制1301..1308,完整替换32位值,初值0。 */
|
||
int16_t scaled_values[EXAMPLE_MEASUREMENT_COUNT]; /* 统一处理值;49/62和模拟采样先更新原始输入。 */
|
||
ExampleMeasurement measurements[EXAMPLE_MEASUREMENT_COUNT]; /* 参数处理启用时的状态,不增加发布队列容量。 */
|
||
/* [STATE/CLOCK_BASE] 校时及带时标业务共用的时间基准 */
|
||
bool clock_system, clock_valid, clock_update_pending; /* 仅成功校时置pending,回调外才更新Command基准。 */
|
||
uint64_t clock_utc_ms, clock_base_ms; /* UTC毫秒及同一时刻的Net单调基准,不影响协议计时。 */
|
||
uint64_t clock_refresh_ms; /* system模式最近一次读时尝试;失败也计时,避免每轮忙刷。 */
|
||
/* [STATE/CI_DATA] 计数量专属:冻结值、读取快照、游标与请求身份 */
|
||
IEC104_InterrogationEvent_t counter_event; /* WAIT时保留的原业务事件,重试不能换成新身份。 */
|
||
bool counter_pending, counter_first; /* 是否持有待应答事件、本轮是否先推进计数量。 */
|
||
uint8_t counter_type; /* 15/37保留整数模式;206读取当前值,207读取带冻结时间的副本。 */
|
||
float energy_snapshot[EXAMPLE_COUNTER_COUNT]; /* BEGIN固定的kWh/kVarh,不经过int32 BCR。 */
|
||
uint8_t energy_quality[EXAMPLE_COUNTER_COUNT];
|
||
uint64_t energy_snapshot_instance, energy_snapshot_request;
|
||
int32_t counter_current[EXAMPLE_COUNTER_COUNT]; /* 模拟整数Wh;浮点模式换算为kWh,不用float长期累加。 */
|
||
IEC60870_BinaryCounterReading_t counter_frozen[EXAMPLE_COUNTER_COUNT]; /* 最近冻结值及BCR序号、品质。 */
|
||
IEC60870_BinaryCounterReading_t counter_snapshot[EXAMPLE_COUNTER_COUNT]; /* 本轮稳定副本;206只取当前整数值。 */
|
||
IEC60870_CP56Time2a_t counter_frozen_time[EXAMPLE_COUNTER_COUNT]; /* 冻结时刻,与值一起发布;未校时则IV=1。 */
|
||
IEC60870_CP56Time2a_t counter_snapshot_time[EXAMPLE_COUNTER_COUNT]; /* 重试不改用发送时刻。 */
|
||
size_t counter_cursor, counter_end; /* 当前读取区间,只有Submit_Batch成功才推进游标。 */
|
||
uint64_t counter_instance, counter_request; /* 快照归属;旧FINISHED不得清理新请求。 */
|
||
IEC104_Station_t *counter_station; /* 读取期间额外持有的原站节点,结束后归还引用。 */
|
||
unsigned long counter_completed; /* 已消费的COMPLETED通知数,包含读取及冻结/复位。 */
|
||
/* [STATE/GI_DATA] 总召专属:取数游标、工作事件与请求身份 */
|
||
ExampleGiData gi_data; /* 应用拥有的游标,库内没有session或回调参数。 */
|
||
IEC104_Station_t *gi_station; /* 取数期间持有原站,Complete_Data或FINISHED时释放。 */
|
||
uint64_t session_instance, session_request; /* 只清理对应请求的遍历状态及业务资源。 */
|
||
IEC104_InterrogationEvent_t business_event; /* 纯值,可保存到后续循环应答。 */
|
||
bool business_pending;
|
||
/* [STATE/BATCH] 两种召唤串行共用的批次容器和字节缓冲 */
|
||
IEC60870_Asdu_t batch; /* 借用本应用bytes;Submit_Batch(OK)后可复用。 */
|
||
uint8_t batch_bytes[IEC104_MAX_ASDU_LEN];
|
||
/* [STATE/DISPATCH] 公共通知调度及不支持请求的兜底计数 */
|
||
bool events_pending;
|
||
unsigned long other_submitted, other_rejected, other_cancelled, other_overloads;
|
||
} ExampleApp;
|
||
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
static double dtu_setting(const ExampleApp *app, uint32_t ioa, double fallback);
|
||
/* 内部int16_t刻度按源地址选取,Type13还原工程值;与XML遥测倍率独立。 */
|
||
static float Example_Measurement_Scale(size_t index)
|
||
{
|
||
uint16_t source = dtu_measurements[index].source_addr;
|
||
if (source >= 0x961FU && source <= 0x9625U) { return 1000.0f; }
|
||
if (source == 0x962AU) { return 10000.0f; }
|
||
if (source == 0x9627U || source == 0x9628U) { return 10.0f; }
|
||
if (source == 0x962BU || source == 0x962CU) { return 1.0f; }
|
||
return 100.0f;
|
||
}
|
||
static float Example_Physical_Measurement(const ExampleApp *app, size_t index)
|
||
{
|
||
return (float)app->scaled_values[index] / Example_Measurement_Scale(index);
|
||
}
|
||
/* 0x002C..0x0031未配置,不能用ioa减基址索引;未找到返回容量哨兵,调用者须先判界。 */
|
||
static size_t Example_Dtu_Signal_Index(uint32_t ioa)
|
||
{
|
||
size_t index;
|
||
for (index = 0U; index < EXAMPLE_SIGNAL_COUNT; ++index) {
|
||
if (dtu_signals[index].ioa == ioa) { return index; }
|
||
}
|
||
return EXAMPLE_SIGNAL_COUNT;
|
||
}
|
||
/* 总召/Read立即可见新值;Flush前的再次变位覆盖待发时刻,相同值不补报。 */
|
||
static void Example_Dtu_Set_Signal(ExampleApp *app, uint32_t ioa, uint8_t value, uint64_t now)
|
||
{
|
||
size_t index = Example_Dtu_Signal_Index(ioa);
|
||
if (index < EXAMPLE_SIGNAL_COUNT && app->signal_values[index] != value) {
|
||
app->signal_values[index] = value;
|
||
app->dtu_signal_time[index] = now;
|
||
app->dtu_signal_pending |= UINT64_C(1) << index;
|
||
}
|
||
}
|
||
|
||
static void Example_Dtu_Reset_Process(ExampleApp *app)
|
||
{
|
||
size_t index;
|
||
Dtu_Measurement_Init(&app->dtu_input);
|
||
Dtu_Protection_Init(&app->dtu_protection);
|
||
memset(&app->dtu_protection_output, 0, sizeof(app->dtu_protection_output));
|
||
memset(app->dtu_digital, 0, sizeof(app->dtu_digital));
|
||
for (index = 0U; index < DTU_SIGNAL_COUNT; ++index) {
|
||
uint16_t source = dtu_signals[index].source_addr;
|
||
if (source >= 0x9141U && source <= 0x919DU) {
|
||
app->dtu_digital[source - 0x9140U] = dtu_signals[index].initial;
|
||
}
|
||
}
|
||
memcpy(app->dtu_digital_candidate, app->dtu_digital, sizeof(app->dtu_digital));
|
||
memcpy(app->dtu_digital_output, app->dtu_digital, sizeof(app->dtu_digital));
|
||
memset(app->dtu_digital_since, 0, sizeof(app->dtu_digital_since));
|
||
memset(app->dtu_pulse_until, 0, sizeof(app->dtu_pulse_until));
|
||
app->dtu_command_due_ms = 0U;
|
||
app->dtu_activation = app->dtu_activation_scheduled = false;
|
||
app->dtu_recording_pending = 0U;
|
||
app->dtu_sample_valid = false;
|
||
for (index = 0U; index < DTU_MEASUREMENT_COUNT; ++index) {
|
||
app->dtu_submitted[index] = Dtu_Measurement_To_Scaled(dtu_measurements[index].initial,
|
||
Example_Measurement_Scale(index), NULL);
|
||
}
|
||
}
|
||
#endif
|
||
static uint8_t Example_Initial_Signal(size_t index)
|
||
{
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
return dtu_signals[index].initial;
|
||
#else
|
||
return example_signals[index].value;
|
||
#endif
|
||
}
|
||
static int16_t Example_Initial_Measurement(size_t index)
|
||
{
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
float value = dtu_measurements[index].initial * Example_Measurement_Scale(index);
|
||
return (int16_t)(value + (value >= 0.0f ? 0.5f : -0.5f));
|
||
#else
|
||
return example_measurements[index].value;
|
||
#endif
|
||
}
|
||
static IEC60870_AsduResult_t Example_Create_Measurement(ExampleMeasurementObject *point,
|
||
uint32_t ioa, int16_t value, uint8_t quality)
|
||
{
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
return IEC60870_MeasuredValueShort_Create(point, ioa,
|
||
(float)value / Example_Measurement_Scale(ioa - EXAMPLE_IOA_MEASUREMENT_BASE), quality);
|
||
#else
|
||
return IEC60870_MeasuredValueScaled_Create(point, ioa, value, quality);
|
||
#endif
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [MEASUREMENT/PROCESS] 参数驱动的应用测量链;所有读取回调只读处理后的值和品质
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:取得指定遥测点当前应答或上送使用的质量位。
|
||
* 输入参数:app——示例应用上下文;index——本次条目、点或逻辑槽的下标。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:该遥测点当前使用的质量位。
|
||
* 说明:参数模块存在时读取运行品质,否则使用点表初值;index须为有效遥测下标。
|
||
*/
|
||
static uint8_t Example_Measurement_Quality(const ExampleApp *app, size_t index)
|
||
{
|
||
return app->parameter != NULL ? app->measurements[index].quality : 0U;
|
||
}
|
||
|
||
/**
|
||
* 功能:将本示例的单调采集时刻映射为历史记录使用的 UTC 毫秒。
|
||
* 输入参数:app 持有启动时建立的历史基准;monotonic_ms 与该基准使用同一单调时钟。
|
||
* 输出参数:成功写回 utc_ms;基准前时刻或加法溢出返回 false,不重新读取系统时间替代采集时间。
|
||
* 历史格式没有CP56的IV字段,示例只用有效墙钟,不输出伪造的2000年占位时间。
|
||
* 启动基准来自Clock_Read;成功协议校时后使用同一新基准,并留作协议复位后的历史时钟。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:无。
|
||
*/
|
||
static bool Example_History_Time(ExampleApp *app, uint64_t monotonic_ms, uint64_t *utc_ms)
|
||
{
|
||
uint64_t elapsed;
|
||
if (app->clock_valid) {
|
||
app->history_utc_ms = app->clock_utc_ms;
|
||
app->history_base_ms = app->clock_base_ms;
|
||
}
|
||
if (monotonic_ms < app->history_base_ms) { return false; }
|
||
elapsed = monotonic_ms - app->history_base_ms;
|
||
if (app->history_utc_ms > UINT64_MAX - elapsed) { return false; }
|
||
*utc_ms = app->history_utc_ms + elapsed;
|
||
return *utc_ms / 1000U <= IEC60870_TIME_MAX_SECONDS;
|
||
}
|
||
|
||
/**
|
||
* 功能:日志失败只能锁存停机,不能把已经完成的参数/升级操作改判拒绝或重做。
|
||
* 输入参数:app——示例应用上下文;result——待判定的处理结果。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:无。
|
||
* 说明:本函数不退出业务回调、不触碰协议资源;主循环在本次提交与收尾完成后检查失败标志。
|
||
*/
|
||
static void Example_User_Log_Result(ExampleApp *app, IEC60870_UserLogResult_t result)
|
||
{
|
||
if (result == IEC60870_USER_LOG_OK) { return; }
|
||
if (!app->user_log_failed) { EXAMPLE_USER_LOG_REPORT_FAULT(result); }
|
||
app->user_log_failed = true;
|
||
}
|
||
|
||
/**
|
||
* 功能:将已发生事实追加为一条持久用户日志。
|
||
* 输入参数:app——示例应用上下文;type——信息对象或日志类型标识;value——本次待处理的数值;occurred_ms——事实发生时的单调毫秒;text——文本或格式化缓冲。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:无。
|
||
* 说明:输入为真实事实发生的单调时刻;事件FIFO的延迟交付不得改用当前时间。
|
||
* 启动与成功校时提供有效基准;回拨允许保留,记录顺序由持久序号决定。
|
||
* 调用者须使用同一单调时钟;早于当前基准的输入直接锁存失败,不以现读墙钟代替发生时间。
|
||
* 文本仅在同步Append期间借用;未启用或已经失败时不再访问介质,也不重试可能已经提交的记录。
|
||
*/
|
||
static void Example_User_Log_Append(ExampleApp *app, uint8_t type, uint8_t value,
|
||
uint64_t occurred_ms, const char *text)
|
||
{
|
||
uint64_t elapsed;
|
||
if (app->user_log == NULL || app->user_log_failed) { return; }
|
||
if (occurred_ms < app->user_log_base_ms) {
|
||
Example_User_Log_Result(app, IEC60870_USER_LOG_INVALID); return;
|
||
}
|
||
elapsed = occurred_ms - app->user_log_base_ms;
|
||
if (app->user_log_utc_ms > UINT64_MAX - elapsed) {
|
||
Example_User_Log_Result(app, IEC60870_USER_LOG_INVALID); return;
|
||
}
|
||
Example_User_Log_Result(app, IEC60870_UserLog_Append(&app->user_log->core, type,
|
||
app->user_log_utc_ms + elapsed, value, text));
|
||
}
|
||
|
||
/**
|
||
* 功能:每个实际变化的参数一条,不记录预置、相同值、TEST或确认发送重试。
|
||
* 输入参数:app——示例应用上下文;scope——日志中的参数领域名称;object——日志对象编号;area——远程参数区号;before——修改前的数值;after——修改后的数值。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:无。
|
||
* 说明:调用者负责先完成真实修改,TEST/拒绝分支不能进入本函数;这里只再过滤同值。
|
||
* old/new采用有界ASCII表示,文本超限视为日志失败,不能静默截断对象身份。
|
||
*/
|
||
static void Example_User_Log_Parameter(ExampleApp *app, const char *scope, uint32_t object,
|
||
unsigned area, double before, double after)
|
||
{
|
||
char text[IEC60870_USER_LOG_TEXT_MAX + 1U];
|
||
int length;
|
||
if (app->user_log == NULL || before == after) { return; }
|
||
length = snprintf(text, sizeof(text), "PARAM %s object=%lu area=%u old=%.9g new=%.9g",
|
||
scope, (unsigned long)object, area, before, after);
|
||
if (length <= 0 || (size_t)length >= sizeof(text)) {
|
||
Example_User_Log_Result(app, IEC60870_USER_LOG_INVALID); return;
|
||
}
|
||
Example_User_Log_Append(app, 10U, 1U, IEC104_Net_Now_Ms(), text);
|
||
}
|
||
|
||
/**
|
||
* 功能:独立启用日志,先验证启动墙钟再恢复介质;不伪造硬件复位原因。
|
||
* 输入参数:app——示例应用上下文;log——日志持久适配实例;directory——持久存储目录。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:01记录本宿主示例进程启动,后续协议模拟重建另带SIMULATED标记。
|
||
* log由调用者持有并首次清零,须活到文件回调结束;directory只在打开期间借用。
|
||
* Open成功即把所有权登记到app,随后恢复状态或写启动记录失败也由Destroy统一关闭。
|
||
* 本入口不改变实时协议的校时有效性;只有完整恢复并保存启动事实才返回true。
|
||
*/
|
||
static bool Example_Init_User_Log(ExampleApp *app, ExampleUserLog *log, const char *directory)
|
||
{
|
||
IEC60870_ClockValue_t value;
|
||
IEC60870_CP56Time2a_t time;
|
||
uint32_t seconds;
|
||
uint64_t base_ms;
|
||
size_t index;
|
||
if (app->user_log != NULL || log == NULL || directory == NULL ||
|
||
!IEC60870_Clock_Read(&value) || value.is_invalid != 0U) { return false; }
|
||
base_ms = IEC104_Net_Now_Ms();
|
||
memset(&time, 0, sizeof(time)); time.time = value.time;
|
||
if (!IEC60870_Time_CP56_To_Seconds(&time, IEC60870_LOCAL_UTC_OFFSET_MINUTES, &seconds) ||
|
||
!Example_User_Log_Open(log, directory, "IEC104-EXAMPLE")) { return false; }
|
||
app->user_log = log;
|
||
app->user_log_utc_ms = (uint64_t)seconds * 1000U + value.time.ms;
|
||
app->user_log_base_ms = base_ms;
|
||
app->user_log_failed = app->user_log_connected = app->user_log_fault = false;
|
||
/* 本存储只属于一个服务通道;恢复最近异常状态,进程重启后CONNECTED仍可形成恢复沿。
|
||
* 只搜索仍保留的1024条,找不到03便保留默认无异常,不推断已覆盖的旧事实。
|
||
* 不恢复connected标志,也不补造断电期间未知的断开时刻。 */
|
||
for (index = IEC60870_UserLog_Count(&log->core); index != 0U; --index) {
|
||
IEC60870_UserLogRecord_t record;
|
||
IEC60870_UserLogResult_t result = IEC60870_UserLog_Get(&log->core, index - 1U, &record);
|
||
if (result != IEC60870_USER_LOG_OK) { Example_User_Log_Result(app, result); return false; }
|
||
if (record.type == 3U) { app->user_log_fault = record.value != 0U; break; }
|
||
}
|
||
Example_User_Log_Append(app, 1U, 1U, base_ms, "HOST_PROCESS_START");
|
||
return !app->user_log_failed;
|
||
}
|
||
|
||
/**
|
||
* 功能:根据连接事件记录TCP连通变化和通道故障恢复。
|
||
* 输入参数:app——示例应用上下文;event——本轮借用的协议事件。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:无。
|
||
* 说明:02只描述TCP连通;START/STOP不冒充建连/断线。03来源是本Slave服务通道,
|
||
* 首次故障快照记发生,随后CONNECTED记恢复;同代次的启停/断线快照不重复记故障。
|
||
* 无故障的普通断开仅记02。日志错误不短路后续生命周期分派和资源清理。
|
||
* 建连1/断开0是本应用的02极性约定;03恢复只代表服务通道重连,不代表所有通信硬件恢复。
|
||
* 状态位用于顺序事件去重,不能证明日志已持久化;失败后仍更新内存边沿并交由主循环停机。
|
||
*/
|
||
static void Example_User_Log_Connection(ExampleApp *app, const IEC104_SlaveEvent_t *event)
|
||
{
|
||
const IEC104_TcpConnectionEvent_t *connection = &event->transport.data.connection;
|
||
IEC104_TcpEventType_t type = event->transport.type;
|
||
char text[IEC60870_USER_LOG_TEXT_MAX + 1U];
|
||
int length;
|
||
if (app->user_log == NULL || (type != IEC104_TCP_EVENT_CONNECTED && type != IEC104_TCP_EVENT_DISCONNECTED &&
|
||
type != IEC104_TCP_EVENT_ACTIVATED && type != IEC104_TCP_EVENT_DEACTIVATED)) { return; }
|
||
length = snprintf(text, sizeof(text), "IEC104 ca=%u peer=%.15s:%u gen=%llu fault=%u socket=%d",
|
||
(unsigned)IEC104_Station_Get_Common_Address(&app->station), connection->peer.address,
|
||
(unsigned)connection->peer.port, (unsigned long long)event->transport.generation,
|
||
connection->status_valid ? (unsigned)connection->status.fault : 0U, connection->socket_error);
|
||
if (length <= 0 || (size_t)length >= sizeof(text)) {
|
||
Example_User_Log_Result(app, IEC60870_USER_LOG_INVALID); return;
|
||
}
|
||
if (type == IEC104_TCP_EVENT_CONNECTED) {
|
||
if (!app->user_log_connected) { Example_User_Log_Append(app, 2U, 1U, connection->occurred_ms, text); }
|
||
app->user_log_connected = true;
|
||
if (app->user_log_fault) { Example_User_Log_Append(app, 3U, 0U, connection->occurred_ms, text); }
|
||
app->user_log_fault = false;
|
||
}
|
||
if (connection->status_valid && connection->status.fault != IEC104_TCP_FAULT_NONE && !app->user_log_fault) {
|
||
Example_User_Log_Append(app, 3U, 1U, connection->occurred_ms, text);
|
||
app->user_log_fault = true;
|
||
}
|
||
if (type == IEC104_TCP_EVENT_DISCONNECTED) {
|
||
if (app->user_log_connected) { Example_User_Log_Append(app, 2U, 0U, connection->occurred_ms, text); }
|
||
app->user_log_connected = false;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:统一传播历史写入结果;首次失败输出原因并锁存 history_failed,主循环随后停止服务。
|
||
* 输入参数:app——示例应用上下文;result——待判定的处理结果。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:不在这里重试提交:同步失败可能已经落盘,恢复之前不能把同一事件再次追加。
|
||
*/
|
||
static bool Example_History_Result(ExampleApp *app, IEC60870_HistoryResult_t result)
|
||
{
|
||
if (result == IEC60870_HISTORY_OK) { return true; }
|
||
if (!app->history_failed) { fprintf(stderr, "HISTORY persistence failed: %d\n", (int)result); }
|
||
app->history_failed = true;
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* 功能:同一次源变位在这里持久化一次,与发送FIFO、ACK、重试和QRP2清除完全独立。
|
||
* 输入参数:app——示例应用上下文;change——本次源变位或待冻结的变化副本。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:change 在本示例中携带单调采集时刻;只接入单点/双点遥信,其他发布类型保持原流程。
|
||
* 未启用历史直接成功;时间映射或提交失败必须传回调用者,不能继续假称该事件已保存。
|
||
*/
|
||
static bool Example_History_Change(ExampleApp *app, const IEC104_SpontaneousChange_t *change)
|
||
{
|
||
uint64_t utc_ms;
|
||
uint8_t value;
|
||
if (app->history == NULL) { return true; }
|
||
if (change->kind == IEC104_SPONTANEOUS_SINGLE) { value = change->value.single; }
|
||
else if (change->kind == IEC104_SPONTANEOUS_DOUBLE) { value = change->value.double_point; }
|
||
else { return true; }
|
||
if (!Example_History_Time(app, change->time_ms, &utc_ms)) {
|
||
return Example_History_Result(app, IEC60870_HISTORY_INVALID);
|
||
}
|
||
return Example_History_Result(app, IEC60870_History_Append_Soe(&app->history->core,
|
||
change->ioa, value, change->quality, utc_ms, true));
|
||
}
|
||
|
||
/**
|
||
* 功能:示例的CO白名单是开关控制点;升降、位串、遥调不冒充附录B的分合操作记录。
|
||
* 输入参数:app——示例应用上下文;request——仅在当前回调期间借用的协议请求;command——已发生的控制操作阶段;monotonic_ms——事实发生时的单调毫秒。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:command 表示已交付应用的操作阶段,utc_ms 取该阶段的事件时间;不由确认发送结果倒推动作成功。
|
||
*/
|
||
static bool Example_History_Command(ExampleApp *app, const IEC104_CommandRequest_t *request,
|
||
IEC60870_HistoryCommand_t command, uint64_t monotonic_ms)
|
||
{
|
||
uint64_t utc_ms;
|
||
uint8_t type = request->type_id;
|
||
if (app->history == NULL || (type != 45U && type != 46U && type != 58U && type != 59U)) { return true; }
|
||
if (!Example_History_Time(app, monotonic_ms, &utc_ms)) {
|
||
return Example_History_Result(app, IEC60870_HISTORY_INVALID);
|
||
}
|
||
return Example_History_Result(app, IEC60870_History_Append_Control(&app->history->core,
|
||
request->ioa, command, request->state, utc_ms, true));
|
||
}
|
||
|
||
/**
|
||
* 功能:取本轮处理后的遥测值与品质,交给核心持续更新极值并判断是否处于定点冻结窗口。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:一次调用包含整张遥测表,输入不经过发送变化门限筛选;调度未运行期间仍可能缺测。
|
||
* 时间回拨只暂停本次观测,其他错误锁存并结束示例;缺失的十五分钟窗口不补造。
|
||
*/
|
||
static bool Example_History_Observe(ExampleApp *app)
|
||
{
|
||
float values[EXAMPLE_MEASUREMENT_COUNT];
|
||
uint8_t quality[EXAMPLE_MEASUREMENT_COUNT];
|
||
uint64_t utc_ms;
|
||
size_t index;
|
||
IEC60870_HistoryResult_t result;
|
||
if (app->history == NULL) { return true; }
|
||
if (app->history_failed) { return false; }
|
||
if (!Example_History_Time(app, IEC104_Net_Now_Ms(), &utc_ms)) {
|
||
return Example_History_Result(app, IEC60870_HISTORY_INVALID);
|
||
}
|
||
for (index = 0U; index < EXAMPLE_MEASUREMENT_COUNT; ++index) {
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
values[index] = Example_Physical_Measurement(app, index);
|
||
#else
|
||
values[index] = (float)app->scaled_values[index];
|
||
#endif
|
||
quality[index] = Example_Measurement_Quality(app, index);
|
||
}
|
||
result = IEC60870_History_Observe(&app->history->core, utc_ms, values, quality, EXAMPLE_MEASUREMENT_COUNT);
|
||
/* 校时回拨期间不覆盖已归档日槽、不重造过去样本;时间追上后自然恢复。 */
|
||
return result == IEC60870_HISTORY_TIME_REVERSED || Example_History_Result(app, result);
|
||
}
|
||
|
||
/**
|
||
* 功能:本示例固定点表生成历史白名单,静态数组存活至所有历史实例关闭。
|
||
* 输入参数:app——示例应用上下文;history——历史持久适配实例;directory——持久存储目录。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:16个单/双遥信及对应开关控制、8个遥测;增加现场点时必须同时更新实际运行点表。
|
||
* command_points 须已初始化;先取得有效墙钟,再打开并恢复存储,最后发布 app->history。
|
||
* 此处只建立历史基准,不把实时上报模块标记为已经完成主站校时。
|
||
*/
|
||
static bool Example_Init_History(ExampleApp *app, ExampleHistory *history, const char *directory)
|
||
{
|
||
static uint32_t soe_ioas[EXAMPLE_SIGNAL_COUNT + EXAMPLE_DOUBLE_COUNT];
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
static uint32_t co_ioas[DTU_COMMAND_COUNT];
|
||
#else
|
||
static uint32_t co_ioas[2U * EXAMPLE_SIGNAL_COUNT];
|
||
#endif
|
||
static uint32_t analog_ioas[EXAMPLE_MEASUREMENT_COUNT];
|
||
IEC60870_HistoryConfig_t config;
|
||
IEC60870_ClockValue_t value;
|
||
IEC60870_CP56Time2a_t time;
|
||
uint32_t seconds;
|
||
uint64_t base_ms;
|
||
size_t index;
|
||
if (app->history != NULL || history == NULL || directory == NULL) { return false; }
|
||
if (!IEC60870_Clock_Read(&value) || value.is_invalid != 0U) { return false; }
|
||
base_ms = IEC104_Net_Now_Ms();
|
||
memset(&time, 0, sizeof(time));
|
||
time.time = value.time;
|
||
if (!IEC60870_Time_CP56_To_Seconds(&time, IEC60870_LOCAL_UTC_OFFSET_MINUTES, &seconds)) { return false; }
|
||
for (index = 0U; index < EXAMPLE_SIGNAL_COUNT; ++index) {
|
||
soe_ioas[index] = example_signals[index].ioa;
|
||
}
|
||
for (index = 0U; index < EXAMPLE_DOUBLE_COUNT; ++index) {
|
||
soe_ioas[EXAMPLE_SIGNAL_COUNT + index] = (uint32_t)(EXAMPLE_IOA_DOUBLE_BASE + index);
|
||
}
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
for (index = 0U; index < DTU_COMMAND_COUNT; ++index) { co_ioas[index] = dtu_commands[index].ioa; }
|
||
#else
|
||
for (index = 0U; index < EXAMPLE_SIGNAL_COUNT; ++index) {
|
||
co_ioas[index] = app->command_points[index].ioa;
|
||
co_ioas[EXAMPLE_SIGNAL_COUNT + index] = app->command_points[EXAMPLE_SIGNAL_COUNT + index].ioa;
|
||
}
|
||
#endif
|
||
for (index = 0U; index < EXAMPLE_MEASUREMENT_COUNT; ++index) { analog_ioas[index] = example_measurements[index].ioa; }
|
||
memset(&config, 0, sizeof(config));
|
||
config.soe_ioas = soe_ioas; config.soe_count = sizeof(soe_ioas) / sizeof(soe_ioas[0]);
|
||
config.co_ioas = co_ioas; config.co_count = sizeof(co_ioas) / sizeof(co_ioas[0]);
|
||
config.analog_ioas = analog_ioas; config.analog_count = EXAMPLE_MEASUREMENT_COUNT;
|
||
config.freeze_grace_ms = 1000U;
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
if (!Example_History_Open(history, directory, &config, "DTU 100V1A example")) { return false; }
|
||
#else
|
||
if (!Example_History_Open(history, directory, &config, "IEC104 slave example")) { return false; }
|
||
#endif
|
||
app->history = history;
|
||
app->history_utc_ms = (uint64_t)seconds * 1000U + value.time.ms;
|
||
app->history_base_ms = base_ms;
|
||
app->history_failed = false;
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:附录F第一回路:冻结地址仅作为文件点标识,不经206/207发送。
|
||
* 输入参数:app——示例应用上下文;energy——冻结电能持久适配实例;meter——示例整数电能源实例;directory——持久存储目录;period_ms——功率方波周期,单位毫秒。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:在监听前同时完成介质核对、整数寄存器恢复及墙钟分段初始化。
|
||
*/
|
||
static bool Example_Init_Energy(ExampleApp *app, ExampleEnergyFreeze *energy,
|
||
ExampleEnergyMeter *meter, const char *directory, uint32_t period_ms)
|
||
{
|
||
static uint32_t interval_ioas[EXAMPLE_COUNTER_COUNT], day_ioas[EXAMPLE_COUNTER_COUNT];
|
||
static uint32_t flow_ioas[EXAMPLE_COUNTER_COUNT];
|
||
static const char *const units[EXAMPLE_COUNTER_COUNT] = {
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
"kWh", "kVarh", "kWh", "kVarh", "kVarh", "kVarh", "kVarh", "kVarh"
|
||
#else
|
||
"kWh", "kVarh", "kVarh", "kVarh", "kWh", "kVarh", "kVarh", "kVarh"
|
||
#endif
|
||
};
|
||
IEC60870_EnergyFreezeConfig_t config;
|
||
IEC60870_ClockValue_t value;
|
||
IEC60870_CP56Time2a_t time;
|
||
uint32_t seconds;
|
||
uint64_t mono, utc;
|
||
size_t index;
|
||
if (app->energy != NULL || !IEC60870_Clock_Read(&value) || value.is_invalid != 0U) { return false; }
|
||
mono = IEC104_Net_Now_Ms();
|
||
memset(&time, 0, sizeof(time)); time.time = value.time;
|
||
if (!IEC60870_Time_CP56_To_Seconds(&time, IEC60870_LOCAL_UTC_OFFSET_MINUTES, &seconds)) { return false; }
|
||
utc = (uint64_t)seconds * 1000U + value.time.ms;
|
||
IEC60870_EnergyFreeze_Config_Default(&config);
|
||
for (index = 0U; index < EXAMPLE_COUNTER_COUNT; ++index) {
|
||
interval_ioas[index] = EXAMPLE_IOA_ENERGY_INTERVAL_BASE + (uint32_t)index;
|
||
day_ioas[index] = EXAMPLE_IOA_ENERGY_DAY_BASE + (uint32_t)index;
|
||
flow_ioas[index] = EXAMPLE_IOA_ENERGY_FLOWREV_BASE + (uint32_t)index;
|
||
}
|
||
config.interval_ioas = interval_ioas; config.day_ioas = day_ioas;
|
||
config.point_count = EXAMPLE_COUNTER_COUNT;
|
||
config.flowrev_ioas = flow_ioas; config.flowrev_count = EXAMPLE_COUNTER_COUNT;
|
||
config.value_semantics = 1U;
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
if (!Example_Energy_Freeze_Open(energy, directory, &config, "DTU 100V1A example", units)) { return false; }
|
||
#else
|
||
if (!Example_Energy_Freeze_Open(energy, directory, &config, "IEC104 slave example", units)) { return false; }
|
||
#endif
|
||
if (!Example_Energy_Meter_Init(meter, period_ms, mono, utc) ||
|
||
!Example_Energy_Meter_Restore(meter, &energy->core)) {
|
||
Example_Energy_Freeze_Close(energy); return false;
|
||
}
|
||
app->energy = energy; app->energy_meter = meter; app->energy_failed = false;
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:两类来源时刻互不干扰:墙钟回拨只暂停定时冻结,FLOWREV仍按单调游标补算。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。
|
||
* 说明:提交失败后锁存退出,不能在同一faulted核心上原样重试。
|
||
*/
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
static bool Example_Dtu_Energy_Settings(ExampleApp *app, const DtuSettings *settings, uint64_t now, bool apply)
|
||
{
|
||
double common_gain, active, reactive, energy;
|
||
bool reverse;
|
||
if (app->energy_meter == NULL) { return true; }
|
||
common_gain = Dtu_Settings_Get(settings, 0x8025U, 100.0) / 100.0 *
|
||
Dtu_Settings_Get(settings, 0x8041U, 1.0) * Dtu_Settings_Get(settings, 0x8026U, 1.0) *
|
||
Dtu_Settings_Get(settings, 0x8042U, 1.0) * Dtu_Settings_Get(settings, 0x8054U, 1.0);
|
||
active = common_gain * Dtu_Settings_Get(settings, 0xA2E7U, 1.0);
|
||
reactive = common_gain * Dtu_Settings_Get(settings, 0xA2E8U, 1.0);
|
||
energy = Dtu_Measurement_Energy_Factor(settings);
|
||
reverse = Dtu_Settings_Get(settings, 0x8056U, 0.0) != 0.0;
|
||
return apply ? Example_Energy_Meter_Set_Gains_At(app->energy_meter, now, active, reactive, energy, reverse) :
|
||
Example_Energy_Meter_Can_Set_Gains_At(app->energy_meter, now, active, reactive, energy, reverse);
|
||
}
|
||
#endif
|
||
|
||
static bool Example_Energy_Step(ExampleApp *app)
|
||
{
|
||
if (app->energy == NULL) { return true; }
|
||
if (app->energy_failed) { return false; }
|
||
if (!Example_Energy_Meter_Step(app->energy_meter, &app->energy->core, IEC104_Net_Now_Ms())) {
|
||
app->energy_failed = true;
|
||
fprintf(stderr, "ENERGY_FREEZE failed: %d\n", (int)app->energy_meter->last_result);
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:配置上下限在本示例中定义有效量程,超出时保留数值并置OV;它不是通用越限告警点表。
|
||
* 输入参数:app——示例应用上下文;index——本次条目、点或逻辑槽的下标;now——本轮共用的单调毫秒时刻。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:无。
|
||
* 说明:后向Euler一阶滤波保存小数,按每点实际单调时差推进;同刻重复调用不重复滤波。
|
||
* 输出按正负对称规则取整后再判量程,等于上下限仍有效;内部小数保留以便缓变继续积累。
|
||
* range单独记录越限方向:从下越限跳到上越限时OV仍为1,也须识别为量程方向变化。
|
||
*/
|
||
static void Example_Update_Measurement(ExampleApp *app, size_t index, uint64_t now)
|
||
{
|
||
ExampleMeasurement *state = &app->measurements[index];
|
||
double tau_ms = 1000.0 * app->parameter_values[3U * EXAMPLE_MEASUREMENT_COUNT + index].short_float;
|
||
double elapsed = now >= state->updated_ms ? (double)(now - state->updated_ms) : 0.0;
|
||
int16_t low = app->parameter_values[EXAMPLE_MEASUREMENT_COUNT + index].scaled;
|
||
int16_t high = app->parameter_values[2U * EXAMPLE_MEASUREMENT_COUNT + index].scaled;
|
||
if (tau_ms == 0.0) { state->filtered = state->raw; }
|
||
else if (elapsed > 0.0) {
|
||
state->filtered += elapsed / (tau_ms + elapsed) * ((double)state->raw - state->filtered);
|
||
}
|
||
state->updated_ms = now; /* 时钟倒退只重设时基,不构造巨大的无符号时差。 */
|
||
app->scaled_values[index] = (int16_t)(state->filtered + (state->filtered < 0.0 ? -0.5 : 0.5));
|
||
state->range = app->scaled_values[index] < low ? -1 : app->scaled_values[index] > high ? 1 : 0;
|
||
state->quality = (uint8_t)(0U |
|
||
(state->range != 0 ? IEC60870_ASDU_QUALITY_OV : 0U));
|
||
}
|
||
|
||
/**
|
||
* 功能:参数模块就绪后,以同一个单调时刻推进全部遥测的滤波值、量程状态和质量位。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:无。
|
||
* 说明:未启用参数模块时直接返回,保持示例原始遥测值。
|
||
*/
|
||
static void Example_Update_Measurements(ExampleApp *app)
|
||
{
|
||
size_t index;
|
||
uint64_t now;
|
||
if (app->parameter == NULL) { return; }
|
||
/* 一轮共用同一时刻,避免8点因函数执行先后产生不同的滤波时差。 */
|
||
now = IEC104_Net_Now_Ms();
|
||
for (index = 0U; index < EXAMPLE_MEASUREMENT_COUNT; ++index) { Example_Update_Measurement(app, index, now); }
|
||
}
|
||
|
||
/**
|
||
* 功能:新输入到达前先推进旧输入,避免把新值追溯应用到此前的时间段。tau=0立即直通。
|
||
* 输入参数:app——示例应用上下文;index——本次条目、点或逻辑槽的下标;raw——新的原始标度值。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:无。
|
||
* 说明:第二次更新使用同一now:tau>0时保持滤波连续,新输入留待后续时差生效;tau=0时立即取新值。
|
||
*/
|
||
static void Example_Set_Measurement(ExampleApp *app, size_t index, int16_t raw)
|
||
{
|
||
if (app->parameter != NULL) {
|
||
uint64_t now = IEC104_Net_Now_Ms();
|
||
Example_Update_Measurement(app, index, now);
|
||
app->measurements[index].raw = raw;
|
||
Example_Update_Measurement(app, index, now);
|
||
} else { app->scaled_values[index] = raw; }
|
||
}
|
||
|
||
/**
|
||
* 功能:初始化或QRP1恢复时,以当时运行值建立输入、滤波和上送基准,避免把启动本身当成数值变位。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:无。
|
||
* 说明:调用前须先准备参数和scaled_values;QRP2仅重设发布基准,不应调用此函数重置滤波状态。
|
||
*/
|
||
static void Example_Reset_Measurements(ExampleApp *app)
|
||
{
|
||
size_t index;
|
||
uint64_t now = IEC104_Net_Now_Ms();
|
||
for (index = 0U; index < EXAMPLE_MEASUREMENT_COUNT; ++index) {
|
||
ExampleMeasurement *state = &app->measurements[index];
|
||
memset(state, 0, sizeof(*state));
|
||
state->raw = state->submitted_value = app->scaled_values[index];
|
||
state->filtered = state->raw;
|
||
state->updated_ms = now;
|
||
Example_Update_Measurement(app, index, now);
|
||
state->submitted_quality = state->quality;
|
||
state->submitted_range = state->range;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:基准只表示完整交给发送队列,或命令FINISHED确认返校已交付;不冒充主站ACK。
|
||
* 输入参数:app——示例应用上下文;entry——应用发布记录。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:无。
|
||
* 说明:time_tag_cleared还标记QRP2之前留下的快照:它可以继续发布,但不能把新建基准退回旧值。
|
||
*/
|
||
static void Example_Submitted_Measurement(ExampleApp *app, const ExamplePublication *entry)
|
||
{
|
||
size_t index = entry->change.ioa - EXAMPLE_IOA_MEASUREMENT_BASE;
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
if (!entry->time_tag_cleared && entry->change.kind == IEC104_SPONTANEOUS_SCALED &&
|
||
entry->change.station_id == IEC104_Station_Get_Id(&app->station) && index < EXAMPLE_MEASUREMENT_COUNT) {
|
||
app->dtu_submitted[index] = entry->change.value.scaled;
|
||
}
|
||
#endif
|
||
if (app->parameter != NULL && !entry->time_tag_cleared && entry->change.kind == IEC104_SPONTANEOUS_SCALED &&
|
||
entry->change.station_id == IEC104_Station_Get_Id(&app->station) && index < EXAMPLE_MEASUREMENT_COUNT) {
|
||
ExampleMeasurement *state = &app->measurements[index];
|
||
state->submitted_value = entry->change.value.scaled;
|
||
state->submitted_quality = entry->change.quality;
|
||
state->submitted_range = entry->measurement_range;
|
||
}
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [SPONTANEOUS/QUEUE] 突发上送:应用变化队列、遥控补报占位与周期采样
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:从应用待发布数组移除指定条目并压紧后续元素。
|
||
* 输入参数:app——示例应用上下文;index——本次条目、点或逻辑槽的下标。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:无。
|
||
* 说明:仅用于应用待发布数组,调用方保证index有效;压紧后不得继续使用先前取得的条目指针。
|
||
* 发送层已经接手的NORMAL条目独立持有副本,不受这里移除或移动元素影响。
|
||
*/
|
||
static void Example_Remove_Publication(ExampleApp *app, size_t index)
|
||
{
|
||
if (index + 1U < app->publication_count) {
|
||
memmove(&app->publications[index], &app->publications[index + 1U],
|
||
(app->publication_count - index - 1U) * sizeof(app->publications[0]));
|
||
}
|
||
--app->publication_count;
|
||
}
|
||
|
||
/**
|
||
* 功能:QRP=2只处理已有变化的发布形态,不修改点的当前值或采样时间。
|
||
* 输入参数:app——示例应用上下文;entry——应用发布记录。
|
||
* 输出参数:entry——应用发布记录。
|
||
* 返回值:清除CP56后仍有合法发布形态时返回true;否则返回false,调用方须删除该条目。
|
||
* 说明:forms=0是“继承配置”,不是“不发送”;清除CP56前须先展开,剩余形态须写成显式值。
|
||
* 默认单/双点只有CP56,清除后须删除事件,不能改发PLAIN;显式兼容双报才可能留下PLAIN。
|
||
* false表示无合法形态可发布,调用方必须删除条目,不能把0留给后续Publish再次继承。
|
||
*/
|
||
static bool Example_Clear_Publication_Time(ExampleApp *app, ExamplePublication *entry)
|
||
{
|
||
unsigned kind = (unsigned)entry->change.kind;
|
||
uint8_t forms = entry->change.forms;
|
||
if (kind == 0U || kind > IEC104_SPONTANEOUS_KIND_COUNT) { return false; }
|
||
if (forms == 0U) { forms = app->publication_forms[kind - 1U]; }
|
||
entry->change.forms = (uint8_t)(forms & (uint8_t)~IEC104_SPONTANEOUS_FORM_CP56);
|
||
return entry->change.forms != 0U;
|
||
}
|
||
|
||
/**
|
||
* 功能:把指定采样单调时刻映射为监视信息使用的本地CP56快照。
|
||
* 输入参数:app/time均非NULL;sampled_ms与Net_Now_Ms、clock_base_ms属于同一单调时钟。
|
||
* 输出参数:覆盖*time,不修改应用时钟或同步状态;无返回值。
|
||
* 返回值:无。
|
||
* 说明:先给出2000-01-01的可编码占位并置时间IV;基准缺失、采样早于基准、
|
||
* 整数溢出或超出CP56年份范围时保留该占位,不伪造有效时间。
|
||
* 能换算日历但未同步时保留近似日历及IV=1;只有发布器确认同步才清时间IV。
|
||
* 时间IV与SIQ/DIQ数据品质独立,本函数不会把时钟失效改写成遥信值无效。
|
||
*/
|
||
static void Example_Monitor_Time(const ExampleApp *app, uint64_t sampled_ms,
|
||
IEC60870_CP56Time2a_t *time)
|
||
{
|
||
IEC104_SpontaneousStatus_t status;
|
||
IEC60870_WallTime_t local;
|
||
uint64_t elapsed, utc_ms;
|
||
memset(time, 0, sizeof(*time));
|
||
time->time.year = 2000U; time->time.month = 1U; time->time.day = 1U;
|
||
time->is_invalid = 1U; time->has_weekday = 1U;
|
||
if (!app->clock_valid || sampled_ms < app->clock_base_ms) { return; }
|
||
elapsed = sampled_ms - app->clock_base_ms;
|
||
if (app->clock_utc_ms > UINT64_MAX - elapsed) { return; }
|
||
utc_ms = app->clock_utc_ms + elapsed;
|
||
if (utc_ms / 1000U > IEC60870_TIME_MAX_SECONDS ||
|
||
!IEC60870_Time_Seconds_To_Local((uint32_t)(utc_ms / 1000U), (uint16_t)(utc_ms % 1000U), &local) ||
|
||
local.year < 2000U || local.year > 2099U) { return; }
|
||
time->time = local;
|
||
if (IEC104_Spontaneous_Get_Status(app->spontaneous, &status) && status.time_synchronized) {
|
||
time->is_invalid = 0U;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:在应用入队时把单/双点的单调采样时间冻结为UTC毫秒及其时间品质。
|
||
* 输入参数:app/change均非NULL,change是即将保存的队列副本。
|
||
* 输出参数:仅处理单/双点的MONOTONIC输入;已为UTC或其他类型的条目保持原样,无返回值。
|
||
* 返回值:无。
|
||
* 说明:用入队时的基准换算一次;后续Publish的WAIT、断线补报或再次校时都沿用
|
||
* 保存的UTC和time_invalid,不能重新映射历史事件。原始采样对象不在此修改。
|
||
* CP56只作为中间日历;秒数换算后再加毫秒余数,不能把毫秒重复计入。
|
||
*/
|
||
static void Example_Freeze_Signal_Time(const ExampleApp *app, IEC104_SpontaneousChange_t *change)
|
||
{
|
||
IEC60870_CP56Time2a_t time;
|
||
uint32_t seconds;
|
||
if ((change->kind != IEC104_SPONTANEOUS_SINGLE && change->kind != IEC104_SPONTANEOUS_DOUBLE) ||
|
||
change->time_kind != IEC104_SPONTANEOUS_TIME_MONOTONIC) { return; }
|
||
Example_Monitor_Time(app, change->time_ms, &time);
|
||
change->time_invalid = time.is_invalid != 0U;
|
||
time.is_invalid = 0U; /* 仅让日历参与数值换算;真实时间IV已单独保存,不因此获得有效授时。 */
|
||
if (!IEC60870_Time_CP56_To_Seconds(&time, IEC60870_LOCAL_UTC_OFFSET_MINUTES, &seconds)) {
|
||
/* UTC零值超出CP56年份范围,发布器会使用无效占位;不能保留旧的单调毫秒冒充UTC。 */
|
||
change->time_ms = 0U;
|
||
change->time_invalid = true;
|
||
} else {
|
||
change->time_ms = (uint64_t)seconds * 1000U + time.time.ms;
|
||
}
|
||
change->time_kind = IEC104_SPONTANEOUS_TIME_UTC;
|
||
}
|
||
|
||
/**
|
||
* 功能:判断单、双点变化是否使用独立CP56 SOE缓存。
|
||
* 输入参数:app——示例应用;change——采集变化。
|
||
* 输出参数:无。
|
||
* 返回值:单、双点且COT为3、有效形态仅CP56时返回true,其他变化返回false。
|
||
* 说明:零cause及forms分别采用突发原因和配置默认值;PLAIN或双报仍使用普通发布流程。
|
||
*/
|
||
static bool Example_Is_Compact_Soe(const ExampleApp *app, const IEC104_SpontaneousChange_t *change)
|
||
{
|
||
uint8_t forms;
|
||
if (change->kind != IEC104_SPONTANEOUS_SINGLE && change->kind != IEC104_SPONTANEOUS_DOUBLE) { return false; }
|
||
forms = change->forms != 0U ? change->forms : app->publication_forms[change->kind - 1U];
|
||
return (change->cause == 0U || change->cause == IEC60870_ASDU_COT_SPONTANEOUS) &&
|
||
forms == IEC104_SPONTANEOUS_FORM_CP56;
|
||
}
|
||
|
||
/**
|
||
* 功能:在新SOE分配序号前交接已有普通发布前缀,保持应用采集先后顺序。
|
||
* 输入参数:app——示例应用及至多32条待发布记录。
|
||
* 输出参数:app——出队记录、提交基准及publication_waiting状态。
|
||
* 返回值:前缀已处理或遇占位/WAIT时返回true,服务故障返回false。
|
||
* 说明:仅交接缓存,不推进网络;调用者区分WAIT与未决标记,后者不阻止继续采集SOE。
|
||
*/
|
||
static bool Example_Drain_Publications(ExampleApp *app);
|
||
|
||
/**
|
||
* 功能:采集SOE直接进入独立缓存;其余变化保存在普通发布数组,给唯一遥控事务保留保序标记。
|
||
* 输入参数:app——示例应用上下文;entry——应用发布记录。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:按应用过载策略处理完毕时返回true,可能淘汰旧条目;无法处理时返回false。
|
||
* 说明:true表示按应用过载策略处理完毕,可能伴随丢旧计数,不表示已经发布或已送达主站。
|
||
* SOE占位原文由发送层持有,可被第257条覆盖;应用标记只阻挡较晚普通发布,不能阻止后续SOE采集。
|
||
* 普通变化过载时淘汰最旧普通条目,不能淘汰未决标记;采样快照与读取当前运行值的用途不同。
|
||
* 先按值复制再冻结队列时间,调用方及历史记录路径仍可使用原始MONOTONIC采样时间。
|
||
*/
|
||
static bool Example_Queue_Publication(ExampleApp *app, const ExamplePublication *entry)
|
||
{
|
||
size_t index, ordinary = 0U;
|
||
bool compact = Example_Is_Compact_Soe(app, &entry->change);
|
||
IEC104_SpontaneousPublishInfo_t info;
|
||
/* 先交接此前普通记录再分配SOE序号;marker仍保留位置,但不能堵住后续SOE采集。
|
||
* WAIT尚未交接完前缀,本次SOE也不接手,调用方不能把false当成已保存。 */
|
||
if (compact && (!Example_Drain_Publications(app) || app->publication_waiting)) { return false; }
|
||
if (compact && !entry->placeholder) {
|
||
IEC104_SpontaneousChange_t change = entry->change;
|
||
IEC104_SpontaneousPublishResult_t result;
|
||
Example_Freeze_Signal_Time(app, &change);
|
||
result = IEC104_Spontaneous_Publish(app->spontaneous, &change, 1U, &info);
|
||
if (result == IEC104_SPONTANEOUS_PUBLISH_ERROR && info.error == IEC104_SPONTANEOUS_ERROR_INPUT) {
|
||
++app->publication_invalid;
|
||
return true;
|
||
}
|
||
return result == IEC104_SPONTANEOUS_PUBLISH_OK;
|
||
}
|
||
for (index = 0U; index < app->publication_count; ++index) {
|
||
if (!app->publications[index].placeholder) { ++ordinary; }
|
||
else if (entry->placeholder) { return false; }
|
||
}
|
||
while (app->publication_count == EXAMPLE_PUBLICATION_CAPACITY ||
|
||
(!entry->placeholder && ordinary >= EXAMPLE_PUBLICATION_CAPACITY - 1U)) {
|
||
for (index = 0U; index < app->publication_count; ++index) {
|
||
if (!app->publications[index].placeholder) { break; }
|
||
}
|
||
if (index == app->publication_count) {
|
||
if (entry->placeholder) { return false; }
|
||
++app->publication_dropped;
|
||
return true;
|
||
}
|
||
Example_Remove_Publication(app, index);
|
||
--ordinary;
|
||
++app->publication_dropped;
|
||
}
|
||
app->publications[app->publication_count] = *entry;
|
||
Example_Freeze_Signal_Time(app, &app->publications[app->publication_count].change);
|
||
if (compact && entry->placeholder) {
|
||
IEC104_SoeTicket_t ticket;
|
||
memset(&ticket, 0, sizeof(ticket));
|
||
if (entry->has_change && IEC104_Spontaneous_Defer_Soe(app->spontaneous,
|
||
&app->publications[app->publication_count].change, &ticket, &info) !=
|
||
IEC104_SPONTANEOUS_PUBLISH_OK) { return false; }
|
||
app->command_soe_ticket = ticket;
|
||
app->command_soe_instance = entry->instance_id;
|
||
app->command_soe_transaction = entry->transaction_id;
|
||
app->command_soe_active = true;
|
||
}
|
||
++app->publication_count;
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:根据FINISHED的最终凭证取消或放行原SOE占位,其他类型仍按原流程决定普通COT=3补报。
|
||
* 输入参数:app——示例应用上下文;instance_id——业务模块实例身份;transaction_id——本次业务事务身份;undelivered——返回信息是否未完成交付。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:占位处理完成或无匹配占位时返回true;运行中的SOE身份解析失败返回false。
|
||
* 说明:accepted只表示返回信息曾被接手,必须结合undelivered判断;没有变化时无需补报。
|
||
* 同时匹配实例与事务编号,避免较早事务的结束通知处理后来事务的占位。
|
||
*/
|
||
static bool Example_Resolve_Publication(ExampleApp *app, uint64_t instance_id,
|
||
uint64_t transaction_id, bool undelivered)
|
||
{
|
||
size_t index;
|
||
for (index = 0U; index < app->publication_count; ++index) {
|
||
ExamplePublication *entry = &app->publications[index];
|
||
if (entry->placeholder && entry->instance_id == instance_id &&
|
||
entry->transaction_id == transaction_id) {
|
||
if (app->command_soe_active && app->command_soe_instance == instance_id &&
|
||
app->command_soe_transaction == transaction_id) {
|
||
if (app->command_soe_ticket.serial != 0U && IEC104_Slave_Resolve_Soe(app->slave,
|
||
&app->command_soe_ticket, !(entry->accepted && !undelivered)) != IEC104_TCP_OK) {
|
||
IEC104_TcpServerStatus_t status;
|
||
/* 正常清理在Close前完成;Close期间才交付的FINISHED只清应用标记,
|
||
* 已关闭实例的队列已销毁,不能把失效票据当作新事件重新入队。 */
|
||
if (IEC104_Slave_Get_Status(app->slave, &status, NULL) != IEC104_TCP_OK || status.listening) {
|
||
return false;
|
||
}
|
||
}
|
||
app->command_soe_active = false;
|
||
app->command_soe_instance = app->command_soe_transaction = 0U;
|
||
memset(&app->command_soe_ticket, 0, sizeof(app->command_soe_ticket));
|
||
Example_Remove_Publication(app, index);
|
||
return true;
|
||
}
|
||
if ((entry->accepted && !undelivered) || !entry->has_change ||
|
||
(entry->time_tag_cleared && !Example_Clear_Publication_Time(app, entry))) {
|
||
if (entry->accepted && !undelivered) { Example_Submitted_Measurement(app, entry); }
|
||
Example_Remove_Publication(app, index);
|
||
}
|
||
else {
|
||
entry->placeholder = false;
|
||
entry->change.cause = IEC60870_ASDU_COT_SPONTANEOUS;
|
||
}
|
||
return true;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:返回信息提交OK后先标记accepted,等FINISHED冻结凭证状态再决定是否需要补报。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:找到本次命令对应占位并标记已接手时返回true,没有匹配占位时返回false。
|
||
* 说明:应用标记阻挡较晚普通发布;独立SOE占位同时约束后续SOE发送次序,
|
||
* 两者均不阻塞遥控应答或总召/读命令,后续真实SOE仍可继续采集入库。
|
||
*/
|
||
static bool Example_Accept_Publication(ExampleApp *app)
|
||
{
|
||
size_t index;
|
||
for (index = 0U; index < app->publication_count; ++index) {
|
||
ExamplePublication *entry = &app->publications[index];
|
||
if (entry->placeholder && entry->instance_id == app->command_instance &&
|
||
entry->transaction_id == app->command_transaction) {
|
||
entry->accepted = true;
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* 功能:每轮至多采一次当前值,错过周期不补造历史变位;条目时刻取实际采样的单调时间。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。
|
||
* 说明:通用field以微扰、负载变化及阶跃增量更新raw,保留遥调工作点,遥信由遥控改变。
|
||
* DTU field按单调毫秒推进30秒工况,每拍从配置初值重建遥测并计算三段过流遥信;
|
||
* 因而下一拍会覆盖遥调工作点,--events改变采样密度但不缩放30秒工况。stress轮转压力输入。
|
||
* 先更新共用运行值,再排入变化快照,因此即使发布等待,总召和读命令也能读取新值。
|
||
* --events 0停止模拟采样和普通DTU电量积分;DTU已待发遥信仍Flush,主循环仍推进
|
||
* 滤波、命令、背景扫描及可选冻结电量服务的独立计量节拍。
|
||
* true表示本拍完成或尚未到期,不表示产生了报文;发布失败返回false交主循环收尾。
|
||
*/
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
#include "iec104_dtu_runtime.inc"
|
||
#endif
|
||
static bool Example_Collect_Events(ExampleApp *app)
|
||
{
|
||
ExamplePublication entry;
|
||
uint64_t now;
|
||
size_t index = app->events_index;
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
now = IEC104_Net_Now_Ms();
|
||
Example_Dtu_Update_Digital(app, now);
|
||
if (!Example_Dtu_Flush_Signals(app)) { return false; }
|
||
#endif
|
||
if (app->events_interval_ms == 0U) { return true; }
|
||
now = IEC104_Net_Now_Ms();
|
||
/* 单调读数倒退时立即采一拍并重设时间基准,避免无符号减法制造巨大补采次数。 */
|
||
if (now >= app->events_last_ms && now - app->events_last_ms < app->events_interval_ms) { return true; }
|
||
app->events_last_ms = now;
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
Example_Dtu_Accumulate_Energy(app, now);
|
||
#endif
|
||
memset(&entry, 0, sizeof(entry));
|
||
entry.has_change = true;
|
||
entry.change.common_address = IEC104_Station_Get_Common_Address(&app->station);
|
||
entry.change.station_id = IEC104_Station_Get_Id(&app->station);
|
||
entry.change.time_kind = IEC104_SPONTANEOUS_TIME_MONOTONIC;
|
||
entry.change.time_ms = now;
|
||
if (app->events_field) {
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
return Example_Dtu_Field(app, now);
|
||
#else
|
||
/* 相位按实际执行的采样拍数计,不是毫秒数;调整--events会缩放整轮持续时间。
|
||
* 相邻两拍的+1/-1微扰相抵;10..29累加100,40另加250,60..79减回100,100另减250。
|
||
* 默认参数且无外部干预时,门限200过滤前40拍的小变化,相位40(第41次采样)的阶跃
|
||
* 触发上送;修改门限或平滑时间后未必在该拍触发,品质变化另行判定。
|
||
* 无遥调介入且未触及饱和边界时,120拍净增量为0;默认间隔下约12秒一轮。 */
|
||
int32_t delta = index % 2U == 0U ? 1 : -1;
|
||
if (index >= 10U && index < 30U) { delta += 5; }
|
||
else if (index >= 60U && index < 80U) { delta -= 5; }
|
||
if (index == 40U) { delta += 250; }
|
||
else if (index == 100U) { delta -= 250; }
|
||
for (index = 0U; index < EXAMPLE_MEASUREMENT_COUNT; ++index) {
|
||
/* 必须在当前原始值上加增量,不能用初始点表重建绝对值,也不能在滤波值上叠加。
|
||
* 这样遥调建立的新工作点继续有效;输入经Example_Set_Measurement进入测量链,主循环继续推进平滑。 */
|
||
int16_t previous = app->parameter != NULL ? app->measurements[index].raw : app->scaled_values[index];
|
||
int32_t raw = (int32_t)previous + delta;
|
||
if (raw < EXAMPLE_SCALED_MIN) { raw = EXAMPLE_SCALED_MIN; }
|
||
else if (raw > EXAMPLE_SCALED_MAX) { raw = EXAMPLE_SCALED_MAX; }
|
||
Example_Set_Measurement(app, index, (int16_t)raw);
|
||
/* 参数启用时只更新输入,随后由统一测量链按处理值、品质及门限生成COT3。
|
||
* 显式禁用参数才直接排变化;饱和后的同值不再制造重复事件。 */
|
||
if (app->parameter == NULL && raw != previous) {
|
||
entry.change.kind = IEC104_SPONTANEOUS_SCALED;
|
||
entry.change.ioa = example_measurements[index].ioa;
|
||
entry.change.value.scaled = app->scaled_values[index];
|
||
entry.change.quality = Example_Measurement_Quality(app, index);
|
||
if (!Example_Queue_Publication(app, &entry)) { return false; }
|
||
}
|
||
}
|
||
app->events_index = (app->events_index + 1U) % 120U;
|
||
return true;
|
||
#endif
|
||
}
|
||
/* stress故意持续翻转遥信、递增遥测,并在上边界回绕,用于积压/重连压力测试。
|
||
* 每点两拍,8点轮转一圈共16拍;这不是field的“每拍更新全部遥测”。 */
|
||
if (!app->events_measurement) {
|
||
app->signal_values[index] ^= 1U;
|
||
entry.change.kind = IEC104_SPONTANEOUS_SINGLE;
|
||
entry.change.ioa = example_signals[index].ioa;
|
||
entry.change.value.single = app->signal_values[index];
|
||
entry.change.quality = 0U;
|
||
} else {
|
||
size_t signal_index = index;
|
||
index %= EXAMPLE_MEASUREMENT_COUNT;
|
||
int16_t raw = app->parameter != NULL ? app->measurements[index].raw : app->scaled_values[index];
|
||
Example_Set_Measurement(app, index, raw == EXAMPLE_SCALED_MAX ? EXAMPLE_SCALED_MIN : (int16_t)(raw + 1));
|
||
entry.change.kind = IEC104_SPONTANEOUS_SCALED;
|
||
entry.change.ioa = example_measurements[index].ioa;
|
||
entry.change.value.scaled = app->scaled_values[index];
|
||
entry.change.quality = Example_Measurement_Quality(app, index);
|
||
app->events_index = (signal_index + 1U) % EXAMPLE_SIGNAL_COUNT;
|
||
}
|
||
app->events_measurement = !app->events_measurement;
|
||
/* 参数模式由统一处理链按门限产生变化;遥信仍按原规则发布。 */
|
||
if (app->parameter != NULL && entry.change.kind == IEC104_SPONTANEOUS_SCALED) { return true; }
|
||
/* 源变位先独立保存一次,再进入可因背压/覆盖而变化的实时发布队列。 */
|
||
if (!Example_History_Change(app, &entry.change)) { return false; }
|
||
return Example_Queue_Publication(app, &entry);
|
||
}
|
||
|
||
/**
|
||
* 功能:按参数门限收集需要普通COT3上送的遥测变化。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。
|
||
* 说明:仅过滤普通COT3。总召、读命令、周期/背景和遥调返校均不受门限抑制。
|
||
* 比较对象是上次已交接的变化/返校基准,不是上一采样值;小步缓变才能累计越过门限。
|
||
* COT1/2、总召和Read仅取当前快照,不推进此基准;品质和量程侧变化不受数值门限阻挡。
|
||
* 同点已有快照/命令占位时等待它出队;出队后重新比较最新值,WAIT和淘汰都不提前推进基准。
|
||
*/
|
||
static bool Example_Collect_Measurement_Changes(ExampleApp *app)
|
||
{
|
||
size_t index;
|
||
if (app->parameter == NULL) { return true; }
|
||
for (index = 0U; index < EXAMPLE_MEASUREMENT_COUNT; ++index) {
|
||
ExampleMeasurement *state = &app->measurements[index];
|
||
ExamplePublication entry;
|
||
int32_t difference = (int32_t)app->scaled_values[index] - state->submitted_value;
|
||
uint32_t delta = (uint32_t)(difference < 0 ? -difference : difference);
|
||
bool changed = state->quality != state->submitted_quality || state->range != state->submitted_range;
|
||
size_t pending;
|
||
/* 门限0表示任意非零数值变化可报,不表示每次扫描都报;品质/量程侧变化已单独判定。 */
|
||
if (app->parameter_points[index].type_id == IEC60870_ASDU_P_ME_NA_1) {
|
||
/* 固定满量程幅值10000;交叉乘保留归一化门限的精确边界,不随上下限改变。 */
|
||
changed = changed || (delta != 0U && delta * 32768U >=
|
||
(uint32_t)app->parameter_values[index].normalized * (uint32_t)EXAMPLE_SCALED_MAX);
|
||
} else {
|
||
changed = changed || (delta != 0U && delta >= (uint32_t)app->parameter_values[index].scaled);
|
||
}
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
/* XML绝对死区与标准变化门限共同约束数值变化;品质/越限变化始终放行。 */
|
||
if (state->quality == state->submitted_quality && state->range == state->submitted_range) {
|
||
changed = changed && Dtu_Measurement_Changed(Example_Physical_Measurement(app, index),
|
||
(double)state->submitted_value / Example_Measurement_Scale(index),
|
||
Dtu_Measurement_Deadband(&app->dtu_settings, dtu_measurements[index].source_addr));
|
||
}
|
||
#endif
|
||
if (!changed) { continue; }
|
||
for (pending = 0U; pending < app->publication_count; ++pending) {
|
||
if (app->publications[pending].change.kind == IEC104_SPONTANEOUS_SCALED &&
|
||
app->publications[pending].change.ioa == example_measurements[index].ioa &&
|
||
app->publications[pending].change.station_id == IEC104_Station_Get_Id(&app->station)) { break; }
|
||
}
|
||
if (pending < app->publication_count) { continue; }
|
||
memset(&entry, 0, sizeof(entry));
|
||
entry.has_change = true;
|
||
entry.measurement_range = state->range;
|
||
entry.change.kind = IEC104_SPONTANEOUS_SCALED;
|
||
entry.change.common_address = IEC104_Station_Get_Common_Address(&app->station);
|
||
entry.change.station_id = IEC104_Station_Get_Id(&app->station);
|
||
entry.change.ioa = example_measurements[index].ioa;
|
||
entry.change.value.scaled = app->scaled_values[index];
|
||
entry.change.quality = state->quality;
|
||
entry.change.time_kind = IEC104_SPONTANEOUS_TIME_MONOTONIC;
|
||
entry.change.time_ms = state->updated_ms;
|
||
if (!Example_Queue_Publication(app, &entry)) { return false; }
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:按应用数组顺序发布;published表示被模块接手的条目数,移除它不等于主站已经收到。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。
|
||
* 说明:WAIT保留未接手的队首并让出网络;占位等待FINISHED解析,不自行猜测返回信息结果。
|
||
* 单条输入错误可丢弃后继续,服务/队列/提交故障则返回false交主循环统一收尾。
|
||
*/
|
||
static bool Example_Drain_Publications(ExampleApp *app)
|
||
{
|
||
app->publication_waiting = false;
|
||
while (app->publication_count != 0U) {
|
||
IEC104_SpontaneousPublishInfo_t info;
|
||
IEC104_SpontaneousPublishResult_t result;
|
||
if (app->publications[0].placeholder) { break; }
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
{
|
||
IEC104_SpontaneousChange_t wire = app->publications[0].change;
|
||
if (wire.kind == IEC104_SPONTANEOUS_SCALED) {
|
||
float value = (float)wire.value.scaled /
|
||
Example_Measurement_Scale(wire.ioa - EXAMPLE_IOA_MEASUREMENT_BASE);
|
||
wire.kind = IEC104_SPONTANEOUS_FLOAT;
|
||
wire.value.short_float = value;
|
||
}
|
||
result = IEC104_Spontaneous_Publish(app->spontaneous, &wire, 1U, &info);
|
||
}
|
||
#else
|
||
result = IEC104_Spontaneous_Publish(app->spontaneous, &app->publications[0].change, 1U, &info);
|
||
#endif
|
||
if (info.published != 0U) {
|
||
Example_Submitted_Measurement(app, &app->publications[0]);
|
||
Example_Remove_Publication(app, 0U);
|
||
}
|
||
if (result == IEC104_SPONTANEOUS_PUBLISH_OK) { continue; }
|
||
if (result == IEC104_SPONTANEOUS_PUBLISH_WAIT) {
|
||
app->publication_waiting = true;
|
||
return true;
|
||
}
|
||
if (info.error == IEC104_SPONTANEOUS_ERROR_INPUT && info.failed_index == 0U) {
|
||
Example_Remove_Publication(app, 0U);
|
||
++app->publication_invalid;
|
||
continue;
|
||
}
|
||
return false; /* STATE/QUEUE/SUBMIT: main stops and closes the service. */
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [GI/DATA] 总召业务 Type100:分组取值、批次提交与数据游标
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:为总召监视数据追加一个点:SQ=1遇到同类型地址断号时,以FULL结束当前连续段。
|
||
* 输入参数:asdu——待组装的ASDU;point——本次加入的信息对象。
|
||
* 输出参数:asdu——待组装的ASDU。
|
||
* 返回值:沿用信息对象编码或ASDU追加结果:OK表示成功,FULL表示容量不足,ERROR等错误表示对象、类型或编码条件不满足。
|
||
* 说明:FULL不消费这个点,提交成功后下一批仍从该点开始;不能把缺失地址补成虚构数据。
|
||
* 断号时先验证已有帧,再以零容量编码仅验证新点,合法非空载荷返回FULL且不写缓冲。
|
||
* 这样非法IOA/品质/对象身份仍返回错误,不会被当作正常分帧;连续点沿用公共Add检查。
|
||
* 参数批次不经过此入口;Type100控制及Type110..112参数继续使用SQ=0。
|
||
*/
|
||
static IEC60870_AsduResult_t Example_Gi_Add_Point(IEC60870_Asdu_t *asdu,
|
||
const IEC60870_InformationObject_t *point)
|
||
{
|
||
if (asdu != NULL && point != NULL && asdu->is_sequence != 0U && asdu->object_count != 0U &&
|
||
point->type_id == asdu->type_id && point->ioa != asdu->first_ioa + asdu->object_count) {
|
||
const uint8_t *bytes;
|
||
uint16_t length;
|
||
if (IEC60870_Asdu_Get_Data(asdu, &bytes, &length) != IEC60870_ASDU_OK) {
|
||
return IEC60870_ASDU_ERROR;
|
||
}
|
||
return IEC60870_InformationObject_Encode(point, asdu->parameters, 1, asdu->buffer, 0U, &length);
|
||
}
|
||
return IEC60870_Asdu_Add_InformationObject(asdu, point);
|
||
}
|
||
|
||
/**
|
||
* 功能:普通应用函数,只由下面的事件分支直接调用,不注册到库中。
|
||
* 输入参数:app——示例应用上下文;request——仅在当前回调期间借用的协议请求。
|
||
* 输出参数:app->batch及app->batch_bytes——本次构造的总召批次;业务游标由提交成功路径另行推进。
|
||
* 返回值:1表示已构造非空批次,0表示所选数据已读完,-1表示身份校验或构造失败。
|
||
* 说明:应用自行选择本批IOA、类型及分组成员;为NEED_DATA构造一种类型的一批。
|
||
* 细则要求总召遥信/遥测按SQ=1发送;--sequence仅控制周期/背景扫描,不影响这里。
|
||
* 真实取值应放在下列逐点组包处,值与品质的读取一致性由数据源保证;不预读整轮数据。
|
||
* 连续段结束或FULL均不跳过当前点;本函数不推进持久游标,Submit_Batch(OK)后才推进。
|
||
* WAIT仅保留事件,每次重试重读当前值。点值更新/突发发布与本次组包/提交须串行协调。
|
||
* 逐批取值不保证整轮同一采样时刻。
|
||
*/
|
||
static int Example_Build_Batch(ExampleApp *app, const IEC104_InterrogationRequest_t *request)
|
||
{
|
||
ExampleGiData *data = &app->gi_data;
|
||
IEC60870_Asdu_t *asdu = &app->batch;
|
||
IEC60870_AsduHeader_t header;
|
||
bool monitoring = data->single_index < EXAMPLE_SIGNAL_COUNT ||
|
||
data->double_index < EXAMPLE_DOUBLE_COUNT || data->scaled_index < EXAMPLE_MEASUREMENT_COUNT;
|
||
IEC104_Station_t *station = request->station_id != 0U ?
|
||
IEC104_Slave_Get_Station_By_Id(app->slave, request->station_id) :
|
||
IEC104_Slave_Get_Station(app->slave, request->common_address);
|
||
if (IEC104_Station_Get_Context(station) != app) {
|
||
return -1;
|
||
}
|
||
memset(&header, 0, sizeof(header));
|
||
header.cause_of_transmission = request->qualifier; /* 站总召20,分组总召21..36。 */
|
||
header.common_address = request->common_address;
|
||
header.originator_address = request->originator_address;
|
||
header.is_test = request->is_test;
|
||
if (IEC60870_Asdu_Create(asdu, IEC104_Slave_Get_Application_Layer_Parameters(app->slave),
|
||
app->batch_bytes, sizeof(app->batch_bytes), &header, monitoring ? 1 : 0) != IEC60870_ASDU_OK) { return -1; }
|
||
if (data->single_index < EXAMPLE_SIGNAL_COUNT) {
|
||
size_t index = data->single_index;
|
||
while (index < EXAMPLE_SIGNAL_COUNT && asdu->object_count < request->max_objects_per_asdu) {
|
||
IEC60870_SinglePointInformation_t point;
|
||
IEC60870_AsduResult_t added;
|
||
if (IEC60870_SinglePointInformation_Create(&point, example_signals[index].ioa,
|
||
app->signal_values[index], 0U) != IEC60870_ASDU_OK) {
|
||
return -1;
|
||
}
|
||
added = Example_Gi_Add_Point(asdu, &point.object);
|
||
if (added == IEC60870_ASDU_FULL) { break; }
|
||
if (added != IEC60870_ASDU_OK) { return -1; }
|
||
++index;
|
||
}
|
||
} else if (data->double_index < EXAMPLE_DOUBLE_COUNT) {
|
||
size_t index = data->double_index;
|
||
while (index < EXAMPLE_DOUBLE_COUNT && asdu->object_count < request->max_objects_per_asdu) {
|
||
IEC60870_DoublePointInformation_t point;
|
||
IEC60870_AsduResult_t added;
|
||
if (IEC60870_DoublePointInformation_Create(&point, (uint32_t)(EXAMPLE_IOA_DOUBLE_BASE + index),
|
||
app->double_values[index], 0U) != IEC60870_ASDU_OK) { return -1; }
|
||
added = Example_Gi_Add_Point(asdu, &point.object);
|
||
if (added == IEC60870_ASDU_FULL) { break; }
|
||
if (added != IEC60870_ASDU_OK) { return -1; }
|
||
++index;
|
||
}
|
||
} else if (data->scaled_index < EXAMPLE_MEASUREMENT_COUNT) {
|
||
size_t index = data->scaled_index;
|
||
while (index < EXAMPLE_MEASUREMENT_COUNT && asdu->object_count < request->max_objects_per_asdu) {
|
||
ExampleMeasurementObject point;
|
||
IEC60870_AsduResult_t added;
|
||
if (Example_Create_Measurement(&point, example_measurements[index].ioa,
|
||
app->scaled_values[index], Example_Measurement_Quality(app, index)) != IEC60870_ASDU_OK) {
|
||
return -1;
|
||
}
|
||
added = Example_Gi_Add_Point(asdu, &point.object);
|
||
if (added == IEC60870_ASDU_FULL) { break; }
|
||
if (added != IEC60870_ASDU_OK) { return -1; }
|
||
++index;
|
||
}
|
||
} else if (data->parameter_index < EXAMPLE_PARAMETER_COUNT) {
|
||
const IEC104_ParameterPoint_t *point = &app->parameter_points[data->parameter_index];
|
||
const IEC104_ParameterValue_t *value = &app->parameter_values[data->parameter_index];
|
||
/* 参数每帧一个对象;不能跨类型尝试Add直到FULL,类型变化首先返回ERROR。
|
||
* 直接读取与模块确认共用的运行值,QPM只填KPA,LPC/POP为0;112有限值由应用保证。
|
||
* 本批不推进游标,WAIT后仍重组这一行;已固定的装载确认不会随这里的读值刷新。 */
|
||
if (point->type_id == IEC60870_ASDU_P_ME_NA_1) {
|
||
IEC60870_ParameterNormalizedValue_t object;
|
||
if (IEC60870_ParameterNormalizedValue_Create(&object, point->ioa, value->normalized,
|
||
point->kind) != IEC60870_ASDU_OK ||
|
||
IEC60870_Asdu_Add_InformationObject(asdu, &object.object) != IEC60870_ASDU_OK) { return -1; }
|
||
} else if (point->type_id == IEC60870_ASDU_P_ME_NB_1) {
|
||
IEC60870_ParameterScaledValue_t object;
|
||
if (IEC60870_ParameterScaledValue_Create(&object, point->ioa, value->scaled,
|
||
point->kind) != IEC60870_ASDU_OK ||
|
||
IEC60870_Asdu_Add_InformationObject(asdu, &object.object) != IEC60870_ASDU_OK) { return -1; }
|
||
} else {
|
||
IEC60870_ParameterFloatValue_t object;
|
||
if (IEC60870_ParameterFloatValue_Create(&object, point->ioa, value->short_float,
|
||
point->kind) != IEC60870_ASDU_OK ||
|
||
IEC60870_Asdu_Add_InformationObject(asdu, &object.object) != IEC60870_ASDU_OK) { return -1; }
|
||
}
|
||
} else { return 0; }
|
||
return asdu->object_count != 0U ? 1 : -1;
|
||
}
|
||
|
||
/**
|
||
* 功能:释放应用为当前取数持有的节点引用并清空游标,库的广播状态区仍独立保存协议进度。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:Complete_Data成功即可调用,让下一站复用游标;不需要等本轮所有站的FINISHED。
|
||
* 撤销时匹配的FINISHED也走此处,只归还应用额外Acquire的引用;库仍可持有原节点发送COT=9。
|
||
*/
|
||
static bool Example_End_Data(ExampleApp *app)
|
||
{
|
||
if (app->gi_station != NULL &&
|
||
IEC104_Slave_Release_Station(app->slave, app->gi_station) != IEC104_STATION_OK) { return false; }
|
||
app->gi_station = NULL;
|
||
memset(&app->gi_data, 0, sizeof(app->gi_data));
|
||
app->session_instance = app->session_request = 0U;
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:启用示例的应用协调,与SlaveConfig.startup_event_gate=1配套,须早于SystemCommand创建及首次接入。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:这里只登记策略,不操作发送器或创建模块;main还须创建SystemCommand并登记初始化COI。
|
||
* 单独暂停突发Publish无效:离线NORMAL可能已在库中,必须由发送层门禁同时约束旧缓存和IDLE。
|
||
*/
|
||
static bool Example_Init_Startup(ExampleApp *app)
|
||
{
|
||
if (app == NULL || app->slave == NULL) { return false; }
|
||
IEC104_Startup_Init(&app->startup);
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:STOP/断线/退出解除应用的站表锁和取数引用,原协议FINISHED仍由业务模块独立交付。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:仅结束本轮应用关联,不调用Release_Startup、不清NORMAL、也不取消其他模块的协议任务。
|
||
* 清掉持有的GI交互前已归还应用读取资源;后续迟到FINISHED继续按原请求清理,不能再记启动成功。
|
||
* enabled保留,使下一次实际ACTIVATED重新闭锁同步;false表示资源归还失败,应进入故障收尾。
|
||
*/
|
||
static bool Example_Startup_Reset(ExampleApp *app)
|
||
{
|
||
if (!IEC104_Startup_Reset(&app->startup, app->slave)) { return false; }
|
||
if (app->startup.enabled && !Example_End_Data(app)) { return false; }
|
||
if (app->startup.enabled) { app->business_pending = false; }
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:发送器在受理START时、继续发送之前已经关闸;这里只为收到的原ACTIVATED建立应用关联。
|
||
* 输入参数:app——示例应用上下文;event——本轮借用的协议事件。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:重复START不产生新ACTIVATED,因此不会清掉当前进度;STOP/重连后的实际激活则另有轮次。
|
||
* Lock_Stations固定本轮必须完成的CA集合,不冻结点值;放行、STOP、断线和退出均须配对归还。
|
||
*/
|
||
static bool Example_Startup_Handle_Event(ExampleApp *app, const IEC104_SlaveEvent_t *event)
|
||
{
|
||
bool reset_data, result;
|
||
result = IEC104_Startup_Handle_Event(&app->startup, app->slave, event, &reset_data);
|
||
if (reset_data) {
|
||
if (!Example_End_Data(app)) { return false; }
|
||
app->business_pending = false;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 功能:推进启动同步:Type70整轮已HANDED后才批准总召,所有站TERM也须HANDED后才开放NORMAL/IDLE。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:true包括阶段未就绪及发送WAIT,调用方继续网络/业务循环;false表示查询、身份或资源失败。
|
||
* 不等待总召ACK、不清NORMAL;新事件仍照常入队,实际选帧由发送层的独立门禁控制。
|
||
* 主站未发合格全站总召时持续等待,不因等待较久或缓存满自动放行;缓存仍执行原容量策略。
|
||
*/
|
||
static bool Example_Startup_Step(ExampleApp *app)
|
||
{
|
||
return IEC104_Startup_Process(&app->startup, app->slave, app->system_command,
|
||
&app->system_command_status);
|
||
}
|
||
|
||
/**
|
||
* 功能:第二条事件流:应用主动取业务事件,再显式应答;没有库调用应用函数的路径。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。
|
||
* 说明:常量点表立即就绪;异步数据源可在NEED_DATA保留business_event,完成采样后再Submit。
|
||
* WAIT先处理Slave通知并推进网络,下次重取数据;STALE表示交互已失效,不重试过期事件。
|
||
* 广播撤销可能使尚未BEGIN的站直接结束,应用不能按广播站数等待等量BEGIN或FINISHED。
|
||
* 只清理实际已交付的业务交互;否定ACT_CON及各站撤销确认的保存和发送均由模块负责。
|
||
*/
|
||
static bool Example_Drain_Business(ExampleApp *app)
|
||
{
|
||
unsigned count;
|
||
for (count = 0U; count < EXAMPLE_EVENT_BUDGET; ++count) {
|
||
IEC104_InterrogationEvent_t *event = &app->business_event;
|
||
IEC104_InterrogationReplyResult_t reply;
|
||
if (!app->business_pending) {
|
||
IEC104_InterrogationNextResult_t next = IEC104_Interrogation_NextEvent(app->interrogation, event);
|
||
if (next == IEC104_INTERROGATION_NEXT_EMPTY) { return true; }
|
||
if (next != IEC104_INTERROGATION_NEXT_READY) { return false; }
|
||
app->business_pending = true;
|
||
}
|
||
switch (event->type) {
|
||
case IEC104_INTERROGATION_BEGIN: {
|
||
bool accept = event->request.qualifier <= 22U;
|
||
/* 示例仅定义组1=单点及双点遥信、组2=遥测;拒绝未配置的组。协议库支持全部16组。
|
||
* 正常广播先逐站完成BEGIN准入;这里只作决定,不占用唯一取数游标。
|
||
* 某站拒绝不代表整轮结束,后续站是否继续或被主站撤销,由模块按原目标状态处理。 */
|
||
if (accept) {
|
||
/* 先登记尝试,再应答BEGIN;Reply_Begin的WAIT/STALE不会产生成功证据。
|
||
* 只有之后同一请求的COMPLETED会记录票据,所以不能在此把站标为已同步。 */
|
||
IEC104_TcpSubmitResult_t recorded = IEC104_Startup_Observe_General(
|
||
&app->startup, app->slave, event, accept);
|
||
if (recorded == IEC104_TCP_SUBMIT_WAIT) { return true; }
|
||
if (recorded != IEC104_TCP_SUBMIT_OK) { return false; }
|
||
}
|
||
reply = IEC104_Interrogation_Reply_Begin(app->interrogation, event, accept);
|
||
break;
|
||
}
|
||
case IEC104_INTERROGATION_NEED_DATA: {
|
||
/* -1构造失败、0取数结束、1有批次;WAIT重试会按当前点值重新构造,故不跨轮保存。 */
|
||
int batch_result;
|
||
/* 总召读取当前点值,无须等待独立的突发发布队列排空。 */
|
||
/* 广播逐站取数,因此首个NEED_DATA才建立游标;用注册编号取得原站,避免同CA替换串站。
|
||
* 应用单独Acquire,确保库交付FINISHED并归还自己的引用时,应用清理仍有有效节点。 */
|
||
if (event->request_id != app->session_request || event->instance_id != app->session_instance) {
|
||
if (app->session_request != 0U) { return false; }
|
||
if (event->request.station_id != 0U) {
|
||
app->gi_station = IEC104_Slave_Get_Station_By_Id(app->slave, event->request.station_id);
|
||
if (app->gi_station == NULL ||
|
||
IEC104_Slave_Acquire_Station(app->slave, app->gi_station) != IEC104_STATION_OK) { return false; }
|
||
}
|
||
memset(&app->gi_data, 0, sizeof(app->gi_data));
|
||
/* 参数只随站总召上送;分组总召和未启用参数时用末尾游标跳过整个参数分支。 */
|
||
if (app->parameter == NULL || event->request.qualifier != 20U) {
|
||
app->gi_data.parameter_index = EXAMPLE_PARAMETER_COUNT;
|
||
}
|
||
if (event->request.qualifier == 21U) { app->gi_data.scaled_index = EXAMPLE_MEASUREMENT_COUNT; }
|
||
if (event->request.qualifier == 22U) {
|
||
app->gi_data.single_index = EXAMPLE_SIGNAL_COUNT;
|
||
app->gi_data.double_index = EXAMPLE_DOUBLE_COUNT;
|
||
}
|
||
app->session_instance = event->instance_id;
|
||
app->session_request = event->request_id;
|
||
}
|
||
batch_result = Example_Build_Batch(app, &event->request);
|
||
if (batch_result < 0) { reply = IEC104_Interrogation_Fail_Request(app->interrogation, event); }
|
||
else if (batch_result == 0) { reply = IEC104_Interrogation_Complete_Data(app->interrogation, event); }
|
||
else { reply = IEC104_Interrogation_Submit_Batch(app->interrogation, event, &app->batch); }
|
||
/* 仅提交成功推进本批所属游标;遥测到末尾后必须推进参数游标,不能重复发首个参数。 */
|
||
if (reply == IEC104_INTERROGATION_REPLY_OK && batch_result > 0) {
|
||
if (app->gi_data.single_index < EXAMPLE_SIGNAL_COUNT) {
|
||
app->gi_data.single_index += app->batch.object_count;
|
||
} else if (app->gi_data.double_index < EXAMPLE_DOUBLE_COUNT) {
|
||
app->gi_data.double_index += app->batch.object_count;
|
||
} else if (app->gi_data.scaled_index < EXAMPLE_MEASUREMENT_COUNT) {
|
||
app->gi_data.scaled_index += app->batch.object_count;
|
||
} else { app->gi_data.parameter_index += app->batch.object_count; }
|
||
} else if (reply == IEC104_INTERROGATION_REPLY_OK && batch_result == 0) {
|
||
/* 其他站的数据随后才开始;无需等到所有站的ACT_TERM才复用游标。 */
|
||
if (!Example_End_Data(app)) { return false; }
|
||
}
|
||
break;
|
||
}
|
||
case IEC104_INTERROGATION_FINISHED:
|
||
/* 完成、本地取消、主站撤销、超时、断线和失败统一清理。
|
||
* 真实异步采样还需在这里停止对应任务;迟到的旧FINISHED不清理新请求资源。
|
||
* 广播各站的通知可能晚于下一站开始取数,须比较instance_id/request_id,不能仅按CA清理。
|
||
* 先前被拒绝的站仍报告原REJECTED;其他站被撤销,不会把这个原因改成DEACTIVATED。
|
||
* FINISHED只表示业务已结束,否定ACT_CON或COT=9仍可能因发送WAIT尚未交接。 */
|
||
if (event->instance_id == app->session_instance && event->request_id == app->session_request) {
|
||
if (!Example_End_Data(app)) { return false; }
|
||
}
|
||
if (event->reason == IEC104_INTERROGATION_FINISH_COMPLETED) {
|
||
/* COMPLETED只说明ACT_TERM已提交,可能还排在HIGH中;保存票据交Startup_Step等HANDED。
|
||
* WAIT保留本条FINISHED,下轮先分派Slave通知;清理读取引用可在此前独立完成。 */
|
||
IEC104_TcpSubmitResult_t recorded = IEC104_Startup_Observe_General(
|
||
&app->startup, app->slave, event, false);
|
||
if (recorded == IEC104_TCP_SUBMIT_WAIT) { return true; }
|
||
/* ERROR不计进度:同TCP旧FINISHED或已同步站后续总召都可能不匹配原BEGIN。
|
||
* 继续消费终结通知,不改用新身份重试;发送队列故障FATAL才转全局失败。 */
|
||
if (recorded == IEC104_TCP_SUBMIT_FATAL) { return false; }
|
||
}
|
||
reply = IEC104_INTERROGATION_REPLY_OK; /* 终结通知无需调用任何应答接口。 */
|
||
break;
|
||
default: return false;
|
||
}
|
||
/* WAIT保留business_event且游标不动;下轮重新Build_Batch,不重发缓存的旧点值。
|
||
* 若等待期间收到撤销,旧NEED_DATA重试会返回STALE:放弃该交互并继续读FINISHED,
|
||
* 不把STALE当成提交成功推进游标,也不在这里误清其他请求的资源。 */
|
||
if (reply == IEC104_INTERROGATION_REPLY_WAIT) { return true; }
|
||
if (reply != IEC104_INTERROGATION_REPLY_OK && reply != IEC104_INTERROGATION_REPLY_STALE) { return false; }
|
||
app->business_pending = false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [GI/STEP] 总召步进:协议推进、事件消费与状态刷新
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:两种业务各自推进协议、消费业务事件并刷新状态,供外层轮换调用次序。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。
|
||
* 说明:总召FINISHED即使已读完,模块仍可能欠原否定ACT_CON或逐站COT=9;不能以应用游标为空为由
|
||
* 停止调用Process,也不在这里等待ACK。最后刷新状态,让外层按发送背压决定何时继续。
|
||
*/
|
||
static bool Example_Step_General(ExampleApp *app)
|
||
{
|
||
if (!IEC104_Interrogation_Process(app->interrogation)) { return false; }
|
||
/* 继续转换期限及处理取消;初始化未完成时不领取新BEGIN,避免提前批准或占用应用游标。
|
||
* 未领取工作事件到期不会欠FINISHED;旧轮资源已在生命周期Reset中归还。 */
|
||
if (IEC104_Startup_Can_Consume_General(&app->startup) &&
|
||
!Example_Drain_Business(app)) { return false; }
|
||
return IEC104_Interrogation_Get_Status(app->interrogation, &app->gi);
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [CI/INIT] 计数量初始化:独立实例、广播状态区与模拟计数器
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:把本应用已有的UTC毫秒基准和当前单调时差换算为一次本地时间快照。
|
||
* 输入参数:app——非空示例上下文,clock_*由成功校时或system模式刷新维护。
|
||
* 输出参数:time——非空输出;采用本地标准时间、SU=0,编码时携带星期。
|
||
* 返回值:无;始终写入完整快照,不修改app,也不重新读取系统/RTC。
|
||
* 说明:未校时、单调时间早于保存的base、加法溢出或日期越界时,保持2000-01-01及IV=1;
|
||
* 占位日期只保证编码合法,不表示实际故障/冻结日期。此函数不改变电能的品质IV。
|
||
* clock_valid是基准可用标记,base_ms=0也可合法;IV=0不单独证明已获外部授时。
|
||
* 新接受的校时可以调整墙钟,已经保存的冻结时刻不会随之改写。
|
||
* 供计数量冻结和模拟时钟读取共用;两个业务的发送重试都使用各自保存的快照。
|
||
*/
|
||
static void Example_Clock_Snapshot(const ExampleApp *app, IEC60870_CP56Time2a_t *time)
|
||
{
|
||
IEC60870_WallTime_t local;
|
||
uint64_t now = IEC104_Net_Now_Ms(), utc_ms, elapsed;
|
||
/* 先提供可编码的无效日历;所有失败分支都保留该占位,不使用全零CP56日历。 */
|
||
memset(time, 0, sizeof(*time));
|
||
time->time.year = 2000U; time->time.month = 1U; time->time.day = 1U;
|
||
time->is_invalid = 1U; time->has_weekday = 1U;
|
||
if (!app->clock_valid || now < app->clock_base_ms) { return; }
|
||
elapsed = now - app->clock_base_ms;
|
||
/* 先在64位域检查加法和秒数上界,再窄化;本站UTC+8越界由日历转换继续拒绝。 */
|
||
if (app->clock_utc_ms > UINT64_MAX - elapsed) { return; }
|
||
utc_ms = app->clock_utc_ms + elapsed;
|
||
if (utc_ms / 1000U > IEC60870_TIME_MAX_SECONDS ||
|
||
!IEC60870_Time_Seconds_To_Local((uint32_t)(utc_ms / 1000U), (uint16_t)(utc_ms % 1000U), &local) ||
|
||
local.year < 2000U || local.year > 2099U) { return; }
|
||
time->time = local;
|
||
time->is_invalid = 0U;
|
||
}
|
||
|
||
/**
|
||
* 功能:计数量只在初始化、复位初始化及冻结动作中取时,组帧不改写原冻结时标。
|
||
* 输入参数:app——示例应用上下文;time——CP56日历时标回写位置。
|
||
* 输出参数:time——CP56日历时标回写位置。
|
||
* 返回值:无。
|
||
* 说明:无。
|
||
*/
|
||
static void Example_Counter_Time(const ExampleApp *app, IEC60870_CP56Time2a_t *time)
|
||
{
|
||
Example_Clock_Snapshot(app, time);
|
||
}
|
||
|
||
/**
|
||
* 功能:计数量实例可选,独立提供广播状态区;不共享总召的数组或取数游标。
|
||
* 输入参数:app——示例应用上下文;broadcast_states——调用方长期持有的广播站点工作区;broadcast_capacity——广播站点工作区容量;total_timeout_ms——整轮业务期限,单位毫秒。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:CLI仅注册一站。测试可给多个CA注册同一app,它们会指向同一组模拟计数器;
|
||
* 真实多站应用应让各站context分别拥有计数器数据,尤其不要逐站复位同一物理源。
|
||
*/
|
||
static bool Example_Init_Counters(ExampleApp *app,
|
||
IEC104_InterrogationStationState_t *broadcast_states, size_t broadcast_capacity, uint32_t total_timeout_ms)
|
||
{
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
static const int32_t initial[EXAMPLE_COUNTER_COUNT] = {0};
|
||
#else
|
||
static const int32_t initial[EXAMPLE_COUNTER_COUNT] = {120000, 345600, 7890, 0, 1, 65535, INT32_MAX, 42};
|
||
#endif
|
||
IEC104_InterrogationConfig_t config;
|
||
IEC60870_CP56Time2a_t initial_time;
|
||
size_t index;
|
||
if (app->counter != NULL) { return false; }
|
||
IEC104_Startup_Config_Default(NULL, NULL, NULL, &config, NULL);
|
||
config.broadcast_states = broadcast_states;
|
||
config.broadcast_capacity = broadcast_capacity;
|
||
config.max_objects_per_asdu = 4U;
|
||
config.total_timeout_ms = total_timeout_ms;
|
||
app->counter = IEC104_CounterInterrogation_Create(app->slave, &config);
|
||
if (app->counter == NULL) { return false; }
|
||
/* 默认206面向主站返回当前示值;CLI可在初始化完成后选择其他类型。
|
||
* 初始冻结副本供37/207演示读取;尚未建立有效时钟基准时,其时间会明确标为无效。 */
|
||
app->counter_type = IEC60870_ASDU_M_IT_NB_1;
|
||
Example_Counter_Time(app, &initial_time);
|
||
for (index = 0U; index < EXAMPLE_COUNTER_COUNT; ++index) {
|
||
app->counter_current[index] = initial[index];
|
||
app->counter_frozen[index].value = initial[index];
|
||
app->counter_frozen_time[index] = initial_time;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [CI/DATA] 计数量业务 Type101:冻结复位、读取快照与批次提交
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:同步模拟计数器动作:执行入口先验证事件,WAIT/STALE及合法TEST不调用本函数。
|
||
* 输入参数:context——调用方注册的回调上下文;request——仅在当前回调期间借用的协议请求。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:FRZ=1保存当前值,FRZ=2先保存再清当前值,FRZ=3只清当前值并保留旧冻结值和时间。
|
||
* 选中组在同一事件循环内完成,所有新冻结点共用一次时刻采样;不调用网络或重入引擎。
|
||
* BCR序号供15/37整数模式使用,206/207不发送该序号。false必须发生在修改任何点之前。
|
||
* 实际外部电表命令需要独立的执行结果和重复请求策略,不能套用此同步函数。
|
||
*/
|
||
static bool Example_Counter_Action(void *context, const IEC104_InterrogationRequest_t *request)
|
||
{
|
||
ExampleApp *app = (ExampleApp *)context;
|
||
IEC60870_CP56Time2a_t freeze_time;
|
||
size_t first, end, index;
|
||
if (app->energy != NULL || request->is_test || (request->qualifier != 1U && request->qualifier != 2U &&
|
||
request->qualifier != 5U) || request->freeze == 0U || request->freeze > 3U) { return false; }
|
||
first = request->qualifier == 2U ? 4U : 0U;
|
||
end = request->qualifier == 1U ? 4U : EXAMPLE_COUNTER_COUNT;
|
||
Example_Counter_Time(app, &freeze_time);
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
Example_Dtu_Accumulate_Energy(app, IEC104_Net_Now_Ms());
|
||
#endif
|
||
for (index = first; index < end; ++index) {
|
||
if (request->freeze != 3U) {
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
app->dtu_energy_frozen_wh[index] = app->dtu_energy_wh[index];
|
||
#endif
|
||
app->counter_frozen[index].value = app->counter_current[index];
|
||
app->counter_frozen[index].sequence_number =
|
||
(uint8_t)((app->counter_frozen[index].sequence_number + 1U) & 31U);
|
||
app->counter_frozen_time[index] = freeze_time;
|
||
}
|
||
if (request->freeze >= 2U) {
|
||
app->counter_current[index] = 0;
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
app->dtu_energy_wh[index] = 0.0;
|
||
#endif
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:释放当前读取的节点引用和快照归属;快照字节无需清零,下次读取会整体覆盖。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:Complete_Data成功或匹配的FINISHED都可收尾,冻结动作本身不占用读取游标。
|
||
*/
|
||
static bool Example_End_Counter(ExampleApp *app)
|
||
{
|
||
if (app->counter_station != NULL &&
|
||
IEC104_Slave_Release_Station(app->slave, app->counter_station) != IEC104_STATION_OK) { return false; }
|
||
app->counter_station = NULL;
|
||
app->counter_instance = app->counter_request = 0U;
|
||
app->counter_cursor = app->counter_end = 0U;
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:从本轮固定快照构造批次;206/207用连续地址SQ=1,15/37保留SQ=0。
|
||
* 输入参数:app——示例应用上下文;request——仅在当前回调期间借用的协议请求。
|
||
* 输出参数:app->batch及app->batch_bytes——由冻结快照构造的计数量批次;本函数不推进快照游标。
|
||
* 返回值:1表示已构造非空批次,0表示所选组已读完,-1表示构造失败。
|
||
* 说明:整数与浮点共用0x6401..0x6408点表;浮点单位kWh。
|
||
* 共用ASDU缓冲但不推进游标,时标取冻结快照,不在这里读取当前时钟。
|
||
* 返回1表示非空批次,0表示所选组已读完,-1表示构造失败;WAIT后仍取同一快照重组。
|
||
*/
|
||
static int Example_Build_Counter_Batch(ExampleApp *app, const IEC104_InterrogationRequest_t *request)
|
||
{
|
||
IEC60870_AsduHeader_t header;
|
||
bool floating = app->counter_type == IEC60870_ASDU_M_IT_NB_1 ||
|
||
app->counter_type == IEC60870_ASDU_M_IT_TC_1;
|
||
size_t index;
|
||
if (app->counter_cursor == app->counter_end) { return 0; }
|
||
memset(&header, 0, sizeof(header));
|
||
header.cause_of_transmission = request->data_cause;
|
||
header.common_address = request->common_address;
|
||
header.originator_address = request->originator_address;
|
||
header.is_test = request->is_test;
|
||
if (IEC60870_Asdu_Create(&app->batch, IEC104_Slave_Get_Application_Layer_Parameters(app->slave),
|
||
app->batch_bytes, sizeof(app->batch_bytes), &header, floating ? 1 : 0) != IEC60870_ASDU_OK) { return -1; }
|
||
for (index = app->counter_cursor; index < app->counter_end &&
|
||
app->batch.object_count < request->max_objects_per_asdu; ++index) {
|
||
/* 每轮只构造一种对象;Add_InformationObject会复制编码字节,批次不借用此局部联合体。 */
|
||
union {
|
||
IEC60870_IntegratedTotals_t integer;
|
||
IEC60870_IntegratedTotalsWithCP56Time2a_t integer_time;
|
||
IEC60870_IntegratedTotalsShort_t floating;
|
||
IEC60870_IntegratedTotalsShortWithCP56Time2a_t floating_time;
|
||
} point;
|
||
IEC60870_InformationObject_t *object;
|
||
IEC60870_AsduResult_t result;
|
||
uint32_t ioa = (uint32_t)(EXAMPLE_IOA_COUNTER_BASE + index);
|
||
/* 先用double把整数Wh换算为kWh,最后舍入到线上float32,避免在单位换算前先丢精度。
|
||
* 这里只映射数据无效位;BCR的序号/CY/CA不对应QDS,不可把整个BCR状态字当品质发送。 */
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
float value = app->energy_snapshot[index];
|
||
#else
|
||
float value = app->energy != NULL ? app->energy_snapshot[index] :
|
||
(float)((double)app->counter_snapshot[index].value / 1000.0);
|
||
#endif
|
||
uint8_t quality = app->energy != NULL ? app->energy_quality[index] :
|
||
(app->counter_snapshot[index].is_invalid ? 0x80U : 0U);
|
||
switch (app->counter_type) {
|
||
case IEC60870_ASDU_M_IT_NA_1:
|
||
result = IEC60870_IntegratedTotals_Create(&point.integer, ioa, &app->counter_snapshot[index]);
|
||
object = &point.integer.object; break;
|
||
case IEC60870_ASDU_M_IT_TB_1:
|
||
result = IEC60870_IntegratedTotalsWithCP56Time2a_Create(&point.integer_time, ioa,
|
||
&app->counter_snapshot[index], &app->counter_snapshot_time[index]);
|
||
object = &point.integer_time.base.object; break;
|
||
case IEC60870_ASDU_M_IT_NB_1:
|
||
result = IEC60870_IntegratedTotalsShort_Create(&point.floating, ioa, value, quality);
|
||
object = &point.floating.object; break;
|
||
case IEC60870_ASDU_M_IT_TC_1:
|
||
result = IEC60870_IntegratedTotalsShortWithCP56Time2a_Create(&point.floating_time, ioa,
|
||
value, quality, &app->counter_snapshot_time[index]);
|
||
object = &point.floating_time.base.object; break;
|
||
default: return -1;
|
||
}
|
||
if (result != IEC60870_ASDU_OK) { return -1; }
|
||
result = IEC60870_Asdu_Add_InformationObject(&app->batch, object);
|
||
if (result == IEC60870_ASDU_FULL) { break; }
|
||
if (result != IEC60870_ASDU_OK) { return -1; }
|
||
}
|
||
return app->batch.object_count != 0U ? 1 : -1;
|
||
}
|
||
|
||
/**
|
||
* 功能:首个NEED_DATA固定本轮快照:206取当前示值,其余取冻结值及原冻结时间。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。
|
||
* 说明:WAIT重建报文也使用同一份值、品质和时标。
|
||
* 模拟点值属于本应用;真实共享数据源应在其锁内取得快照后再进行网络提交。
|
||
*/
|
||
static bool Example_Drain_Counter(ExampleApp *app)
|
||
{
|
||
unsigned count;
|
||
if (app->counter == NULL) { return true; }
|
||
for (count = 0U; count < EXAMPLE_EVENT_BUDGET; ++count) {
|
||
IEC104_InterrogationEvent_t *event = &app->counter_event;
|
||
IEC104_InterrogationReplyResult_t reply;
|
||
if (!app->counter_pending) {
|
||
IEC104_InterrogationNextResult_t next = IEC104_Interrogation_NextEvent(app->counter, event);
|
||
if (next == IEC104_INTERROGATION_NEXT_EMPTY) { return true; }
|
||
if (next != IEC104_INTERROGATION_NEXT_READY) { return false; }
|
||
app->counter_pending = true;
|
||
}
|
||
switch (event->type) {
|
||
case IEC104_INTERROGATION_BEGIN: {
|
||
IEC104_Station_t *station = IEC104_Slave_Get_Station_By_Id(app->slave, event->request.station_id);
|
||
/* 浮点模式仅演示国网总请求;在BEGIN同时拒绝分组读取和分组FRZ动作,
|
||
* 避免先修改计数器,再到数据阶段才发现206/207不接受COT=38..41。 */
|
||
bool accept = IEC104_Station_Get_Context(station) == app &&
|
||
(event->request.qualifier == 5U ||
|
||
((app->counter_type == IEC60870_ASDU_M_IT_NA_1 || app->counter_type == IEC60870_ASDU_M_IT_TB_1) &&
|
||
(event->request.qualifier == 1U || event->request.qualifier == 2U)));
|
||
if (app->energy != NULL) {
|
||
accept = accept && app->counter_type == IEC60870_ASDU_M_IT_NB_1 &&
|
||
event->request.qualifier == 5U && event->request.freeze == 0U;
|
||
/* BEGIN的确认可能WAIT;按请求身份仅采一次,后续NEED_DATA不重采。 */
|
||
if (accept && (app->energy_snapshot_instance != event->instance_id ||
|
||
app->energy_snapshot_request != event->request_id)) {
|
||
if (!Example_Energy_Meter_Snapshot(app->energy_meter, IEC104_Net_Now_Ms(),
|
||
app->energy_snapshot, app->energy_quality)) { return false; }
|
||
app->energy_snapshot_instance = event->instance_id;
|
||
app->energy_snapshot_request = event->request_id;
|
||
}
|
||
}
|
||
if (accept && event->request.freeze != 0U) {
|
||
/* TEST同样走协议入口,由引擎短路action;不能先修改冻结值、序号或锁。 */
|
||
reply = IEC104_CounterInterrogation_Execute_Begin(app->counter, event, Example_Counter_Action, app);
|
||
} else {
|
||
reply = IEC104_Interrogation_Reply_Begin(app->counter, event,
|
||
accept && event->request.freeze == 0U);
|
||
}
|
||
break;
|
||
}
|
||
case IEC104_INTERROGATION_NEED_DATA: {
|
||
int built;
|
||
/* 一个instance/request只取一次快照;后续批次和WAIT继续使用它,
|
||
* 即使当前值已变化或另有冻结动作,也不把两代数据混进同一次召唤。 */
|
||
if (event->instance_id != app->counter_instance || event->request_id != app->counter_request) {
|
||
IEC104_Station_t *station;
|
||
if (app->counter_request != 0U) { return false; }
|
||
station = IEC104_Slave_Get_Station_By_Id(app->slave, event->request.station_id);
|
||
if (station == NULL || IEC104_Station_Get_Context(station) != app ||
|
||
IEC104_Slave_Acquire_Station(app->slave, station) != IEC104_STATION_OK) { return false; }
|
||
app->counter_station = station;
|
||
if (app->energy == NULL) {
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
size_t index;
|
||
Example_Dtu_Accumulate_Energy(app, IEC104_Net_Now_Ms());
|
||
for (index = 0U; index < EXAMPLE_COUNTER_COUNT; ++index) {
|
||
double wh = app->counter_type == IEC60870_ASDU_M_IT_NB_1 ?
|
||
app->dtu_energy_wh[index] : app->dtu_energy_frozen_wh[index];
|
||
app->energy_snapshot[index] = (float)(wh / 1000.0);
|
||
}
|
||
#endif
|
||
memcpy(app->counter_snapshot, app->counter_frozen, sizeof(app->counter_snapshot));
|
||
memcpy(app->counter_snapshot_time, app->counter_frozen_time, sizeof(app->counter_snapshot_time));
|
||
}
|
||
if (app->energy == NULL && app->counter_type == IEC60870_ASDU_M_IT_NB_1) {
|
||
size_t index;
|
||
/* 206取实时Wh源;复用BCR存储槽前清除旧冻结品质/序号,实际编码仍是float+QDS。
|
||
* 当前模拟源只有有效整数值;真实设备接入时应一并采集实时品质。 */
|
||
memset(app->counter_snapshot, 0, sizeof(app->counter_snapshot));
|
||
for (index = 0U; index < EXAMPLE_COUNTER_COUNT; ++index) {
|
||
app->counter_snapshot[index].value = app->counter_current[index];
|
||
}
|
||
}
|
||
app->counter_cursor = event->request.qualifier == 2U ? 4U : 0U;
|
||
app->counter_end = event->request.qualifier == 1U ? 4U : EXAMPLE_COUNTER_COUNT;
|
||
app->counter_instance = event->instance_id;
|
||
app->counter_request = event->request_id;
|
||
}
|
||
built = Example_Build_Counter_Batch(app, &event->request);
|
||
if (built < 0) { reply = IEC104_Interrogation_Fail_Request(app->counter, event); }
|
||
else if (built == 0) { reply = IEC104_Interrogation_Complete_Data(app->counter, event); }
|
||
else { reply = IEC104_Interrogation_Submit_Batch(app->counter, event, &app->batch); }
|
||
if (reply == IEC104_INTERROGATION_REPLY_OK) {
|
||
/* 发送层接手后才推进;WAIT保持事件和游标,下一轮可从同一快照重建相同批次。 */
|
||
if (built > 0) { app->counter_cursor += app->batch.object_count; }
|
||
else if (built == 0 && !Example_End_Counter(app)) { return false; }
|
||
}
|
||
break;
|
||
}
|
||
case IEC104_INTERROGATION_FINISHED:
|
||
if (event->reason == IEC104_INTERROGATION_FINISH_COMPLETED) { ++app->counter_completed; }
|
||
if (event->instance_id == app->counter_instance && event->request_id == app->counter_request &&
|
||
!Example_End_Counter(app)) { return false; }
|
||
reply = IEC104_INTERROGATION_REPLY_OK;
|
||
break;
|
||
default: return false;
|
||
}
|
||
if (reply == IEC104_INTERROGATION_REPLY_WAIT) { return true; }
|
||
if (reply != IEC104_INTERROGATION_REPLY_OK && reply != IEC104_INTERROGATION_REPLY_STALE) { return false; }
|
||
app->counter_pending = false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [CI/STEP] 计数量步进:协议推进、事件消费与状态刷新
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:推进本轮计数量召唤处理。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。
|
||
* 说明:仅总召测试不创建计数量实例,此时直接完成本轮;已创建时采用相同推进顺序。
|
||
*/
|
||
static bool Example_Step_Counter(ExampleApp *app)
|
||
{
|
||
return app->counter == NULL || (IEC104_Interrogation_Process(app->counter) && Example_Drain_Counter(app) &&
|
||
IEC104_Interrogation_Get_Status(app->counter, &app->ci));
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [CLOCK/INIT] 校时初始化:配置复制与实例绑定
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:config可为NULL采用默认值;创建须早于消费Slave通知,实例独占自身请求和确认状态。
|
||
* 输入参数:app——示例应用上下文;config——初始化配置。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:无。
|
||
*/
|
||
static bool Example_Init_Clock(ExampleApp *app, const IEC104_ClockSynchronizationConfig_t *config)
|
||
{
|
||
IEC104_ClockSynchronizationConfig_t defaults;
|
||
if (app->clock != NULL) { return false; }
|
||
if (config == NULL) {
|
||
IEC104_ClockSynchronization_Config_Default(&defaults);
|
||
config = &defaults;
|
||
}
|
||
app->clock = IEC104_ClockSynchronization_Create(app->slave, config);
|
||
return app->clock != NULL;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [CLOCK/ACTION] Type103:时间基准、设时/读时动作与应答推进
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:system模式启动时及每60秒刷新。Clock_Read给出固定UTC+8标准日历,不能使用主站时区或SU。
|
||
* 输入参数:app——示例应用上下文;force——是否强制刷新或提交。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:无。
|
||
* 说明:读时失败、IV或换算失败立即清除基准;此处只读系统时钟,不触发设时。
|
||
* 在分派新命令前调用,已有事务仍按Command的受理时效契约推进。
|
||
*/
|
||
static void Example_Refresh_System_Clock(ExampleApp *app, bool force)
|
||
{
|
||
IEC60870_ClockValue_t value;
|
||
IEC60870_CP56Time2a_t time;
|
||
uint32_t seconds;
|
||
uint64_t now, base_ms, utc_ms;
|
||
if (!app->clock_system) { return; }
|
||
now = IEC104_Net_Now_Ms();
|
||
if (!force && now >= app->clock_refresh_ms &&
|
||
now - app->clock_refresh_ms < EXAMPLE_CLOCK_REFRESH_MS) { return; }
|
||
app->clock_refresh_ms = now;
|
||
app->clock_update_pending = false;
|
||
if (IEC60870_Clock_Read(&value) != 0 && value.is_invalid == 0U) {
|
||
base_ms = IEC104_Net_Now_Ms();
|
||
memset(&time, 0, sizeof(time));
|
||
time.time = value.time;
|
||
if (IEC60870_Time_CP56_To_Seconds(&time, IEC60870_LOCAL_UTC_OFFSET_MINUTES, &seconds)) {
|
||
utc_ms = (uint64_t)seconds * 1000U + value.time.ms;
|
||
if (app->command == NULL || IEC104_Command_Set_Time_Base(app->command, utc_ms, base_ms)) {
|
||
app->clock_utc_ms = utc_ms;
|
||
app->clock_base_ms = base_ms;
|
||
app->clock_valid = true;
|
||
if (force) {
|
||
(void)IEC104_Spontaneous_Set_Time_Base(app->spontaneous, utc_ms, base_ms, false);
|
||
}
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
app->clock_valid = false;
|
||
if (app->command != NULL) { IEC104_Command_Clear_Time_Base(app->command); }
|
||
if (force) { IEC104_Spontaneous_Clear_Time_Base(app->spontaneous); }
|
||
}
|
||
|
||
/**
|
||
* 功能:执行已授权的真实校时动作并更新示例时钟状态。
|
||
* 输入参数:context——调用方注册的回调上下文;request——仅在当前回调期间借用的协议请求。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:仅COT6真实设时会进入本回调,COT5读取及COT6 TEST均不借此产生成功校时状态。
|
||
* 执行检查已完成时区换算和滞留补偿;动作不重复补偿,也不推进网络事件循环。
|
||
* system设时失败时不置pending;执行入口的OK只表示回调返回,不单独证明设时成功。
|
||
*/
|
||
static bool Example_Clock_Action(void *context, const IEC104_ClockSynchronizationRequest_t *request)
|
||
{
|
||
ExampleApp *app = (ExampleApp *)context;
|
||
if (app->clock_system && IEC60870_Clock_Set(&request->local_time) == 0) { return false; }
|
||
app->clock_utc_ms = request->utc_ms;
|
||
app->clock_base_ms = request->base_ms;
|
||
app->clock_valid = true;
|
||
app->clock_update_pending = true;
|
||
app->clock_refresh_ms = request->base_ms;
|
||
/* 日志与协议校时共享成功事实,协议模拟复位后仍保留此持久时基。 */
|
||
if (app->user_log != NULL) {
|
||
app->user_log_utc_ms = request->utc_ms;
|
||
app->user_log_base_ms = request->base_ms;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:为Type103/COT5提供一次只读本地时间,READ/SET的调用顺序由校时模块维护。
|
||
* 输入参数:context——非空本应用;request——当前只读请求身份及TEST,仅在回调期间有效。
|
||
* 输出参数:time——非空、本地UTC+8标准时间、毫秒及IV;协议层补齐星期并要求SU=0。
|
||
* 返回值:true提供了快照(可以IV=1),仍须通过协议层日期/字段校验;false表示后端读时失败,
|
||
* 不改time,协议层回COT5否定。合法IV=1输出可获肯定回复,读取成功不等于时间可信。
|
||
* 说明:simulated模式用已有基准推算,无基准时给合法2000-01-01占位且IV=1;
|
||
* system模式每个新请求直接读Clock后端,不使用60秒刷新的旧缓存。
|
||
* Clock_Read返回的是本地标准日历,不再叠加UTC+8或主站配置时区;年份若不足2000,
|
||
* 虽可能是Clock后端合法日历,仍由协议层按CP56范围拒绝,不伪造当前年份。
|
||
* 此示例各逻辑站共用设备时钟,所以不按CA取不同源;TEST也可调用同一安全只读后端。
|
||
* 不调用Clock_Set,不更新clock_valid/pending或Command/Spontaneous基准;WAIT不再调用。
|
||
*/
|
||
static bool Example_Clock_Read(void *context, const IEC104_ClockSynchronizationReadRequest_t *request,
|
||
IEC60870_CP56Time2a_t *time)
|
||
{
|
||
const ExampleApp *app = (const ExampleApp *)context;
|
||
IEC60870_ClockValue_t value;
|
||
(void)request;
|
||
if (!app->clock_system) {
|
||
/* 未取得基准仍返回合法IV占位;这是读到了未同步状态,与后端调用失败分开表达。 */
|
||
Example_Clock_Snapshot(app, time);
|
||
return true;
|
||
}
|
||
/* 先在局部变量取得完整日历和品质;失败不能改变调用方输出或已有应用时基。 */
|
||
if (IEC60870_Clock_Read(&value) == 0) { return false; }
|
||
memset(time, 0, sizeof(*time));
|
||
time->time = value.time;
|
||
time->is_invalid = value.is_invalid;
|
||
time->has_weekday = 1U;
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:按同一FIFO显式执行读/设时操作,并在成功设时回调返回后发布新的业务时间基准。
|
||
* 输入参数:app——已初始化的应用;clock为空表示未启用该可选业务。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本轮推进或正常让出,不保证待回复已发送;false交主循环按故障收尾。
|
||
* 说明:每轮最多调用执行入口EXAMPLE_EVENT_BUDGET次,READ和SET共用预算,让出主循环推进其他业务。
|
||
* WAIT先交回Slave消费通知,EMPTY可能仍有REPLY等待Process提交;两者都不重放回调。
|
||
* OK也可能是读取失败或设时失败,只有设时回调置clock_update_pending才更新其他模块。
|
||
* 读取只产生回复快照,不因成功读取、IV变化或旧clock_valid恢复/刷新授时状态。
|
||
*/
|
||
static bool Example_Drain_Clock(ExampleApp *app)
|
||
{
|
||
unsigned count;
|
||
if (app->clock == NULL) { return true; }
|
||
for (count = 0U; count < EXAMPLE_EVENT_BUDGET; ++count) {
|
||
IEC104_ClockSynchronizationExecuteResult_t result =
|
||
IEC104_ClockSynchronization_Execute_Next_With_Read(app->clock,
|
||
Example_Clock_Action, Example_Clock_Read, app);
|
||
/* 不在回调内跨模块调用。READ不会置pending;确认WAIT或丢失也不撤销已成功SET的基准。
|
||
* setter失败交上层清理,不重新设时,也不能用执行返回OK或旧valid替代这个标志。 */
|
||
if (app->clock_update_pending) {
|
||
if (app->energy != NULL && !Example_Energy_Meter_Set_Epoch(app->energy_meter,
|
||
app->clock_base_ms, app->clock_utc_ms)) { return false; }
|
||
if (app->command != NULL &&
|
||
!IEC104_Command_Set_Time_Base(app->command, app->clock_utc_ms, app->clock_base_ms)) { return false; }
|
||
if (!IEC104_Spontaneous_Set_Time_Base(app->spontaneous,
|
||
app->clock_utc_ms, app->clock_base_ms, true)) { return false; }
|
||
app->clock_update_pending = false;
|
||
}
|
||
if (result == IEC104_CLOCK_SYNCHRONIZATION_EXECUTE_EMPTY ||
|
||
result == IEC104_CLOCK_SYNCHRONIZATION_EXECUTE_WAIT) { return true; }
|
||
if (result != IEC104_CLOCK_SYNCHRONIZATION_EXECUTE_OK) { return false; }
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [CLOCK/STEP] 校时步进:确认提交、动作执行与状态刷新
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:先重试旧确认,再执行本轮允许的新动作;执行结果与提交状态由末尾快照统一反映。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。
|
||
* 说明:已取样的读回复同样由Process重试;read_pending变false不表示该回复已被HIGH接手。
|
||
* 此包装不等待网络ACK,也不以其他业务是否排空作为执行条件。
|
||
*/
|
||
static bool Example_Step_Clock(ExampleApp *app)
|
||
{
|
||
return app->clock == NULL || (IEC104_ClockSynchronization_Process(app->clock) &&
|
||
Example_Drain_Clock(app) && IEC104_ClockSynchronization_Get_Status(app->clock, &app->cs));
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [COMMAND/POINTS] 遥控配置:逐点类型、直接执行与选择执行策略
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:为命令行示例创建遥控实例,与仅总召的初始化入口分开。
|
||
* 输入参数:app——非NULL,Slave句柄和站点已创建,尚未开始消费Slave通知。
|
||
* extensions——仅控制是否追加无S/E字段的51/64位串演示,不改变其他点的选择执行策略。
|
||
* 输出参数:成功后保存app->command;失败不创建可用实例。
|
||
* 返回值:true为创建成功;false为重复初始化、配置/归属错误或静态池没有空位。
|
||
* 说明:默认启用45/46/47/49及对应时标类型的32个选择执行点;extensions另启用8个51/64位串点。
|
||
* 点表归app所有,只在Create前填充,Destroy之前禁止移动app、修改或释放点表。
|
||
* 每Slave只能绑定一个Command。main在Slave_Init前创建亦可,但必须早于首条生命周期通知。
|
||
*/
|
||
static bool Example_Init_Command_Mode(ExampleApp *app, bool extensions)
|
||
{
|
||
IEC104_CommandConfig_t config;
|
||
uint16_t common_address = IEC104_Station_Get_Common_Address(&app->station);
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
IEC104_CommandPoint_t points[EXAMPLE_COMMAND_COUNT];
|
||
size_t cursor, group, index;
|
||
for (cursor = 0U; cursor < DTU_COMMAND_COUNT; ++cursor) {
|
||
IEC104_CommandPoint_t *point = &points[cursor];
|
||
bool dual = cursor >= 1U && cursor <= 16U;
|
||
point->common_address = common_address;
|
||
point->ioa = dtu_commands[cursor].ioa;
|
||
point->type_mask = dual ? IEC104_COMMAND_TYPE_BIT(46U) | IEC104_COMMAND_TYPE_BIT(59U) :
|
||
IEC104_COMMAND_TYPE_BIT(45U) | IEC104_COMMAND_TYPE_BIT(58U);
|
||
point->mode = IEC104_COMMAND_MODE_SELECT_EXECUTE;
|
||
}
|
||
for (group = 1U; group < sizeof(example_command_groups) / sizeof(example_command_groups[0]); ++group) {
|
||
for (index = 0U; index < example_command_groups[group].count; ++index) {
|
||
IEC104_CommandPoint_t *point = &points[cursor++];
|
||
point->common_address = common_address;
|
||
point->ioa = example_command_groups[group].first_ioa + (uint32_t)index;
|
||
point->type_mask = example_command_groups[group].type_mask;
|
||
point->mode = group == 3U ? IEC104_COMMAND_MODE_DIRECT : IEC104_COMMAND_MODE_SELECT_EXECUTE;
|
||
}
|
||
}
|
||
#else
|
||
/* 每行独立指定策略;默认32个带S/E点均要求选择成功后执行或撤销。
|
||
* 使用实际站点CA以保留--ca;局部表只用于初始化,Create借用app中的持久副本。 */
|
||
const IEC104_CommandPoint_t points[] = {
|
||
/* CA IOA 允许类型 执行方式 */
|
||
{common_address, EXAMPLE_IOA_COMMAND_SINGLE_BASE, IEC104_COMMAND_TYPE_BIT(45U) | IEC104_COMMAND_TYPE_BIT(58U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_SINGLE_BASE + 1U), IEC104_COMMAND_TYPE_BIT(45U) | IEC104_COMMAND_TYPE_BIT(58U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_SINGLE_BASE + 2U), IEC104_COMMAND_TYPE_BIT(45U) | IEC104_COMMAND_TYPE_BIT(58U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_SINGLE_BASE + 3U), IEC104_COMMAND_TYPE_BIT(45U) | IEC104_COMMAND_TYPE_BIT(58U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_SINGLE_BASE + 4U), IEC104_COMMAND_TYPE_BIT(45U) | IEC104_COMMAND_TYPE_BIT(58U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_SINGLE_BASE + 5U), IEC104_COMMAND_TYPE_BIT(45U) | IEC104_COMMAND_TYPE_BIT(58U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_SINGLE_BASE + 6U), IEC104_COMMAND_TYPE_BIT(45U) | IEC104_COMMAND_TYPE_BIT(58U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_SINGLE_BASE + 7U), IEC104_COMMAND_TYPE_BIT(45U) | IEC104_COMMAND_TYPE_BIT(58U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
|
||
{common_address, EXAMPLE_IOA_COMMAND_DOUBLE_BASE, IEC104_COMMAND_TYPE_BIT(46U) | IEC104_COMMAND_TYPE_BIT(59U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_DOUBLE_BASE + 1U), IEC104_COMMAND_TYPE_BIT(46U) | IEC104_COMMAND_TYPE_BIT(59U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_DOUBLE_BASE + 2U), IEC104_COMMAND_TYPE_BIT(46U) | IEC104_COMMAND_TYPE_BIT(59U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_DOUBLE_BASE + 3U), IEC104_COMMAND_TYPE_BIT(46U) | IEC104_COMMAND_TYPE_BIT(59U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_DOUBLE_BASE + 4U), IEC104_COMMAND_TYPE_BIT(46U) | IEC104_COMMAND_TYPE_BIT(59U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_DOUBLE_BASE + 5U), IEC104_COMMAND_TYPE_BIT(46U) | IEC104_COMMAND_TYPE_BIT(59U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_DOUBLE_BASE + 6U), IEC104_COMMAND_TYPE_BIT(46U) | IEC104_COMMAND_TYPE_BIT(59U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_DOUBLE_BASE + 7U), IEC104_COMMAND_TYPE_BIT(46U) | IEC104_COMMAND_TYPE_BIT(59U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
|
||
/* 升降:全部点先选择后执行;47与60共用当前位置和执行模式。
|
||
* 选择只保留操作意图,真正升降发生在EXECUTE,限位检查不能只做在选择阶段。 */
|
||
{common_address, EXAMPLE_IOA_COMMAND_STEP_BASE, IEC104_COMMAND_TYPE_BIT(47U) | IEC104_COMMAND_TYPE_BIT(60U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_STEP_BASE + 1U), IEC104_COMMAND_TYPE_BIT(47U) | IEC104_COMMAND_TYPE_BIT(60U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_STEP_BASE + 2U), IEC104_COMMAND_TYPE_BIT(47U) | IEC104_COMMAND_TYPE_BIT(60U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_STEP_BASE + 3U), IEC104_COMMAND_TYPE_BIT(47U) | IEC104_COMMAND_TYPE_BIT(60U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_STEP_BASE + 4U), IEC104_COMMAND_TYPE_BIT(47U) | IEC104_COMMAND_TYPE_BIT(60U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_STEP_BASE + 5U), IEC104_COMMAND_TYPE_BIT(47U) | IEC104_COMMAND_TYPE_BIT(60U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_STEP_BASE + 6U), IEC104_COMMAND_TYPE_BIT(47U) | IEC104_COMMAND_TYPE_BIT(60U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_STEP_BASE + 7U), IEC104_COMMAND_TYPE_BIT(47U) | IEC104_COMMAND_TYPE_BIT(60U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
|
||
{common_address, EXAMPLE_IOA_COMMAND_SETPOINT_BASE, IEC104_COMMAND_TYPE_BIT(49U) | IEC104_COMMAND_TYPE_BIT(62U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_SETPOINT_BASE + 1U), IEC104_COMMAND_TYPE_BIT(49U) | IEC104_COMMAND_TYPE_BIT(62U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_SETPOINT_BASE + 2U), IEC104_COMMAND_TYPE_BIT(49U) | IEC104_COMMAND_TYPE_BIT(62U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_SETPOINT_BASE + 3U), IEC104_COMMAND_TYPE_BIT(49U) | IEC104_COMMAND_TYPE_BIT(62U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_SETPOINT_BASE + 4U), IEC104_COMMAND_TYPE_BIT(49U) | IEC104_COMMAND_TYPE_BIT(62U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_SETPOINT_BASE + 5U), IEC104_COMMAND_TYPE_BIT(49U) | IEC104_COMMAND_TYPE_BIT(62U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_SETPOINT_BASE + 6U), IEC104_COMMAND_TYPE_BIT(49U) | IEC104_COMMAND_TYPE_BIT(62U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_SETPOINT_BASE + 7U), IEC104_COMMAND_TYPE_BIT(49U) | IEC104_COMMAND_TYPE_BIT(62U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
|
||
/* 位串:51/64的载荷没有S/E字段,所有点必须DIRECT;不能配置为先选择后执行。
|
||
* 每个IOA表示一个完整32位值,不拆成32个单点命令。 */
|
||
{common_address, EXAMPLE_IOA_COMMAND_BITSTRING_BASE, IEC104_COMMAND_TYPE_BIT(51U) | IEC104_COMMAND_TYPE_BIT(64U), IEC104_COMMAND_MODE_DIRECT},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_BITSTRING_BASE + 1U), IEC104_COMMAND_TYPE_BIT(51U) | IEC104_COMMAND_TYPE_BIT(64U), IEC104_COMMAND_MODE_DIRECT},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_BITSTRING_BASE + 2U), IEC104_COMMAND_TYPE_BIT(51U) | IEC104_COMMAND_TYPE_BIT(64U), IEC104_COMMAND_MODE_DIRECT},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_BITSTRING_BASE + 3U), IEC104_COMMAND_TYPE_BIT(51U) | IEC104_COMMAND_TYPE_BIT(64U), IEC104_COMMAND_MODE_DIRECT},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_BITSTRING_BASE + 4U), IEC104_COMMAND_TYPE_BIT(51U) | IEC104_COMMAND_TYPE_BIT(64U), IEC104_COMMAND_MODE_DIRECT},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_BITSTRING_BASE + 5U), IEC104_COMMAND_TYPE_BIT(51U) | IEC104_COMMAND_TYPE_BIT(64U), IEC104_COMMAND_MODE_DIRECT},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_BITSTRING_BASE + 6U), IEC104_COMMAND_TYPE_BIT(51U) | IEC104_COMMAND_TYPE_BIT(64U), IEC104_COMMAND_MODE_DIRECT},
|
||
{common_address, (EXAMPLE_IOA_COMMAND_BITSTRING_BASE + 7U), IEC104_COMMAND_TYPE_BIT(51U) | IEC104_COMMAND_TYPE_BIT(64U), IEC104_COMMAND_MODE_DIRECT}
|
||
};
|
||
_Static_assert(sizeof(points) == sizeof(app->command_points), "Command point table size mismatch");
|
||
#endif
|
||
if (app->command != NULL) { return false; }
|
||
IEC104_Command_Config_Default(&config);
|
||
/* 本例对收到即过期、等待决定后过期的命令都安排否定COT49,便于主站明确结束请求。
|
||
* 保留动作前时标复查;决定期限15s不保证时标窗口10s内受理的命令始终可执行。
|
||
* 与库默认策略一致;实际设备须与主站约定迟到否定及重试的处理方式。 */
|
||
config.negative_on_expired = true;
|
||
/* 执行收尾固定:成功/失败都先Report_Result再Complete,分别产生肯定/否定TERM。
|
||
* 未报告结果即执行超时则由模块安排否定TERM,不关闭TCP,也不再等待应用Complete。
|
||
* 超时只表示命令服务未确认成功,设备结果仍未知;真实设备须自行维护忙状态,不能重做动作。 */
|
||
/* 本例按实施细则将选择有效期设为60000ms。
|
||
* 主站自动选择后紧接执行时,可在此设置config.select_timeout_ms = 10000U,
|
||
* 最终值须覆盖主站操作间隔与确认发送/通信/调度余量,并与主站约定。
|
||
* 此期限由所有选择执行点共用,匹配执行到达即可进入下一阶段,不必等满;
|
||
* 等待期间占唯一事务槽。它与time_tag_max_delay_ms的时标校验窗口独立。 */
|
||
/* 全局掩码决定Command接管哪些类型,逐点掩码再限制该IOA允许的类型,二者取交集。
|
||
* Config_Default默认全部启用,这里用赋值裁剪;只增点表而漏掉全局位仍会走44兜底。 */
|
||
config.type_mask = IEC104_COMMAND_TYPE_BIT(45U) | IEC104_COMMAND_TYPE_BIT(46U) |
|
||
IEC104_COMMAND_TYPE_BIT(47U) | IEC104_COMMAND_TYPE_BIT(49U) | IEC104_COMMAND_TYPE_BIT(51U) |
|
||
IEC104_COMMAND_TYPE_BIT(58U) | IEC104_COMMAND_TYPE_BIT(59U) | IEC104_COMMAND_TYPE_BIT(60U) |
|
||
IEC104_COMMAND_TYPE_BIT(62U) | IEC104_COMMAND_TYPE_BIT(64U);
|
||
memcpy(app->command_points, points, sizeof(points));
|
||
config.points = app->command_points;
|
||
config.point_count = sizeof(points) / sizeof(points[0]);
|
||
config.select_timeout_ms = 60000U;
|
||
if (!extensions) {
|
||
/* 位串块必须保持在点表末尾;同时裁剪类型许可和可见点数,避免只关类型却留下扩展点。
|
||
* 仅缩短Create借用的范围,不移动app内点表;重排分组时须同步检查这里的尾部裁剪。 */
|
||
config.type_mask &= (uint16_t)~(IEC104_COMMAND_TYPE_BIT(51U) | IEC104_COMMAND_TYPE_BIT(64U));
|
||
config.point_count -= EXAMPLE_BITSTRING_COUNT;
|
||
}
|
||
app->command = IEC104_Command_Create(app->slave, &config);
|
||
return app->command != NULL;
|
||
}
|
||
|
||
/**
|
||
* 功能:默认入口只注册选择执行点;CLI显式选择扩展时才调用上面的Mode入口启用51/64。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:无。
|
||
*/
|
||
static bool Example_Init_Command(ExampleApp *app)
|
||
{
|
||
return Example_Init_Command_Mode(app, false);
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [COMMAND/ACTION] 遥控与遥调:点号映射、动作结果及返回信息
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:将带时标命令类型映射为对应的基础命令类型。
|
||
* 输入参数:type——信息对象或日志类型标识。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:去除时标差异后的基础命令类型。
|
||
* 说明:58..64与45..51逐项相差13,折回基础类型仅用于应用动作及监视类型分派。
|
||
* 时标解析/时效检查由Command完成;原请求type_id和CP56仍由库保存并用于确认回显。
|
||
*/
|
||
static uint8_t Example_Command_Base_Type(uint8_t type)
|
||
{
|
||
return type >= 58U && type <= 64U ? (uint8_t)(type - 13U) : type;
|
||
}
|
||
|
||
/**
|
||
* 功能:把示例支持的遥控命令地址映射为对应运行值数组的下标。
|
||
* 输入参数:request——非NULL的已解码45/46/47/49/51或对应带时标工作请求,仅借用。
|
||
* 输出参数:index——非NULL,仅true时可用;DTU单点映射失败可能写入容量哨兵。
|
||
* 返回值:true表示当前配置点表中存在该类型命令的应用映射。
|
||
* 说明:库已按应用提供的点表校验CA/IOA/类型/模式,此处仍核对应用映射,避免动作写错运行值。
|
||
* 通用入口按8点组映射。DTU单点映射见本函数,16个开关及扩展控制按命令组表映射;
|
||
* 业务IOA与源XML参数地址不同,不能把0x98xx点表参数地址直接交给遥控。
|
||
*/
|
||
static bool Example_Command_Point(const IEC104_CommandRequest_t *request, size_t *index)
|
||
{
|
||
size_t group;
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
if (Example_Command_Base_Type(request->type_id) == 45U) {
|
||
uint32_t ioa = request->ioa == 0x6001U ? 0x0009U :
|
||
(request->ioa == 0x6012U ? 0x0018U : (request->ioa == 0x6013U ? 0x0026U : 0U));
|
||
*index = Example_Dtu_Signal_Index(ioa);
|
||
return *index < EXAMPLE_SIGNAL_COUNT;
|
||
}
|
||
#endif
|
||
for (group = 0U; group < sizeof(example_command_groups) / sizeof(example_command_groups[0]); ++group) {
|
||
uint32_t first = example_command_groups[group].first_ioa;
|
||
/* 先检查类型及下界,再做无符号差值检查,避免未知地址下溢后被当作数组下标。 */
|
||
if ((example_command_groups[group].type_mask & IEC104_COMMAND_TYPE_BIT(request->type_id)) != 0U &&
|
||
request->ioa >= first && request->ioa - first < example_command_groups[group].count) {
|
||
*index = (size_t)(request->ioa - first);
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* 功能:检查已解码命令的限定词是否属于本例实现的设备动作,仅读取request。
|
||
* 输入参数:request——非NULL,来自Command工作事件或动作回调,基础/时标类型采用相同策略。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true允许进入后续值检查;false由调用方拒绝,函数本身不应答、不改设备值。
|
||
* 说明:单/双点只模拟持续输出QU=0/3;升降QU=0约定每次执行一步,拒绝QU=1/2/3。
|
||
* 设定值只支持QL=0;位串没有限定词或S/E,库只交付直接执行。
|
||
* TEST不生成应用工作事件,不经过本检查;测试肯定只说明协议流程受理。
|
||
*/
|
||
static bool Example_Command_Qualifier_Allowed(const IEC104_CommandRequest_t *request)
|
||
{
|
||
uint8_t type = Example_Command_Base_Type(request->type_id);
|
||
if (type == 45U || type == 46U) { return request->qualifier == 0U || request->qualifier == 3U; }
|
||
return type == 51U || ((type == 47U || type == 49U) && request->qualifier == 0U);
|
||
}
|
||
|
||
/**
|
||
* 功能:按当前设备值检查本次操作是否在示例允许范围内,不计算或写回最终值。
|
||
* 输入参数:app/request——非NULL;index——已由Example_Command_Point校验的同类运行值下标。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true为可执行;false为升降方向非法、已到该方向限位或标度设定值越限。
|
||
* 说明:升降state=1降一档、2升一档;使用当前位置检查下一步,不把state当作目标档位。
|
||
* SELECT、EXECUTE及动作入口均检查,选择成功后的位置变化不能绕过执行时限位。
|
||
* 位串使用uint32_t完整值域,无额外数值限幅;这些检查不是设备闭锁或现场保护判据。
|
||
*/
|
||
static bool Example_Command_Value_Allowed(const ExampleApp *app,
|
||
const IEC104_CommandRequest_t *request, size_t index)
|
||
{
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
/* 软压板只约束开关分合命令。 */
|
||
if (Example_Command_Base_Type(request->type_id) == 46U) {
|
||
if (app->dtu_digital[0x4AU] == 0U || app->dtu_digital[0x24U] != 0U ||
|
||
app->dtu_pulse_until[index] > IEC104_Net_Now_Ms()) { return false; }
|
||
if (index == 0U && request->state == 2U && (app->dtu_protection_output.close_blocked ||
|
||
app->dtu_digital[0x22U] != 0U || app->dtu_digital[0x23U] != 0U ||
|
||
app->dtu_digital[0x5CU] != 0U)) { return false; }
|
||
}
|
||
#endif
|
||
if (Example_Command_Base_Type(request->type_id) == 47U) {
|
||
return (request->state == 1U && app->step_values[index] > EXAMPLE_STEP_MIN) ||
|
||
(request->state == 2U && app->step_values[index] < EXAMPLE_STEP_MAX);
|
||
}
|
||
return Example_Command_Base_Type(request->type_id) != 49U ||
|
||
(request->value.scaled >= EXAMPLE_SCALED_MIN && request->value.scaled <= EXAMPLE_SCALED_MAX);
|
||
}
|
||
|
||
/**
|
||
* 功能:执行已通过Accept校验并消费的选择/执行动作,仅修改模拟设备状态。
|
||
* 输入参数:context——当前ExampleApp;request——库仅在本次回调期间借出的工作请求,不得保存指针。
|
||
* 输出参数:选择置返校标志;执行置输出标志并更新对应运行值,供返回信息和监视量读取。
|
||
* 返回值:NOT_STARTED表示动作未开始,STARTED表示已接受执行;测试构建可由EXAMPLE_COMMAND_ACTION_RESULT注入动作结果。
|
||
* 说明:STARTED表示选择生效或输出启动,不代替Report_Result。真实异步驱动应在设备完成后报告结果。
|
||
* 不在动作中发布任何上报、推进Slave或重入修改Command;库不保存本函数或context。
|
||
*/
|
||
static IEC104_CommandActionResult_t Example_Command_Action(void *context,
|
||
const IEC104_CommandRequest_t *request)
|
||
{
|
||
ExampleApp *app = (ExampleApp *)context;
|
||
size_t index;
|
||
uint8_t type = Example_Command_Base_Type(request->type_id);
|
||
/* 决定阶段先拒绝不支持的操作;动作入口再次守卫,确保任何副作用之前范围仍有效。 */
|
||
if (!Example_Command_Point(request, &index) || !Example_Command_Qualifier_Allowed(request) ||
|
||
!Example_Command_Value_Allowed(app, request, index)) {
|
||
return IEC104_COMMAND_ACTION_NOT_STARTED;
|
||
}
|
||
if (request->is_select) { app->command_selected = true; }
|
||
else {
|
||
IEC104_SpontaneousChange_t *change = &app->command_change;
|
||
app->command_output = true;
|
||
memset(change, 0, sizeof(*change));
|
||
change->common_address = request->common_address;
|
||
change->station_id = request->station_id;
|
||
change->time_kind = IEC104_SPONTANEOUS_TIME_MONOTONIC;
|
||
change->time_ms = IEC104_Net_Now_Ms();
|
||
/* 同步模拟动作的值与时刻在本回调内配对保存;COT11不借用主站命令中的时标。
|
||
* 接入异步设备时,应由实际反馈快照给出动作值及采集时刻,不能用排队或重试时刻替代。 */
|
||
Example_Monitor_Time(app, change->time_ms, &app->command_action_time);
|
||
app->command_action_called = true;
|
||
if (type == 45U) {
|
||
uint8_t state = request->state;
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
if (request->ioa == 0x6012U) { state = 0U; }
|
||
#endif
|
||
change->ioa = example_signals[index].ioa;
|
||
change->kind = IEC104_SPONTANEOUS_SINGLE;
|
||
change->value.single = state;
|
||
app->command_has_change = app->signal_values[index] != state;
|
||
#ifndef IEC104_EXAMPLE_DTU_PROFILE
|
||
app->signal_values[index] = state;
|
||
#endif
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
if (request->ioa == 0x6001U) {
|
||
app->dtu_activation = request->state != 0U;
|
||
app->dtu_activation_since = change->time_ms;
|
||
if (app->dtu_activation) { app->dtu_activation_scheduled = false; }
|
||
app->dtu_digital[2U] = app->dtu_activation;
|
||
}
|
||
if (request->ioa == 0x6013U) { app->dtu_digital[0x4AU] = state; }
|
||
/* 复归整个保护状态;仍存在的故障在后续采样重新计时。 */
|
||
if (request->ioa == 0x6012U && request->state != 0U) {
|
||
size_t source;
|
||
Dtu_Protection_Reset(&app->dtu_protection);
|
||
/* 保留上一有效采样的合闸许可,复归不绕过仍存在的闭锁条件。 */
|
||
for (source = 1U; source < DTU_PROTECTION_SIGNAL_COUNT; ++source) {
|
||
if (Dtu_Protection_Indicator_Source((uint16_t)(0x9140U + source)) ||
|
||
source == 0x4BU || source == 0x4CU) {
|
||
app->dtu_digital[source] = 0U;
|
||
}
|
||
}
|
||
app->signal_values[index] = 0U;
|
||
change->value.single = 0U;
|
||
}
|
||
Example_Dtu_Update_Digital(app, change->time_ms);
|
||
{
|
||
uint16_t source = dtu_signals[index].source_addr;
|
||
change->value.single = state ^ (dtu_setting(app, source + 0xCC0U, 0.0) != 0.0);
|
||
app->command_has_change = app->signal_values[index] != change->value.single;
|
||
app->dtu_command_due_ms = change->time_ms + (uint64_t)(dtu_setting(app, 0x802BU, 0.02) * 1000.0 + 0.5);
|
||
}
|
||
#endif
|
||
} else if (type == 46U) {
|
||
change->ioa = (uint32_t)(EXAMPLE_IOA_DOUBLE_BASE + index);
|
||
change->kind = IEC104_SPONTANEOUS_DOUBLE;
|
||
change->value.double_point = request->state;
|
||
app->command_has_change = app->double_values[index] != request->state;
|
||
app->double_values[index] = request->state;
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
app->dtu_pulse_until[index] = change->time_ms +
|
||
(uint64_t)(dtu_setting(app, request->state == 2U ? 0x802DU : 0x802CU, 0.15) * 1000.0 + 0.5);
|
||
app->dtu_command_due_ms = app->dtu_pulse_until[index];
|
||
/* 仅00开关另有分/合单点反馈;电流及P/Q在下一次field采样随分闸归零。 */
|
||
if (index == 0U) {
|
||
app->dtu_digital[0x1FU] = request->state == 2U;
|
||
app->dtu_digital[0x20U] = request->state == 1U;
|
||
if (request->state == 1U) { Dtu_Protection_Cancel_Reclose(&app->dtu_protection, change->time_ms); }
|
||
Example_Dtu_Update_Digital(app, change->time_ms);
|
||
}
|
||
#endif
|
||
} else if (type == 47U) {
|
||
/* 通过限位检查后只移动一档;同步模拟完成,change清零留下transient=false及好品质。
|
||
* 网络WAIT只重试协议应答,不得通过重调动作来推进档位。 */
|
||
change->ioa = (uint32_t)(EXAMPLE_IOA_STEP_BASE + index);
|
||
change->kind = IEC104_SPONTANEOUS_STEP;
|
||
app->step_values[index] = (int8_t)(app->step_values[index] + (request->state == 1U ? -1 : 1));
|
||
change->value.step.value = app->step_values[index];
|
||
app->command_has_change = true;
|
||
} else if (type == 51U) {
|
||
/* 整字替换而非按位OR,写0必须清掉旧位;使用无符号类型保留bit31。
|
||
* 相同值仍完成命令/返回,但has_change=false防止取消或断连后补报虚构变化。 */
|
||
change->ioa = (uint32_t)(EXAMPLE_IOA_BITSTRING_BASE + index);
|
||
change->kind = IEC104_SPONTANEOUS_BITSTRING;
|
||
change->value.bitstring = request->value.bitstring;
|
||
app->command_has_change = app->bitstring_values[index] != request->value.bitstring;
|
||
app->bitstring_values[index] = request->value.bitstring;
|
||
} else {
|
||
int16_t previous = app->scaled_values[index];
|
||
uint8_t quality = Example_Measurement_Quality(app, index);
|
||
Example_Set_Measurement(app, index, request->value.scaled);
|
||
change->ioa = example_measurements[index].ioa;
|
||
change->kind = IEC104_SPONTANEOUS_SCALED;
|
||
change->value.scaled = app->scaled_values[index];
|
||
change->quality = Example_Measurement_Quality(app, index);
|
||
app->command_has_change = previous != change->value.scaled || quality != change->quality;
|
||
}
|
||
return EXAMPLE_COMMAND_ACTION_RESULT(app);
|
||
}
|
||
return IEC104_COMMAND_ACTION_STARTED;
|
||
}
|
||
|
||
/**
|
||
* 功能:为已启动的当前EXECUTE构造一帧COT=11的模拟位置返回信息,此处只组包,不提交。
|
||
* 输入参数:app——非NULL,command_event保留当前EXECUTE身份,运行值已由动作更新。
|
||
* 输出参数:app->command_return及其固定17字节缓冲,CA/OA沿用工作请求,IOA映射到对应监视量。
|
||
* 返回值:true为Type30/31/5/7/11单对象ASDU构造成功;false为点表或编解码失败,此时不可提交该ASDU。
|
||
* 说明:TEST命令由协议层模拟且不交付应用动作,本入口只处理真实命令,TEST=0。
|
||
* 遥测使用当时的处理值和量程品质;测试确认不构造假的设备位置变化。
|
||
* 47/60返回Type5的当前档位,51/64返回Type7的完整位串;监视IOA与命令IOA分开。
|
||
* 单/双点返回使用动作时冻结的值与CP56;命令原CP56仅随确认/终止回显。
|
||
* 即使当前点值随后变化,COT11仍反馈这次动作快照;查询最新状态应走Read或总召。
|
||
* 局部信息对象由ASDU编码复制,离开函数不借用局部变量;ASDU仍借用app内固定字节缓冲。
|
||
* 成功后冻结这一帧,Submit_Return_Info的WAIT不重新组包;只有OK才可推进,避免同一变位重复上报。
|
||
*/
|
||
static bool Example_Build_Command_Return(ExampleApp *app)
|
||
{
|
||
const IEC104_CommandRequest_t *request = &app->command_event.request;
|
||
IEC60870_AsduHeader_t header;
|
||
size_t index;
|
||
uint8_t type = Example_Command_Base_Type(request->type_id);
|
||
if (!Example_Command_Point(request, &index)) { return false; }
|
||
memset(&header, 0, sizeof(header));
|
||
header.cause_of_transmission = IEC60870_ASDU_COT_RETURN_INFO_REMOTE;
|
||
header.common_address = request->common_address;
|
||
header.originator_address = request->originator_address;
|
||
if (IEC60870_Asdu_Create(&app->command_return,
|
||
IEC104_Slave_Get_Application_Layer_Parameters(app->slave), app->command_return_bytes,
|
||
sizeof(app->command_return_bytes), &header, 0) != IEC60870_ASDU_OK) { return false; }
|
||
if (type == 45U) {
|
||
IEC60870_SinglePointWithCP56Time2a_t point;
|
||
return IEC60870_SinglePointWithCP56Time2a_Create(&point, example_signals[index].ioa,
|
||
app->command_change.value.single, 0U, &app->command_action_time) == IEC60870_ASDU_OK &&
|
||
IEC60870_Asdu_Add_InformationObject(&app->command_return, &point.base.object) == IEC60870_ASDU_OK;
|
||
} else if (type == 46U) {
|
||
IEC60870_DoublePointWithCP56Time2a_t point;
|
||
return IEC60870_DoublePointWithCP56Time2a_Create(&point, (uint32_t)(EXAMPLE_IOA_DOUBLE_BASE + index),
|
||
app->command_change.value.double_point, 0U, &app->command_action_time) == IEC60870_ASDU_OK &&
|
||
IEC60870_Asdu_Add_InformationObject(&app->command_return, &point.base.object) == IEC60870_ASDU_OK;
|
||
} else if (type == 47U) {
|
||
IEC60870_StepPositionInformation_t point;
|
||
/* VTI由公共编码器按有符号7位编码;同步到位,暂态和QDS均为0。 */
|
||
return IEC60870_StepPositionInformation_Create(&point, (uint32_t)(EXAMPLE_IOA_STEP_BASE + index),
|
||
app->step_values[index], 0U, 0U) == IEC60870_ASDU_OK &&
|
||
IEC60870_Asdu_Add_InformationObject(&app->command_return, &point.object) == IEC60870_ASDU_OK;
|
||
} else if (type == 51U) {
|
||
IEC60870_BitString32_t point;
|
||
/* 公共编码器负责BSI小端字节序;监视对象比命令的4字节位串多1字节QDS。 */
|
||
return IEC60870_BitString32_Create(&point, (uint32_t)(EXAMPLE_IOA_BITSTRING_BASE + index),
|
||
app->bitstring_values[index], 0U) == IEC60870_ASDU_OK &&
|
||
IEC60870_Asdu_Add_InformationObject(&app->command_return, &point.object) == IEC60870_ASDU_OK;
|
||
} else {
|
||
ExampleMeasurementObject point;
|
||
return Example_Create_Measurement(&point, example_measurements[index].ioa,
|
||
app->scaled_values[index], Example_Measurement_Quality(app, index)) == IEC60870_ASDU_OK &&
|
||
IEC60870_Asdu_Add_InformationObject(&app->command_return, &point.object) == IEC60870_ASDU_OK;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:消费遥控业务事件、处理应用决定,并推进结果报告/返回信息/Complete的持久化步骤。
|
||
* 输入参数:app——非NULL,所属Slave通知须先按FIFO分派;command可为NULL以兼容仅总召测试。
|
||
* 输出参数:更新应用持有事件、站点引用、模拟标志和重试步骤;不替代Command_Process提交协议应答。
|
||
* 返回值:true为本轮处理完成或遇到正常WAIT/STALE;false为事件身份、引用或接口/组包错误。
|
||
* 说明:先读取业务事件再重试旧交互,使STOP、断线、撤销产生的FINISHED能先清理过期步骤。
|
||
* 一个事务可能交付SELECT后再交付EXECUTE,但只持有一个应用站点引用,最后恰好按FINISHED清理。
|
||
* FINISHED不回滚设备值;本例动作同步完成,可直接清除模拟标志并Release。真实输出未结束时,
|
||
* 应用须另存设备操作及站点引用,保持设备忙状态,不能照搬本例的立即释放。
|
||
*/
|
||
static bool Example_Drain_Command(ExampleApp *app)
|
||
{
|
||
unsigned count;
|
||
if (app->command == NULL) { return true; }
|
||
for (count = 0U; count < EXAMPLE_EVENT_BUDGET; ++count) {
|
||
IEC104_CommandEvent_t event;
|
||
IEC104_CommandNextResult_t next = IEC104_Command_NextEvent(app->command, &event);
|
||
if (next == IEC104_COMMAND_NEXT_EMPTY) { break; }
|
||
if (next != IEC104_COMMAND_NEXT_READY) { return false; }
|
||
if (event.type == IEC104_COMMAND_FINISHED) {
|
||
/* 撤销以实际交付的停用终结事件记一次;超时、断线等其他终结原因不冒充撤销操作。 */
|
||
if (event.reason == IEC104_COMMAND_FINISH_DEACTIVATED &&
|
||
!Example_History_Command(app, &event.request, IEC60870_HISTORY_CANCEL, IEC104_Net_Now_Ms())) {
|
||
return false;
|
||
}
|
||
/* 只清理当前应用持有的事务,不能让旧实例/旧事务的终结通知释放另一次输出资源。
|
||
* 执行超时的FINISHED可先于否定TERM交接,清理应用步骤后仍须继续推进Command_Process。
|
||
* 模块槽可能仍因最后应答WAIT而占用;应用读到FINISHED也不能据此强行发起新动作。 */
|
||
if (event.instance_id != app->command_instance ||
|
||
event.transaction_id != app->command_transaction) { return false; }
|
||
if (!Example_Resolve_Publication(app, event.instance_id, event.transaction_id,
|
||
event.return_info_undelivered)) { return false; }
|
||
if (event.select_effect) { app->command_selected = false; }
|
||
if (event.execute_effect) { app->command_output = false; }
|
||
if (app->command_station != NULL &&
|
||
IEC104_Slave_Release_Station(app->slave, app->command_station) != IEC104_STATION_OK) { return false; }
|
||
app->command_station = NULL;
|
||
app->command_instance = app->command_transaction = 0U;
|
||
app->command_pending = app->command_waiting = false;
|
||
app->command_step = 0U;
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
app->dtu_command_due_ms = 0U;
|
||
#endif
|
||
} else {
|
||
/* 选择与执行在业务事件首次取出时保存,后续动作/应答 WAIT 重试不再次记操作。 */
|
||
if (!Example_History_Command(app, &event.request,
|
||
event.type == IEC104_COMMAND_SELECT ? IEC60870_HISTORY_SELECT : IEC60870_HISTORY_OPER,
|
||
event.request.accepted_ms)) { return false; }
|
||
if (app->command_transaction == 0U) {
|
||
/* 先按注册编号找到原站并Acquire,再保存引用及事务身份;同CA重新注册不能替代原站。
|
||
* 模块自身的引用可能在FINISHED出队时释放,不能借它维持应用context的生命周期。 */
|
||
IEC104_Station_t *station = IEC104_Slave_Get_Station_By_Id(app->slave, event.request.station_id);
|
||
if (station == NULL || IEC104_Slave_Acquire_Station(app->slave, station) != IEC104_STATION_OK) {
|
||
return false;
|
||
}
|
||
app->command_station = station;
|
||
app->command_instance = event.instance_id;
|
||
app->command_transaction = event.transaction_id;
|
||
} else if (app->command_instance != event.instance_id ||
|
||
app->command_transaction != event.transaction_id || app->command_pending) { return false; }
|
||
/* 按值保存,不持有NextEvent局部变量的地址;匹配执行覆盖工作事件,继续保留同一站点引用。 */
|
||
app->command_event = event;
|
||
app->command_pending = true;
|
||
app->command_waiting = false;
|
||
}
|
||
}
|
||
if (app->command_pending) {
|
||
IEC104_CommandReplyResult_t reply;
|
||
size_t index;
|
||
app->command_action_called = app->command_has_change = false;
|
||
/* 库已查命令点表;应用仍核对原站context和运行值映射,不借用另一个站点的设备状态。 */
|
||
if (IEC104_Station_Get_Context(app->command_station) != app ||
|
||
!Example_Command_Point(&app->command_event.request, &index)) {
|
||
reply = IEC104_Command_Reject(app->command, &app->command_event, IEC104_COMMAND_REJECT_UNKNOWN_IOA);
|
||
} else if (!Example_Command_Qualifier_Allowed(&app->command_event.request) ||
|
||
!Example_Command_Value_Allowed(app, &app->command_event.request, index)) {
|
||
reply = IEC104_Command_Reject(app->command, &app->command_event, IEC104_COMMAND_REJECT_NEGATIVE);
|
||
} else { reply = IEC104_Command_Accept(app->command, &app->command_event, Example_Command_Action, app); }
|
||
/* Accept may finish a failed action or observe a disconnection after
|
||
* the callback. Preserve its actual side effect before inspecting state. */
|
||
if (app->command_action_called) {
|
||
ExamplePublication entry;
|
||
memset(&entry, 0, sizeof(entry));
|
||
entry.change = app->command_change;
|
||
if (app->parameter != NULL && entry.change.kind == IEC104_SPONTANEOUS_SCALED) {
|
||
entry.measurement_range = app->measurements[entry.change.ioa - EXAMPLE_IOA_MEASUREMENT_BASE].range;
|
||
}
|
||
entry.instance_id = app->command_instance;
|
||
entry.transaction_id = app->command_transaction;
|
||
entry.placeholder = true;
|
||
entry.has_change = app->command_has_change;
|
||
/* 实际发生的返回点变位在首次动作后保存;占位解锁和补报重试只处理发送,不重复落历史。 */
|
||
if (entry.has_change && !Example_History_Change(app, &entry.change)) { return false; }
|
||
if (!Example_Queue_Publication(app, &entry)) { return false; }
|
||
}
|
||
app->command_waiting = reply == IEC104_COMMAND_REPLY_WAIT;
|
||
/* WAIT未消费工作事件、未调用动作;保留身份,下轮先处理Slave通知再重试。
|
||
* STALE不再重交动作,只保留事务归属等待FINISHED;OK也仅表示事件被消费。 */
|
||
if (app->command_waiting) { return true; }
|
||
if (reply != IEC104_COMMAND_REPLY_OK && reply != IEC104_COMMAND_REPLY_STALE) { return false; }
|
||
app->command_pending = false;
|
||
if (reply == IEC104_COMMAND_REPLY_OK && app->command_event.type == IEC104_COMMAND_EXECUTE) {
|
||
IEC104_CommandTransactionInfo_t info;
|
||
/* Reject和动作NOT_STARTED/FAILED也可能返回OK,必须确认仍为EXECUTING才能报告设备结果。
|
||
* 返回信息此时可先构造;Submit_Return_Info须等肯定执行确认被接手,HIGH FIFO保持事务帧序。 */
|
||
if (IEC104_Command_Get_Transaction(app->command, &app->command_event, &info) && info.active &&
|
||
info.phase == IEC104_COMMAND_PHASE_EXECUTING) {
|
||
if (!Example_Build_Command_Return(app)) { return false; }
|
||
app->command_step = 1U;
|
||
}
|
||
}
|
||
}
|
||
/* 模拟动作已经完成,先报告结果停止执行计时;确认是否已交接不影响本次报告。
|
||
* Report_Result只记录结果:成功可先交接返校,明确失败跳过返校,两者都由Complete封口。
|
||
* 每轮至多推进三个步骤。每步仅OK后递增;返回信息OK已经固定帧序,不能因Complete等待而重发。 */
|
||
for (count = 0U; count < 3U && app->command_step != 0U; ++count) {
|
||
IEC104_CommandReplyResult_t reply;
|
||
if (app->command_step == 1U) {
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
if (app->dtu_command_due_ms > IEC104_Net_Now_Ms()) {
|
||
app->command_waiting = true;
|
||
return true;
|
||
}
|
||
app->dtu_command_due_ms = 0U;
|
||
#endif
|
||
IEC104_CommandResult_t device_result = EXAMPLE_COMMAND_DEVICE_RESULT(app);
|
||
reply = IEC104_Command_Report_Result(app->command, &app->command_event, device_result);
|
||
if (reply == IEC104_COMMAND_REPLY_OK && device_result == IEC104_COMMAND_RESULT_FAILED) {
|
||
app->command_step = 3U;
|
||
continue; /* 已知失败仍须Complete,随后等待否定TERM交接及FINISHED。 */
|
||
}
|
||
} else if (app->command_step == 2U) {
|
||
reply = IEC104_Command_Submit_Return_Info(app->command, &app->command_event, &app->command_return);
|
||
if (reply == IEC104_COMMAND_REPLY_OK) {
|
||
if (!Example_Accept_Publication(app)) { return false; }
|
||
}
|
||
} else { reply = IEC104_Command_Complete(app->command, &app->command_event); }
|
||
app->command_waiting = reply == IEC104_COMMAND_REPLY_WAIT;
|
||
/* WAIT保持当前步骤及完整ASDU;STALE停止后续提交,引用与模拟标志交给FINISHED统一清理。
|
||
* Complete的OK只关闭返回信息阶段,ACT_TERM交接及FINISHED仍由后续Process/NextEvent推进。 */
|
||
if (app->command_waiting) { return true; }
|
||
if (reply == IEC104_COMMAND_REPLY_STALE) {
|
||
app->command_step = 0U;
|
||
return true;
|
||
}
|
||
if (reply != IEC104_COMMAND_REPLY_OK) { return false; }
|
||
app->command_step = app->command_step == 3U ? 0U : app->command_step + 1U;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [READ/LOOKUP] 读命令 Type102:同步查点与有界执行
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:按受理时station_id找到原节点,读取总召/遥控共用的模拟运行值并Add一个对象。
|
||
* 输入参数:context为本ExampleApp;request/response均由Read借出,仅本次调用有效。
|
||
* 输出参数:response——单对象读取应答缓冲。
|
||
* 返回值:FOUND表示对象已加入应答,UNKNOWN表示地址不在示例点表内,ERROR表示身份、品质准备或编码失败。
|
||
* 说明:无。
|
||
*/
|
||
static IEC104_ReadLookupResult_t Example_Read_Point(void *context,
|
||
const IEC104_ReadRequest_t *request, IEC60870_Asdu_t *response)
|
||
{
|
||
ExampleApp *app = context;
|
||
IEC104_Station_t *station = IEC104_Slave_Get_Station_By_Id(app->slave, request->station_id);
|
||
size_t index;
|
||
IEC60870_CP56Time2a_t sampled_time;
|
||
if (IEC104_Station_Get_Context(station) != app) { return IEC104_READ_LOOKUP_ERROR; }
|
||
Example_Monitor_Time(app, IEC104_Net_Now_Ms(), &sampled_time);
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
/* 源地址诊断别名让全部41倍率和93取反都可观察;不补造XML三遥映射。 */
|
||
if (Dtu_Measurement_Source_Valid(request->ioa)) {
|
||
IEC60870_MeasuredValueShort_t point;
|
||
return IEC60870_MeasuredValueShort_Create(&point, request->ioa,
|
||
(float)app->dtu_frame.primary[Dtu_Measurement_Index(request->ioa)],
|
||
app->dtu_sample_valid ? 0U : 0x80U) == IEC60870_ASDU_OK &&
|
||
IEC60870_Asdu_Add_InformationObject(response, &point.object) == IEC60870_ASDU_OK ?
|
||
IEC104_READ_LOOKUP_FOUND : IEC104_READ_LOOKUP_ERROR;
|
||
}
|
||
if ((request->ioa >= 0x9141U && request->ioa <= 0x919DU) ||
|
||
(request->ioa >= 0xB100U && request->ioa < 0xB100U + EXAMPLE_DOUBLE_COUNT)) {
|
||
IEC60870_SinglePointWithCP56Time2a_t point;
|
||
uint8_t value = request->ioa < 0xB100U ? app->dtu_digital_output[request->ioa - 0x9140U] :
|
||
app->dtu_pulse_until[request->ioa - 0xB100U] > IEC104_Net_Now_Ms();
|
||
return IEC60870_SinglePointWithCP56Time2a_Create(&point, request->ioa, value, 0U, &sampled_time) == IEC60870_ASDU_OK &&
|
||
IEC60870_Asdu_Add_InformationObject(response, &point.base.object) == IEC60870_ASDU_OK ?
|
||
IEC104_READ_LOOKUP_FOUND : IEC104_READ_LOOKUP_ERROR;
|
||
}
|
||
#endif
|
||
for (index = 0U; index < EXAMPLE_SIGNAL_COUNT; ++index) {
|
||
if (request->ioa == example_signals[index].ioa) {
|
||
IEC60870_SinglePointWithCP56Time2a_t point;
|
||
return IEC60870_SinglePointWithCP56Time2a_Create(&point, request->ioa,
|
||
app->signal_values[index], 0U, &sampled_time) == IEC60870_ASDU_OK &&
|
||
IEC60870_Asdu_Add_InformationObject(response, &point.base.object) == IEC60870_ASDU_OK ?
|
||
IEC104_READ_LOOKUP_FOUND : IEC104_READ_LOOKUP_ERROR;
|
||
}
|
||
if (index < EXAMPLE_DOUBLE_COUNT && request->ioa == EXAMPLE_IOA_DOUBLE_BASE + index) {
|
||
IEC60870_DoublePointWithCP56Time2a_t point;
|
||
return IEC60870_DoublePointWithCP56Time2a_Create(&point, request->ioa,
|
||
app->double_values[index], 0U, &sampled_time) == IEC60870_ASDU_OK &&
|
||
IEC60870_Asdu_Add_InformationObject(response, &point.base.object) == IEC60870_ASDU_OK ?
|
||
IEC104_READ_LOOKUP_FOUND : IEC104_READ_LOOKUP_ERROR;
|
||
}
|
||
}
|
||
for (index = 0U; index < EXAMPLE_STEP_COUNT; ++index) {
|
||
if (request->ioa == EXAMPLE_IOA_STEP_BASE + index) {
|
||
IEC60870_StepPositionInformation_t point;
|
||
return IEC60870_StepPositionInformation_Create(&point, request->ioa,
|
||
app->step_values[index], 0U, 0U) == IEC60870_ASDU_OK &&
|
||
IEC60870_Asdu_Add_InformationObject(response, &point.object) == IEC60870_ASDU_OK ?
|
||
IEC104_READ_LOOKUP_FOUND : IEC104_READ_LOOKUP_ERROR;
|
||
}
|
||
}
|
||
for (index = 0U; index < EXAMPLE_BITSTRING_COUNT; ++index) {
|
||
if (request->ioa == EXAMPLE_IOA_BITSTRING_BASE + index) {
|
||
IEC60870_BitString32_t point;
|
||
return IEC60870_BitString32_Create(&point, request->ioa,
|
||
app->bitstring_values[index], 0U) == IEC60870_ASDU_OK &&
|
||
IEC60870_Asdu_Add_InformationObject(response, &point.object) == IEC60870_ASDU_OK ?
|
||
IEC104_READ_LOOKUP_FOUND : IEC104_READ_LOOKUP_ERROR;
|
||
}
|
||
}
|
||
for (index = 0U; index < EXAMPLE_MEASUREMENT_COUNT; ++index) {
|
||
if (request->ioa == example_measurements[index].ioa) {
|
||
ExampleMeasurementObject point;
|
||
return Example_Create_Measurement(&point, request->ioa,
|
||
app->scaled_values[index], Example_Measurement_Quality(app, index)) == IEC60870_ASDU_OK &&
|
||
IEC60870_Asdu_Add_InformationObject(response, &point.object) == IEC60870_ASDU_OK ?
|
||
IEC104_READ_LOOKUP_FOUND : IEC104_READ_LOOKUP_ERROR;
|
||
}
|
||
}
|
||
/* 只有不在可读监视表的地址才走UNKNOWN,计数量和命令地址也在此列。
|
||
* 已知点的数据无效在上面的点分支按IV应答;无法构造应答或组包失败才返回ERROR。 */
|
||
return IEC104_READ_LOOKUP_UNKNOWN;
|
||
}
|
||
|
||
/**
|
||
* 功能:每轮读空网络通知后有界推进Read,保留其他业务的运行机会。
|
||
* Process负责已有REPLY;Execute_Next的OK只代表原READ已结束或转回复,不能当作发送成功。
|
||
* OK后再Process及时发送UNKNOWN转出的47;WAIT/EMPTY结束循环,下一轮网络推进后再试。
|
||
* 返回false交主循环清理;末尾刷新rd供Example_Wait_Time合并事件、发送背压和期限。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示指定范围的数据已完整读出;false表示范围非法、读取失败或短读。
|
||
* 说明:无。
|
||
*/
|
||
static bool Example_Step_Read(ExampleApp *app)
|
||
{
|
||
unsigned step;
|
||
if (app->read == NULL) { return true; }
|
||
if (!IEC104_Read_Process(app->read)) { return false; }
|
||
for (step = 0U; step < EXAMPLE_READ_BUDGET; ++step) {
|
||
IEC104_ReadExecuteResult_t result = IEC104_Read_Execute_Next(app->read, Example_Read_Point, app);
|
||
if (result == IEC104_READ_EXECUTE_ERROR) { return false; }
|
||
if (result != IEC104_READ_EXECUTE_OK) { break; }
|
||
if (!IEC104_Read_Process(app->read)) { return false; }
|
||
}
|
||
return IEC104_Read_Get_Status(app->read, &app->rd);
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [PARAMETER/INIT] 参数点表和运行值;独立IOA,默认扩展全部关闭
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:首次Create前,或纯内存模式协议复位已取消旧任务后,恢复运行初值;调用始终在所属事件循环。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:无。
|
||
* 说明:默认标度门限200,归一化原始655使整数差达到200时上送;平滑0,下/上限使用设定值范围。
|
||
* 这些是演示工况值,不是现场标定值;借用数组地址、点表归属和采样配置均不变。
|
||
* 同时恢复滤波和变化基准;本函数不读写配置文件,也不改扫描模块借用的周期数组与重试位图。
|
||
*/
|
||
static void Example_Reset_Parameter_Values(ExampleApp *app)
|
||
{
|
||
size_t index;
|
||
for (index = 0U; index < EXAMPLE_PARAMETER_COUNT; ++index) {
|
||
const IEC104_ParameterPoint_t *point = &app->parameter_points[index];
|
||
IEC104_ParameterValue_t *value = &app->parameter_values[index];
|
||
memset(value, 0, sizeof(*value));
|
||
if (point->kind == IEC60870_ASDU_KPA_THRESHOLD) {
|
||
if (point->type_id == IEC60870_ASDU_P_ME_NA_1) { value->normalized = EXAMPLE_THRESHOLD_NORMALIZED; }
|
||
else { value->scaled = EXAMPLE_THRESHOLD_SCALED; }
|
||
} else if (point->kind == IEC60870_ASDU_KPA_LOW_LIMIT) { value->scaled = EXAMPLE_SCALED_MIN; }
|
||
else if (point->kind == IEC60870_ASDU_KPA_HIGH_LIMIT) { value->scaled = EXAMPLE_SCALED_MAX; }
|
||
}
|
||
Example_Reset_Measurements(app);
|
||
}
|
||
|
||
/**
|
||
* 功能:每个遥测对应四行:门限0x8601..0x8608、下限0x8611..0x8618、上限0x8621..0x8628、平滑0x8631..0x8638。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:无。
|
||
* 说明:地址使用独立的十六进制分区常量,按(CA, IOA)升序;index % 8关联同一遥测,group决定参数种类。
|
||
* 门限前四行和上下限用111,门限后四行用110比例值,平滑时间常数用112秒值。
|
||
* 在Slave消费首条通知前创建;点表与运行值均借用app固定存储,默认extensions保持0。
|
||
*/
|
||
static void Example_Prepare_Parameter_Values(ExampleApp *app)
|
||
{
|
||
size_t index;
|
||
static const uint8_t kinds[4] = {IEC60870_ASDU_KPA_THRESHOLD, IEC60870_ASDU_KPA_LOW_LIMIT,
|
||
IEC60870_ASDU_KPA_HIGH_LIMIT, IEC60870_ASDU_KPA_SMOOTHING};
|
||
for (index = 0U; index < EXAMPLE_PARAMETER_COUNT; ++index) {
|
||
size_t group = index / EXAMPLE_MEASUREMENT_COUNT;
|
||
size_t measurement = index % EXAMPLE_MEASUREMENT_COUNT;
|
||
IEC104_ParameterPoint_t *point = &app->parameter_points[index];
|
||
point->common_address = IEC104_Station_Get_Common_Address(&app->station);
|
||
point->ioa = (uint32_t)(EXAMPLE_IOA_PARAMETER_BASE + group * EXAMPLE_IOA_PARAMETER_STRIDE + measurement);
|
||
point->kind = kinds[group];
|
||
point->type_id = group == 3U ? IEC60870_ASDU_P_ME_NC_1 :
|
||
(group == 0U && measurement >= 4U ? IEC60870_ASDU_P_ME_NA_1 : IEC60870_ASDU_P_ME_NB_1);
|
||
}
|
||
Example_Reset_Parameter_Values(app);
|
||
}
|
||
|
||
/**
|
||
* 功能:准备参数点表和初值,再创建借用app固定数组的标准参数模块;重复初始化返回false。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:返回true表示创建成功,调用方须让点表和运行值存储覆盖模块整个生命周期。
|
||
*/
|
||
static inline bool Example_Init_Parameter(ExampleApp *app)
|
||
{
|
||
IEC104_ParameterConfig_t config;
|
||
if (app->parameter != NULL) { return false; }
|
||
Example_Prepare_Parameter_Values(app);
|
||
IEC104_Parameter_Config_Default(&config);
|
||
config.points = app->parameter_points;
|
||
config.point_count = EXAMPLE_PARAMETER_COUNT;
|
||
config.values = app->parameter_values;
|
||
app->parameter = IEC104_Parameter_Create(app->slave, &config);
|
||
return app->parameter != NULL;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [PARAMETER/CONFIG] 应用业务校验与可选文件持久化;协议模块不直接读写存储
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:网络装载和文件恢复共用业务判据;values可指向尚未提交的整份加载候选。
|
||
* 输入参数:app——示例应用上下文;values——与点表同序的参数运行值数组;index——本次条目、点或逻辑槽的下标;value——解析结果回写位置。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:候选参数满足该点的业务值域及关联约束时返回true,否则返回false。
|
||
* 说明:调用方先检查index。恢复时以候选中的另一限值校验,不能拿默认上下限与新配置混合判断。
|
||
*/
|
||
static bool Example_Parameter_Value_Valid(const ExampleApp *app,
|
||
const IEC104_ParameterValue_t *values, size_t index, const IEC104_ParameterValue_t *value)
|
||
{
|
||
size_t measurement = index % EXAMPLE_MEASUREMENT_COUNT;
|
||
switch (app->parameter_points[index].kind) {
|
||
case IEC60870_ASDU_KPA_THRESHOLD:
|
||
return app->parameter_points[index].type_id == IEC60870_ASDU_P_ME_NA_1 ?
|
||
value->normalized >= 0 : value->scaled >= 0;
|
||
case IEC60870_ASDU_KPA_SMOOTHING:
|
||
/* 正向区间判断同时排除NaN;存储格式和协议层还各自拒绝非有限浮点。 */
|
||
return value->short_float >= 0.0f && value->short_float <= 60.0f;
|
||
case IEC60870_ASDU_KPA_LOW_LIMIT:
|
||
return value->scaled >= EXAMPLE_SCALED_MIN && value->scaled <= EXAMPLE_SCALED_MAX &&
|
||
value->scaled <= values[2U * EXAMPLE_MEASUREMENT_COUNT + measurement].scaled;
|
||
case IEC60870_ASDU_KPA_HIGH_LIMIT:
|
||
return value->scaled >= EXAMPLE_SCALED_MIN && value->scaled <= EXAMPLE_SCALED_MAX &&
|
||
value->scaled >= values[EXAMPLE_MEASUREMENT_COUNT + measurement].scaled;
|
||
default: return false;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:只比较该Type使用的union成员,不能memcmp未使用字节;同值重装无需重复写盘。
|
||
* 输入参数:type——信息对象或日志类型标识;a——第一个待比较值或身份;b——第二个待比较值或身份。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:指定类型的两个参数运行值相等时返回true,否则返回false。
|
||
* 说明:无。
|
||
*/
|
||
static bool Example_Parameter_Value_Equal(uint8_t type,
|
||
const IEC104_ParameterValue_t *a, const IEC104_ParameterValue_t *b)
|
||
{
|
||
if (type == IEC60870_ASDU_P_ME_NA_1) { return a->normalized == b->normalized; }
|
||
if (type == IEC60870_ASDU_P_ME_NB_1) { return a->scaled == b->scaled; }
|
||
return a->short_float == b->short_float;
|
||
}
|
||
|
||
/**
|
||
* 功能:动作回调只登记保存需求,不做文件I/O;连续装载在首次修改后的500ms窗口内合并。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:无。
|
||
* 说明:失败退避期间的新修改继续合入最新运行值,既不清失败状态,也不把退避无限顺延。
|
||
*/
|
||
static void Example_Config_Changed(ExampleApp *app)
|
||
{
|
||
if (app->config_path == NULL || app->config_dirty) { return; }
|
||
app->config_dirty = true;
|
||
app->config_wait_started_ms = IEC104_Net_Now_Ms();
|
||
app->config_wait_ms = EXAMPLE_CONFIG_SAVE_MS;
|
||
}
|
||
|
||
/**
|
||
* 功能:首次创建、或纯内存模式协议重建时恢复初值;调用前须已完成预置清理。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:无。
|
||
* 说明:持久化模式重建保留定值,独立映像记录example_image也不在此复位。
|
||
*/
|
||
static void Example_Reset_Remote_Values(ExampleApp *app);
|
||
/**
|
||
* 功能:仅复制已固化值,不保存预置候选、连接身份或只读映像信息。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:已固化远程定值的完整值副本。
|
||
* 说明:无。
|
||
*/
|
||
static ExampleRemoteConfig Example_Remote_Config_Snapshot(const ExampleApp *app);
|
||
/**
|
||
* 功能:将已校验的远程参数配置复制到运行区;包含当前区号、全局死区和五套区值。
|
||
* 输入参数:app——示例应用上下文;saved——已经校验的配置快照。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:无。
|
||
* 说明:本函数只应用内存值,持久化、预置清理和生效通知由调用方编排。
|
||
*/
|
||
static void Example_Remote_Config_Apply(ExampleApp *app, const ExampleRemoteConfig *saved);
|
||
/**
|
||
* 功能:打印本次远程参数操作目标及当前实际选用的运行定值。
|
||
* 输入参数:app——示例应用上下文;reason——状态输出中的原因文字;target_area——本次操作的目标区号。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:无。
|
||
* 说明:target_area是本次操作的目标,current_area是当前实际选用的设置。
|
||
* 固化非当前区时两者可以不同;输出仍显示当前区的值,便于观察“保存”和“选用”的区别。
|
||
* 只在初始化/成功变更/复位/退出展示,PRESET、撤销及TEST不发布配置变更。
|
||
*/
|
||
static void Example_Remote_Report_Settings(const ExampleApp *app, const char *reason, uint16_t target_area);
|
||
|
||
/**
|
||
* 功能:快照借用已提交区;只有当前提交者的候选覆盖对应领域,不包含远程预置或文件半成品。
|
||
* 输入参数:app——示例应用上下文;remote——可选远程定值提交候选;temp——已提交或待提交的TEMP快照。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:沿用Example_Config_Save结果:OK表示保存成功,INVALID表示候选非法,IO_ERROR表示文件操作失败。
|
||
* 说明:所有业务共用同一原子替换入口,成功同时落盘最新标准参数,因此可清除其dirty/退避状态。
|
||
*/
|
||
static ExampleConfigResult Example_Config_Store(ExampleApp *app,
|
||
const ExampleRemoteConfig *remote, const ExampleTempConfig *temp)
|
||
{
|
||
ExamplePersistentConfig saved = {0};
|
||
ExampleConfigResult result;
|
||
saved.remote = remote != NULL ? *remote : Example_Remote_Config_Snapshot(app);
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
/* 同步借用提交候选或已固化区;其他业务保存不能夹带dtu_stage预置值。 */
|
||
saved.dtu = app->dtu_config_candidate != NULL ? app->dtu_config_candidate : &app->dtu_settings;
|
||
saved.remote.current_area = saved.dtu->current_area;
|
||
#endif
|
||
saved.temp.present = app->files.present;
|
||
saved.temp.name = app->files.file_name;
|
||
saved.temp.name_length = app->files.file_name_length;
|
||
saved.temp.bytes = app->files.file_bytes;
|
||
saved.temp.size = app->files.file_size;
|
||
saved.temp.time = app->files.file_time;
|
||
if (temp != NULL) { saved.temp = *temp; }
|
||
result = Example_Config_Save(app->config_path, app->parameter_points,
|
||
app->parameter_values, EXAMPLE_PARAMETER_COUNT, &saved);
|
||
if (result == EXAMPLE_CONFIG_OK) { app->config_dirty = app->config_failed = false; }
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 功能:标准参数的延迟保存由应用主循环执行,不在其协议动作回调或信号处理器中执行。
|
||
* 输入参数:app——示例应用上下文;force——是否强制刷新或提交。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:肯定确认只承诺运行参数已生效;写盘失败不回滚运行值,保留dirty并按5秒重试。
|
||
* force用于正常退出,跳过合并和退避;返回false表示本次实际保存失败。
|
||
* 文件系统I/O仍可能阻塞,当前Windows演示没有独立存储线程或实时耗时保证。
|
||
*/
|
||
static inline bool Example_Config_Flush(ExampleApp *app, bool force)
|
||
{
|
||
ExampleConfigResult result;
|
||
uint64_t now;
|
||
if (app->config_path == NULL || !app->config_dirty) { return true; }
|
||
now = IEC104_Net_Now_Ms();
|
||
if (!force && now >= app->config_wait_started_ms &&
|
||
now - app->config_wait_started_ms < app->config_wait_ms) { return true; }
|
||
result = Example_Config_Store(app, NULL, NULL);
|
||
if (result != EXAMPLE_CONFIG_OK) {
|
||
if (!app->config_failed) {
|
||
fprintf(stderr, "CONFIG save failed: %s; retry in 5000ms\n", Example_Config_Result_Name(result));
|
||
}
|
||
app->config_failed = true;
|
||
app->config_wait_started_ms = IEC104_Net_Now_Ms();
|
||
app->config_wait_ms = EXAMPLE_CONFIG_RETRY_MS;
|
||
return false;
|
||
}
|
||
app->config_dirty = app->config_failed = false;
|
||
puts("CONFIG SAVED"); fflush(stdout);
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:监听前完整验证三个领域,包括未启用的协议模块,防止下一次保存丢掉其数据。
|
||
* 输入参数:app——示例应用上下文;path——NUL结尾的宿主文件路径。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示请求的资源或存储实例已准备就绪;false表示输入校验、资源获取或恢复失败。
|
||
* 说明:复用文件接收暂存区加载TEMP,不额外分配大缓冲。旧格式全部校验后才原子迁移。
|
||
* 只有所有旧档都不存在才创建默认档;非法或不可读的文件不覆盖,父目录须已存在。
|
||
*/
|
||
static inline bool Example_Config_Open(ExampleApp *app, const char *path)
|
||
{
|
||
IEC104_ParameterValue_t loaded[EXAMPLE_PARAMETER_COUNT];
|
||
ExamplePersistentConfig saved = {0};
|
||
ExampleConfigResult result;
|
||
bool created;
|
||
size_t index;
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
DtuSettings loaded_dtu;
|
||
#endif
|
||
if (path == NULL) { return true; }
|
||
if (app->parameter == NULL) { Example_Prepare_Parameter_Values(app); }
|
||
if (app->remote_parameter == NULL) { Example_Reset_Remote_Values(app); }
|
||
memcpy(loaded, app->parameter_values, sizeof(loaded));
|
||
saved.remote = Example_Remote_Config_Snapshot(app);
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
loaded_dtu = app->dtu_settings;
|
||
saved.dtu = &loaded_dtu;
|
||
#endif
|
||
saved.temp.name = app->files.stage_name;
|
||
saved.temp.bytes = app->files.stage_bytes;
|
||
result = Example_Config_Load(path, app->parameter_points, loaded, EXAMPLE_PARAMETER_COUNT, &saved);
|
||
created = result == EXAMPLE_CONFIG_NOT_FOUND;
|
||
if (result != EXAMPLE_CONFIG_OK && !created) {
|
||
fprintf(stderr, "CONFIG load failed: %s\n", Example_Config_Result_Name(result));
|
||
return false;
|
||
}
|
||
for (index = 0U; index < EXAMPLE_PARAMETER_COUNT; ++index) {
|
||
if (!Example_Parameter_Value_Valid(app, loaded, index, &loaded[index])) {
|
||
fputs("CONFIG invalid parameter values\n", stderr); return false;
|
||
}
|
||
}
|
||
if (created || saved.legacy) {
|
||
result = Example_Config_Save(path, app->parameter_points, loaded, EXAMPLE_PARAMETER_COUNT, &saved);
|
||
if (result != EXAMPLE_CONFIG_OK) {
|
||
fprintf(stderr, "CONFIG %s failed: %s\n", created ? "create" : "migration",
|
||
Example_Config_Result_Name(result));
|
||
return false;
|
||
}
|
||
}
|
||
memcpy(app->parameter_values, loaded, sizeof(loaded));
|
||
Example_Reset_Measurements(app);
|
||
Example_Remote_Config_Apply(app, &saved.remote);
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
app->dtu_settings = loaded_dtu;
|
||
app->remote_area = loaded_dtu.current_area;
|
||
#endif
|
||
app->files.present = saved.temp.present;
|
||
if (saved.temp.present) {
|
||
memcpy(app->files.file_name, saved.temp.name, saved.temp.name_length);
|
||
memcpy(app->files.file_bytes, saved.temp.bytes, saved.temp.size);
|
||
app->files.file_name_length = saved.temp.name_length;
|
||
app->files.file_size = saved.temp.size;
|
||
app->files.file_time = saved.temp.time;
|
||
}
|
||
app->config_path = path;
|
||
puts(created ? "CONFIG CREATED" : saved.legacy ? "CONFIG MIGRATED" : "CONFIG LOADED");
|
||
if (app->remote_parameter != NULL) {
|
||
puts("REMOTE_CONFIG LOADED");
|
||
Example_Remote_Report_Settings(app, "load", app->remote_area);
|
||
}
|
||
if (app->file_service != NULL && saved.temp.present) { puts("FILE_CONFIG LOADED"); }
|
||
fflush(stdout);
|
||
return true;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [PARAMETER/ACTION] 装载后更新测量处理;门限只抑制普通变化上送
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:短时同步动作:LOAD通过业务校验后更新运行值,再返回APPLIED供模块形成带值确认。
|
||
* 输入参数:context——调用方注册的回调上下文;request——仅在当前回调期间借用的协议请求。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:APPLIED表示动作已完成,UNKNOWN_IOA表示请求点或周期目标不支持,REJECTED表示身份、动作或业务校验拒绝。
|
||
* 说明:模块已检查地址、类型、KPA和有限浮点;本函数补业务范围与上下限之间的约束。
|
||
* 110..112合法TEST由模块直接确认,不调用此动作;113 TEST会进入,只检查周期配置。
|
||
* 本例未实现ACK扩展的预留和收尾,因此仅接受EXECUTE,不能直接打开扩展位沿用此动作。
|
||
*/
|
||
static IEC104_ParameterActionResult_t Example_Parameter_Action(void *context,
|
||
const IEC104_ParameterRequest_t *request)
|
||
{
|
||
ExampleApp *app = context;
|
||
IEC104_Station_t *station = IEC104_Slave_Get_Station_By_Id(app->slave, request->station_id);
|
||
/* 使用受理时的站点身份,不把同CA重注册后的站点当作原请求对象。 */
|
||
if (station != &app->station || !IEC104_Station_Is_Registered(station) ||
|
||
request->phase != IEC104_PARAMETER_PHASE_EXECUTE) { return IEC104_PARAMETER_ACTION_REJECTED; }
|
||
if (request->operation == IEC104_PARAMETER_OP_LOAD) {
|
||
size_t measurement = request->point_index % EXAMPLE_MEASUREMENT_COUNT;
|
||
bool changed;
|
||
IEC104_ParameterValue_t before;
|
||
if (request->point_index >= EXAMPLE_PARAMETER_COUNT) { return IEC104_PARAMETER_ACTION_REJECTED; }
|
||
/* 与另一限值的当前运行值比较:上移区间先装上限,下移区间先装下限。
|
||
* 拒绝路径不改数组,模块随后回报仍在运行的旧值。 */
|
||
if (!Example_Parameter_Value_Valid(app, app->parameter_values, request->point_index, &request->value)) {
|
||
return IEC104_PARAMETER_ACTION_REJECTED;
|
||
}
|
||
changed = !Example_Parameter_Value_Equal(request->type_id,
|
||
&app->parameter_values[request->point_index], &request->value);
|
||
before = app->parameter_values[request->point_index];
|
||
/* 先按旧配置积分到动作时刻,再切换配置并重估品质/直通值;TEST不会到达此路径。
|
||
* 回复、总召读取同一运行配置;变化发布留给主循环,动作不调用网络发送。 */
|
||
{
|
||
uint64_t now = IEC104_Net_Now_Ms();
|
||
Example_Update_Measurement(app, measurement, now);
|
||
app->parameter_values[request->point_index] = request->value;
|
||
Example_Update_Measurement(app, measurement, now);
|
||
}
|
||
if (changed) {
|
||
Example_Config_Changed(app);
|
||
/* 10记运行值已经生效;INI的延迟保存尚未完成,不能在这里宣称配置文件已保存。
|
||
* 协议随后重试固定确认,不会再调用本动作;日志失败也保持本次APPLIED事实。 */
|
||
Example_User_Log_Parameter(app, "STANDARD", request->ioa, 0U,
|
||
request->type_id == 112U ? (double)before.short_float :
|
||
request->type_id == 111U ? (double)before.scaled : (double)before.normalized,
|
||
request->type_id == 112U ? (double)request->value.short_float :
|
||
request->type_id == 111U ? (double)request->value.scaled : (double)request->value.normalized);
|
||
}
|
||
return IEC104_PARAMETER_ACTION_APPLIED;
|
||
}
|
||
if (request->qpa == IEC60870_ASDU_QPA_CYCLIC_TRANSMISSION) {
|
||
IEC104_PeriodicScanGroupStatus_t group;
|
||
size_t index;
|
||
uint32_t period;
|
||
/* QPA=3寻址扫描的测量对象,不查参数点表;仅组0(COT=1)成员可以被启停。 */
|
||
if (app->periodic_scan == NULL) { return IEC104_PARAMETER_ACTION_UNKNOWN_IOA; }
|
||
for (index = 0U; index < EXAMPLE_SCAN_POINT_COUNT; ++index) {
|
||
const IEC104_PeriodicScanPoint_t *point = &app->scan_points[index];
|
||
if (point->common_address == request->common_address && point->ioa == request->ioa &&
|
||
(point->groups & 1U) != 0U) { break; }
|
||
}
|
||
if (index == EXAMPLE_SCAN_POINT_COUNT) { return IEC104_PARAMETER_ACTION_UNKNOWN_IOA; }
|
||
/* 有该周期对象但使用组周期模式时回否定,不能用停整组替代寻址点的停止激活。 */
|
||
if (!IEC104_PeriodicScan_Get_Group_Status(app->periodic_scan, 0U, &group) || !group.point_period) {
|
||
return IEC104_PARAMETER_ACTION_REJECTED;
|
||
}
|
||
/* 停止写0但保留另存的恢复周期;激活还要确认组未停用且周期是组刻度的正整数倍。
|
||
* 只改COT=1的点级周期,同一测量对象所属的COT=2背景组仍可继续上送。 */
|
||
period = request->operation == IEC104_PARAMETER_OP_DEACTIVATE ? 0U : app->parameter_cyclic_ms;
|
||
if (request->operation == IEC104_PARAMETER_OP_ACTIVATE &&
|
||
(period == 0U || group.period_ms == 0U || period % group.period_ms != 0U)) {
|
||
return IEC104_PARAMETER_ACTION_REJECTED;
|
||
}
|
||
/* TEST只检查,与真实请求共享判据,短路求值保证绝不调用setter。
|
||
* 真实请求的APPLIED表示配置已启停;不承诺数据送达,也不替代扫描故障后的Resume。 */
|
||
if (!request->test) {
|
||
uint32_t before = app->point_period_ms[index];
|
||
if (!IEC104_PeriodicScan_Set_Point_Period(app->periodic_scan, index, period)) {
|
||
return IEC104_PARAMETER_ACTION_REJECTED;
|
||
}
|
||
Example_User_Log_Parameter(app, "CYCLIC_MS", request->ioa, 0U, (double)before, (double)period);
|
||
}
|
||
return IEC104_PARAMETER_ACTION_APPLIED;
|
||
}
|
||
return IEC104_PARAMETER_ACTION_REJECTED;
|
||
}
|
||
|
||
/**
|
||
* 功能:读空Slave通知后每轮至多交付一次动作:前后Process分别处理期限/旧确认与本次新确认。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。
|
||
* 说明:WAIT要求先继续分派通知,EMPTY表示当前没有可执行动作;二者都正常让出本轮。
|
||
* 即使need_process为false仍要调用Process,以观察状态变化和重试发送背压。
|
||
*/
|
||
static bool Example_Step_Parameter(ExampleApp *app)
|
||
{
|
||
IEC104_ParameterExecuteResult_t result;
|
||
if (app->parameter == NULL) { return true; }
|
||
if (!IEC104_Parameter_Process(app->parameter)) { return false; }
|
||
result = IEC104_Parameter_Execute_Next(app->parameter, Example_Parameter_Action, app);
|
||
return result != IEC104_PARAMETER_EXECUTE_ERROR && IEC104_Parameter_Process(app->parameter) &&
|
||
IEC104_Parameter_Get_Status(app->parameter, &app->parameter_status);
|
||
}
|
||
|
||
/* [REMOTE_PARAMETER] 应用归属、整批暂存与运行值。
|
||
* 七个地址按设计示例排列;权限、值域和五个定值区属于本示例配置,不能推作设备能力。
|
||
* 固有/运行参数位于前五行,分区动作定值位于末两行;读全部借用该固定顺序。 */
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
#include "iec104_dtu_settings.inc"
|
||
#else
|
||
static const uint32_t example_remote_ioas[] = {
|
||
0x8001U, 0x8003U, 0x8005U, 0x8006U, 0x8020U, 0x8221U, 0x8224U
|
||
};
|
||
|
||
/**
|
||
* 功能:当前区只选择一套已固化的动作定值;不分区死区由所有区共享。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:当前选中区及其运行定值的值副本。
|
||
* 说明:调用方与动作回调在同一事件循环取值,不读取PRESET候选,也不改变任何配置。
|
||
* remote_area仅由初始化和校验后的SWITCH_AREA写入,始终在0–4内。
|
||
*/
|
||
static ExampleRemoteSettings Example_Remote_Current_Settings(const ExampleApp *app)
|
||
{
|
||
ExampleRemoteSettings settings;
|
||
settings.area = app->remote_area;
|
||
settings.reset_seconds = app->remote_reset_seconds[settings.area];
|
||
settings.x_time = app->remote_x_time[settings.area];
|
||
settings.deadband = app->remote_deadband;
|
||
return settings;
|
||
}
|
||
|
||
/**
|
||
* 功能:打印本次远程参数操作目标及当前实际选用的运行定值。
|
||
* 输入参数:app——示例应用上下文;reason——状态输出中的原因文字;target_area——本次操作的目标区号。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:无。
|
||
* 说明:target_area是本次操作的目标,current_area是当前实际选用的设置。
|
||
* 固化非当前区时两者可以不同;输出仍显示当前区的值,便于观察“保存”和“选用”的区别。
|
||
* 只在初始化/成功变更/复位/退出展示,PRESET、撤销及TEST不发布配置变更。
|
||
*/
|
||
static void Example_Remote_Report_Settings(const ExampleApp *app, const char *reason, uint16_t target_area)
|
||
{
|
||
ExampleRemoteSettings settings = Example_Remote_Current_Settings(app);
|
||
printf("REMOTE_SETTINGS reason=%s target_area=%u current_area=%u reset_seconds=%u x_time=%.9g deadband=%.9g\n",
|
||
reason, (unsigned)target_area, (unsigned)settings.area, (unsigned)settings.reset_seconds,
|
||
(double)settings.x_time, (double)settings.deadband);
|
||
fflush(stdout); /* 管道运行时也即时显示切区/固化结果,不等进程退出。 */
|
||
}
|
||
|
||
/**
|
||
* 功能:首次创建、或纯内存模式协议重建时恢复初值;调用前须已完成预置清理。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:无。
|
||
* 说明:持久化模式重建保留定值,独立映像记录example_image也不在此复位。
|
||
*/
|
||
static void Example_Reset_Remote_Values(ExampleApp *app)
|
||
{
|
||
/* 不同初值便于主站观察五套配置;这些是演示值,不是规约规定的默认定值。 */
|
||
static const uint16_t reset_seconds[5] = {30U, 60U, 90U, 120U, 150U};
|
||
static const float x_time[5] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f};
|
||
app->remote_area = 0U;
|
||
app->remote_deadband = 0.0f;
|
||
memcpy(app->remote_reset_seconds, reset_seconds, sizeof(app->remote_reset_seconds));
|
||
memcpy(app->remote_x_time, x_time, sizeof(app->remote_x_time));
|
||
memset(&app->remote_stage, 0, sizeof(app->remote_stage));
|
||
}
|
||
|
||
/**
|
||
* 功能:仅复制已固化值,不保存预置候选、连接身份或只读映像信息。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:已固化远程定值的完整值副本。
|
||
* 说明:无。
|
||
*/
|
||
static ExampleRemoteConfig Example_Remote_Config_Snapshot(const ExampleApp *app)
|
||
{
|
||
ExampleRemoteConfig saved;
|
||
saved.current_area = app->remote_area;
|
||
saved.deadband = app->remote_deadband;
|
||
memcpy(saved.reset_seconds, app->remote_reset_seconds, sizeof(saved.reset_seconds));
|
||
memcpy(saved.x_time, app->remote_x_time, sizeof(saved.x_time));
|
||
return saved;
|
||
}
|
||
|
||
/**
|
||
* 功能:将已校验的远程参数配置复制到运行区;包含当前区号、全局死区和五套区值。
|
||
* 输入参数:app——示例应用上下文;saved——已经校验的配置快照。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:无。
|
||
* 说明:本函数只应用内存值,持久化、预置清理和生效通知由调用方编排。
|
||
*/
|
||
static void Example_Remote_Config_Apply(ExampleApp *app, const ExampleRemoteConfig *saved)
|
||
{
|
||
app->remote_area = saved->current_area;
|
||
app->remote_deadband = saved->deadband;
|
||
memcpy(app->remote_reset_seconds, saved->reset_seconds, sizeof(saved->reset_seconds));
|
||
memcpy(app->remote_x_time, saved->x_time, sizeof(saved->x_time));
|
||
}
|
||
|
||
/**
|
||
* 功能:Windows小文件同步提交:写盘失败不发布任何运行值,不改变原选择或其他区。
|
||
* 输入参数:app——示例应用上下文;saved——已经校验的配置快照。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:这是示例应用的持久化语义;无配置路径时保持原有RAM模式。
|
||
*/
|
||
static bool Example_Remote_Config_Commit(ExampleApp *app, const ExampleRemoteConfig *saved)
|
||
{
|
||
ExampleRemoteConfig before = Example_Remote_Config_Snapshot(app);
|
||
size_t index;
|
||
if (app->config_path != NULL) {
|
||
ExampleConfigResult result = Example_Config_Store(app, saved, NULL);
|
||
if (result != EXAMPLE_CONFIG_OK) {
|
||
fprintf(stderr, "REMOTE_CONFIG save failed: %s\n", Example_Config_Result_Name(result));
|
||
return false;
|
||
}
|
||
puts("REMOTE_CONFIG SAVED"); fflush(stdout);
|
||
}
|
||
Example_Remote_Config_Apply(app, saved);
|
||
/* 整份配置提交与发布完成后才写日志;失败不得回滚已生效配置或让SOLIDIFY重新执行。
|
||
* 非当前区记录已保存的参数值,scope明确其含义;切区只记选择变化,PRESET不进入这里。 */
|
||
Example_User_Log_Parameter(app, "REMOTE_AREA", 0U, saved->current_area,
|
||
(double)before.current_area, (double)saved->current_area);
|
||
Example_User_Log_Parameter(app, "REMOTE_GLOBAL", example_remote_ioas[4], 0U,
|
||
(double)before.deadband, (double)saved->deadband);
|
||
for (index = 0U; index < 5U; ++index) {
|
||
Example_User_Log_Parameter(app, "REMOTE_STORED", example_remote_ioas[5], (unsigned)index,
|
||
(double)before.reset_seconds[index], (double)saved->reset_seconds[index]);
|
||
Example_User_Log_Parameter(app, "REMOTE_STORED", example_remote_ioas[6], (unsigned)index,
|
||
(double)before.x_time[index], (double)saved->x_time[index]);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:在消费首条Slave通知前创建;本例用memcpy解码binary32,因此先检查宿主表示。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:使用模块默认类型、镜像确认和期限;实例存在期间不切换确认模式或应用上下文。
|
||
*/
|
||
static inline bool Example_Init_RemoteParameter(ExampleApp *app)
|
||
{
|
||
IEC104_RemoteParameterConfig_t config;
|
||
if (app->remote_parameter != NULL || sizeof(float) != 4U || FLT_RADIX != 2 ||
|
||
FLT_MANT_DIG != 24 || FLT_MAX_EXP != 128) { return false; }
|
||
Example_Reset_Remote_Values(app);
|
||
IEC104_RemoteParameter_Config_Default(&config);
|
||
app->remote_parameter = IEC104_RemoteParameter_Create(app->slave, &config);
|
||
if (app->remote_parameter != NULL) { Example_Remote_Report_Settings(app, "init", 0U); }
|
||
return app->remote_parameter != NULL;
|
||
}
|
||
|
||
/**
|
||
* 功能:按完整原归属查暂存,不只看CA;同CA删除重注册、重连或换实例均不能接续旧批次。
|
||
* 输入参数:stage——远程预置候选及所属身份;request——仅在当前回调期间借用的协议请求。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:预置记录与请求的所有者身份一致时返回true,否则返回false。
|
||
* 说明:此处故意不比较SN:合法CANCEL允许携带不同SN;续帧/固化另行核对SN。
|
||
*/
|
||
static bool Example_Remote_Owner(const ExampleRemoteStage *stage,
|
||
const IEC104_RemoteParameterRequest_t *request)
|
||
{
|
||
const IEC104_RemoteParameterRequest_t *owner = &stage->owner;
|
||
return stage->active && owner->identity.slave == request->identity.slave &&
|
||
owner->identity.instance_id == request->identity.instance_id &&
|
||
owner->identity.generation == request->identity.generation &&
|
||
owner->instance_id == request->instance_id && owner->generation == request->generation &&
|
||
owner->station_id == request->station_id && owner->common_address == request->common_address &&
|
||
owner->test == request->test;
|
||
}
|
||
|
||
/**
|
||
* 功能:返回固定点表下标;等于表长表示未知地址,用于区分UNKNOWN_IOA与权限/值域拒绝。
|
||
* 输入参数:ioa——信息体地址。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:IOA对应的定值项索引;未匹配时返回固定点表长度。
|
||
* 说明:无。
|
||
*/
|
||
static size_t Example_Remote_Index(uint32_t ioa)
|
||
{
|
||
size_t index;
|
||
for (index = 0U; index < sizeof(example_remote_ioas) / sizeof(example_remote_ioas[0]); ++index) {
|
||
if (example_remote_ioas[index] == ioa) { break; }
|
||
}
|
||
return index;
|
||
}
|
||
|
||
/**
|
||
* 功能:普通读写核对本例站点的注册编号及CA;旧站清理必须走暂存归属匹配,不能受此检查阻挡。
|
||
* 输入参数:app——示例应用上下文;request——仅在当前回调期间借用的协议请求。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:请求仍属于本应用登记的站点时返回true,否则返回false。
|
||
* 说明:无。
|
||
*/
|
||
static bool Example_Remote_Station(const ExampleApp *app, const IEC104_RemoteParameterRequest_t *request)
|
||
{
|
||
return request->identity.slave == app->slave &&
|
||
request->station_id == IEC104_Station_Get_Id(&app->station) &&
|
||
request->common_address == IEC104_Station_Get_Common_Address(&app->station);
|
||
}
|
||
|
||
/**
|
||
* 功能:短时同步动作,应用负责权限、区号和值域,模块已检查帧结构和Tag基本编码。
|
||
* 输入参数:context——调用方注册的回调上下文;request——仅在当前回调期间借用的协议请求;area——远程参数区域查询结果回写位置。
|
||
* 输出参数:area——远程参数区域查询结果回写位置。
|
||
* 返回值:APPLIED表示请求阶段已处理,UNKNOWN_IOA表示定值地址不支持,REJECTED表示身份、区号、状态、候选值校验拒绝或持久化失败。
|
||
* 说明:PRESET只写暂存,SOLIDIFY一次发布;失败返回前清本归属整批资源,不等待后续DISCARD。
|
||
* TEST写动作由模块模拟,不会进入这里;READ_AREA即使TEST也只读当前区号。
|
||
*/
|
||
static IEC104_RemoteParameterActionResult_t Example_Remote_Action(void *context,
|
||
const IEC104_RemoteParameterRequest_t *request, IEC104_RemoteParameterArea_t *area)
|
||
{
|
||
ExampleApp *app = context;
|
||
ExampleRemoteStage *stage = &app->remote_stage;
|
||
IEC104_RemoteParameterActionResult_t failure = IEC104_REMOTE_PARAMETER_ACTION_REJECTED;
|
||
size_t index;
|
||
/* 原站即使已被删除,仍须按完整归属清理旧暂存;先清理再检查当前注册站。
|
||
* CANCEL携带的SN不是暂存选择器,不能误清该SN下其他资源;重复清理允许无操作。 */
|
||
if (request->operation == IEC104_REMOTE_PARAMETER_OP_CANCEL ||
|
||
request->operation == IEC104_REMOTE_PARAMETER_OP_DISCARD) {
|
||
if (Example_Remote_Owner(stage, request)) { memset(stage, 0, sizeof(*stage)); }
|
||
return IEC104_REMOTE_PARAMETER_ACTION_APPLIED;
|
||
}
|
||
if (!Example_Remote_Station(app, request)) { goto reject; }
|
||
if (request->operation == IEC104_REMOTE_PARAMETER_OP_READ_AREA) {
|
||
if (area == NULL) { return failure; }
|
||
area->minimum = 0U; area->maximum = 4U; area->current = app->remote_area;
|
||
return IEC104_REMOTE_PARAMETER_ACTION_APPLIED;
|
||
}
|
||
if (request->operation == IEC104_REMOTE_PARAMETER_OP_SWITCH_AREA) {
|
||
ExampleRemoteConfig saved;
|
||
/* 只选择已有设置,不复制或重置各区内容;真实暂存期间禁止切区。
|
||
* 非当前区仍可按请求SN读取或预置,当前配置由Current_Settings统一取值。 */
|
||
if (request->sn > 4U || stage->active) { return failure; }
|
||
saved = Example_Remote_Config_Snapshot(app);
|
||
saved.current_area = request->sn;
|
||
if (!Example_Remote_Config_Commit(app, &saved)) { return failure; }
|
||
Example_Remote_Report_Settings(app, "switch", request->sn);
|
||
return IEC104_REMOTE_PARAMETER_ACTION_APPLIED;
|
||
}
|
||
if (request->operation == IEC104_REMOTE_PARAMETER_OP_PRESET) {
|
||
ExampleRemoteValues candidate;
|
||
if (request->first_frame) {
|
||
if (stage->active) { goto reject; }
|
||
memset(&candidate, 0, sizeof(candidate));
|
||
} else {
|
||
if (!Example_Remote_Owner(stage, request)) { return failure; }
|
||
candidate = stage->values;
|
||
}
|
||
if (request->sn > 4U || (!request->first_frame && stage->owner.sn != request->sn)) { goto reject; }
|
||
/* 在局部候选副本上检查全帧,任一元素失败都不发布半帧暂存。
|
||
* 同一IOA重复出现按顺序覆盖;固定三项可写槽不随元素数增加,不会截断成功。 */
|
||
for (index = 0U; index < request->count; ++index) {
|
||
IEC104_RemoteParameterElement_t element;
|
||
size_t point;
|
||
if (!IEC104_RemoteParameter_Get_Element(request, index, &element)) { goto reject; }
|
||
point = Example_Remote_Index(element.ioa);
|
||
if (point == 7U) { failure = IEC104_REMOTE_PARAMETER_ACTION_UNKNOWN_IOA; goto reject; }
|
||
/* 前四项只读;电流死区不分区,非零SN不能访问,不能偷换成当前区。 */
|
||
if (point < 4U || (point == 4U && request->sn != 0U)) { goto reject; }
|
||
if (point == 5U) {
|
||
uint16_t value;
|
||
if (element.tag != IEC104_REMOTE_PARAMETER_TAG_USHORT || element.length != 2U) { goto reject; }
|
||
value = (uint16_t)((uint16_t)element.value[0] | ((uint16_t)element.value[1] << 8));
|
||
if (value > 3600U) { goto reject; }
|
||
candidate.reset_seconds = value; candidate.reset_set = true;
|
||
} else {
|
||
uint32_t bits;
|
||
float value;
|
||
if (element.tag != IEC104_REMOTE_PARAMETER_TAG_FLOAT || element.length != 4U) { goto reject; }
|
||
bits = (uint32_t)element.value[0] | ((uint32_t)element.value[1] << 8) |
|
||
((uint32_t)element.value[2] << 16) | ((uint32_t)element.value[3] << 24);
|
||
memcpy(&value, &bits, sizeof(value));
|
||
if (!(value >= 0.0f && value <= (point == 4U ? 10.0f : 100.0f))) { goto reject; }
|
||
if (point == 4U) { candidate.deadband = value; candidate.deadband_set = true; }
|
||
else { candidate.x_time = value; candidate.x_time_set = true; }
|
||
}
|
||
}
|
||
if (request->first_frame) {
|
||
/* 只保留身份等纯值字段,绝不把回调期TLV指针带到下一帧或DISCARD。 */
|
||
stage->owner = *request;
|
||
stage->owner._data = NULL; stage->owner._length = 0U; stage->owner.count = 0U;
|
||
stage->active = true;
|
||
}
|
||
stage->values = candidate;
|
||
return IEC104_REMOTE_PARAMETER_ACTION_APPLIED;
|
||
}
|
||
if (request->operation == IEC104_REMOTE_PARAMETER_OP_SOLIDIFY) {
|
||
ExampleRemoteValues *candidate = &stage->values;
|
||
ExampleRemoteConfig saved;
|
||
if (!Example_Remote_Owner(stage, request)) { return failure; }
|
||
if (request->sn > 4U || stage->owner.sn != request->sn ||
|
||
(candidate->deadband_set && (request->sn != 0U ||
|
||
!(candidate->deadband >= 0.0f && candidate->deadband <= 10.0f))) ||
|
||
(candidate->reset_set && candidate->reset_seconds > 3600U) ||
|
||
(candidate->x_time_set && !(candidate->x_time >= 0.0f && candidate->x_time <= 100.0f))) { goto reject; }
|
||
/* 所有约束通过后才发布已固化值;事件循环串行,发布期间不调回调或推进Slave。
|
||
* 目标是非当前区时只保存该套设置,不隐式切区;当前区写入立即可被Current_Settings读取。
|
||
* deadband不分区,经SN0修改后对任何当前区立即可见。
|
||
* 本例标准Parameter未开ACK且访问不同物理参数;若产品共用存储,
|
||
* 此处还须检查对方未提交的约束组预留,不能拿候选值当已生效值。 */
|
||
saved = Example_Remote_Config_Snapshot(app);
|
||
if (candidate->deadband_set) { saved.deadband = candidate->deadband; }
|
||
if (candidate->reset_set) { saved.reset_seconds[request->sn] = candidate->reset_seconds; }
|
||
if (candidate->x_time_set) { saved.x_time[request->sn] = candidate->x_time; }
|
||
if (!Example_Remote_Config_Commit(app, &saved)) { goto reject; }
|
||
memset(stage, 0, sizeof(*stage));
|
||
Example_Remote_Report_Settings(app, "solidify", request->sn);
|
||
return IEC104_REMOTE_PARAMETER_ACTION_APPLIED;
|
||
}
|
||
return failure;
|
||
reject:
|
||
/* 拒绝只清本请求所属批次;身份不匹配不能破坏另一实例或旧站仍欠清理的资源。 */
|
||
if (Example_Remote_Owner(stage, request)) { memset(stage, 0, sizeof(*stage)); }
|
||
return failure;
|
||
}
|
||
|
||
/**
|
||
* 功能:202读取请求SN的已固化值;可读取未选用的区,不使用Current_Settings偷换请求SN。
|
||
* 输入参数:context——调用方注册的回调上下文;request——仅在当前回调期间借用的协议请求;index——本次条目、点或逻辑槽的下标;ioa——信息体地址;frame——借用的远程参数回复帧。
|
||
* 输出参数:frame——借用的远程参数回复帧。
|
||
* 返回值:ADDED表示对象已加入回复,FULL表示当前帧已满,END表示全读遍历结束,UNKNOWN表示地址未知,ERROR表示身份或编码失败。
|
||
* 说明:纯读取且可重复:指定地址预检、正式组帧和发送WAIT后均可能重取同一下标。
|
||
* 不推进业务游标、不清计数;运行值允许变化,但整次请求的成员与index→IOA映射固定。
|
||
* 每次只向借用Frame加入一个元素,FULL表示本帧放不下,由模块在下一帧重取。
|
||
*/
|
||
static IEC104_RemoteParameterLookupResult_t Example_Remote_Lookup(void *context,
|
||
const IEC104_RemoteParameterRequest_t *request, size_t index, uint32_t ioa,
|
||
IEC104_RemoteParameterFrame_t *frame)
|
||
{
|
||
ExampleApp *app = context;
|
||
IEC104_RemoteParameterAddResult_t added;
|
||
size_t point;
|
||
if (!Example_Remote_Station(app, request) || request->sn > 4U) { return IEC104_REMOTE_PARAMETER_LOOKUP_ERROR; }
|
||
if (request->count == 0U) {
|
||
/* SN0含不分区参数与第0区动作定值;非零区只枚举末两项,避免错标不分区参数。 */
|
||
size_t count = request->sn == 0U ? 7U : 2U;
|
||
if (index >= count) { return IEC104_REMOTE_PARAMETER_LOOKUP_END; }
|
||
point = index + (request->sn == 0U ? 0U : 5U);
|
||
ioa = example_remote_ioas[point];
|
||
} else {
|
||
point = Example_Remote_Index(ioa);
|
||
if (point == 7U) { return IEC104_REMOTE_PARAMETER_LOOKUP_UNKNOWN; }
|
||
}
|
||
if (request->sn != 0U && point < 5U) { return IEC104_REMOTE_PARAMETER_LOOKUP_ERROR; }
|
||
switch (point) {
|
||
case 0U: added = IEC104_RemoteParameter_Add_String(frame, ioa, "DTU", 3U); break;
|
||
case 1U: added = IEC104_RemoteParameter_Add_String(frame, ioa, "Example", 7U); break;
|
||
case 2U: {
|
||
/* uint32十进制最多10字节;此处内容长度不含NUL,String写入器负责追加终止符。 */
|
||
char version[11];
|
||
int length = snprintf(version, sizeof(version), "%lu", (unsigned long)example_image.version);
|
||
if (length <= 0 || (size_t)length >= sizeof(version)) { return IEC104_REMOTE_PARAMETER_LOOKUP_ERROR; }
|
||
added = IEC104_RemoteParameter_Add_String(frame, ioa, version, (size_t)length);
|
||
break;
|
||
}
|
||
case 3U: added = IEC104_RemoteParameter_Add_Uint(frame, ioa, example_image.crc); break;
|
||
case 4U: added = IEC104_RemoteParameter_Add_Float(frame, ioa, app->remote_deadband); break;
|
||
case 5U: added = IEC104_RemoteParameter_Add_UShort(frame, ioa, app->remote_reset_seconds[request->sn]); break;
|
||
default: added = IEC104_RemoteParameter_Add_Float(frame, ioa, app->remote_x_time[request->sn]); break;
|
||
}
|
||
return added == IEC104_REMOTE_PARAMETER_ADD_OK ? IEC104_REMOTE_PARAMETER_LOOKUP_ADDED :
|
||
added == IEC104_REMOTE_PARAMETER_ADD_FULL ? IEC104_REMOTE_PARAMETER_LOOKUP_FULL : IEC104_REMOTE_PARAMETER_LOOKUP_ERROR;
|
||
}
|
||
|
||
#endif
|
||
/* 从首次执行到任务、预置、恢复及DISCARD全部结束,函数指针与app上下文身份保持稳定。 */
|
||
static const IEC104_RemoteParameterHandlers_t example_remote_handlers = {
|
||
Example_Remote_Action, Example_Remote_Lookup
|
||
};
|
||
|
||
/**
|
||
* 功能:每轮网络推进、读空通知后调用;先处理期限/固定回复,再执行一次动作或至多一帧读取。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。
|
||
* 说明:OK不等于动作成功或主站收到;回调后故障也可能返回OK,故仍检查Process与faulted。
|
||
* WAIT交回外层网络等待,不能在此原地循环重取。
|
||
*/
|
||
static bool Example_Step_RemoteParameter(ExampleApp *app)
|
||
{
|
||
IEC104_RemoteParameterExecuteResult_t result;
|
||
if (app->remote_parameter == NULL) { return true; }
|
||
if (!IEC104_RemoteParameter_Process(app->remote_parameter)) { return false; }
|
||
result = IEC104_RemoteParameter_Execute_Next(app->remote_parameter, &example_remote_handlers, app);
|
||
return result != IEC104_REMOTE_PARAMETER_EXECUTE_ERROR &&
|
||
IEC104_RemoteParameter_Process(app->remote_parameter) &&
|
||
IEC104_RemoteParameter_Get_Status(app->remote_parameter, &app->remote_status) && !app->remote_status.faulted;
|
||
}
|
||
|
||
/**
|
||
* 功能:先Cancel、Close并分派生命周期,再进入仅清理路径;退出时绝不执行排队中的新业务。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。
|
||
* 说明:每实例最多欠一次DISCARD,原连接已结束也必须交付;app与暂存容器保留至清理完成。
|
||
* 状态查询失败或仍有恢复/任务均返回false,不假装Destroy前置条件已满足。
|
||
*/
|
||
static bool Example_Drain_RemoteParameter(ExampleApp *app)
|
||
{
|
||
if (app->remote_parameter == NULL) { return true; }
|
||
if (!IEC104_RemoteParameter_Get_Status(app->remote_parameter, &app->remote_status)) { return false; }
|
||
if (app->remote_status.discard_pending &&
|
||
IEC104_RemoteParameter_Execute_Next(app->remote_parameter, &example_remote_handlers, app) !=
|
||
IEC104_REMOTE_PARAMETER_EXECUTE_OK) { return false; }
|
||
return IEC104_RemoteParameter_Get_Status(app->remote_parameter, &app->remote_status) &&
|
||
!app->remote_status.discard_pending && !app->remote_status.preset_active &&
|
||
!app->remote_status.recovery_required && app->remote_status.pending_requests == 0U;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [SOFTWARE_UPGRADE] Type211控制;候选、预留激活任务与设备owner属于应用
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:Slave地址不足以识别连接:实例编号防池槽复用,generation防重连后的TCP会话串接旧候选。
|
||
* 输入参数:a——第一个待比较值或身份;b——第二个待比较值或身份。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:两份服务及连接身份相同时返回true,否则返回false。
|
||
* 说明:无。
|
||
*/
|
||
static bool Example_Upgrade_Identity(const IEC104_SlaveEventIdentity_t *a,
|
||
const IEC104_SlaveEventIdentity_t *b)
|
||
{
|
||
return a->slave == b->slave && a->instance_id == b->instance_id && a->generation == b->generation;
|
||
}
|
||
|
||
/**
|
||
* 功能:OA保留在请求中但不作为会话键;相同CA注销重注册后仍须被station_id挡住。
|
||
* 输入参数:app——示例应用上下文;request——仅在当前回调期间借用的协议请求。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:请求与当前升级所有者身份一致时返回true,否则返回false。
|
||
* 说明:无。
|
||
*/
|
||
static bool Example_Upgrade_Owner(const ExampleApp *app, const IEC104_SoftwareUpgradeRequest_t *request)
|
||
{
|
||
const ExampleUpgradeDevice *device = &example_upgrade_device;
|
||
return device->owned && device->context == app &&
|
||
Example_Upgrade_Identity(&device->owner.identity, &request->identity) &&
|
||
device->owner.common_address == request->common_address &&
|
||
device->owner.station_id == request->station_id && device->owner.session_serial == request->session_serial;
|
||
}
|
||
|
||
/**
|
||
* 功能:锁存固件存储故障,交由主循环执行统一退出。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:无。
|
||
* 说明:I/O/提交故障不可就地重试;候选格式或许可拒绝不等同于持久存储损坏。
|
||
* 这里只锁存退出原因,不关闭文件、不改写协议结果;当前回调仍须走完自己的最终收尾。
|
||
*/
|
||
static void Example_Upgrade_Store_Failed(ExampleApp *app)
|
||
{
|
||
if (!app->upgrade_store_failed) { fputs("UPGRADE_STORE failed; close and recover before retry.\n", stderr); }
|
||
app->upgrade_store_failed = true;
|
||
}
|
||
|
||
/**
|
||
* 功能:后端bool失败后的分类检查:只查询故障位,不推进恢复,也不据此重做失败的写入。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:存储实例健康或未启用持久存储时返回true,查询失败或已故障时返回false。
|
||
* 说明:返回true仅表示实例尚可继续受理合法动作;不会把前一次拒绝改判为成功。
|
||
*/
|
||
static bool Example_Upgrade_Store_Healthy(ExampleApp *app)
|
||
{
|
||
IEC60870_FirmwareUpdateStatus_t status;
|
||
if (app->upgrade_store == NULL) { return true; }
|
||
if (!IEC60870_FirmwareUpdate_Get_Status(&app->upgrade_store->core, &status) || status.faulted) {
|
||
Example_Upgrade_Store_Failed(app); return false;
|
||
}
|
||
return !app->upgrade_store_failed;
|
||
}
|
||
|
||
/**
|
||
* 功能:Prepare_Boot只在一次启动/激活中调用一次。查询实际启动角色,不把TRIAL的旧current当作新映像。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:app借用的后端须已Open且保持串行;返回false后交统一退出清理,不在原实例循环重试安装。
|
||
* 宿主只安装文件,不执行负载;恢复回退与试运行分别记录事实,不能伪报升级成功。
|
||
* before用于辨认本次恢复动作,after用于核验真实结果;普通STABLE启动不新增升级行为日志。
|
||
*/
|
||
static bool Example_Upgrade_Prepare_Boot(ExampleApp *app)
|
||
{
|
||
IEC60870_FirmwareUpdateStatus_t before, after;
|
||
uint8_t slot;
|
||
char text[IEC60870_USER_LOG_TEXT_MAX + 1U];
|
||
const char *phase;
|
||
int length;
|
||
if (app->upgrade_store == NULL) { return true; }
|
||
if (!IEC60870_FirmwareUpdate_Get_Status(&app->upgrade_store->core, &before) || before.faulted ||
|
||
!Example_Upgrade_Store_Prepare_Boot(app->upgrade_store) ||
|
||
!IEC60870_FirmwareUpdate_Get_Status(&app->upgrade_store->core, &after) || after.faulted) {
|
||
Example_Upgrade_Store_Failed(app); return false;
|
||
}
|
||
slot = after.state == IEC60870_FIRMWARE_UPDATE_TRIAL ? after.candidate_slot : after.current_slot;
|
||
if ((after.state != IEC60870_FIRMWARE_UPDATE_TRIAL && after.state != IEC60870_FIRMWARE_UPDATE_STABLE) ||
|
||
slot >= IEC60870_FIRMWARE_UPDATE_SLOT_COUNT || after.images[slot].version == 0U || after.images[slot].size == 0U) {
|
||
Example_Upgrade_Store_Failed(app); return false;
|
||
}
|
||
phase = after.state == IEC60870_FIRMWARE_UPDATE_TRIAL ? "BOOT_TRIAL" :
|
||
(before.state == IEC60870_FIRMWARE_UPDATE_TRIAL || before.state == IEC60870_FIRMWARE_UPDATE_ROLLING_BACK ||
|
||
before.state == IEC60870_FIRMWARE_UPDATE_AUTHORIZED || before.state == IEC60870_FIRMWARE_UPDATE_INSTALLING) ?
|
||
"BOOT_ROLLBACK" : NULL;
|
||
if (phase != NULL) {
|
||
length = snprintf(text, sizeof(text), "HOST_FILE UPGRADE %s version=%lu", phase,
|
||
(unsigned long)after.images[slot].version);
|
||
if (length <= 0 || (size_t)length >= sizeof(text)) { Example_Upgrade_Store_Failed(app); return false; }
|
||
Example_User_Log_Append(app, 11U, 1U, IEC104_Net_Now_Ms(), text);
|
||
}
|
||
/* 核心可能拒绝损坏候选并成功恢复旧映像;恢复成功不等于本次升级成功。
|
||
* 运行期已领取任务必须确实启动冻结的目标,启动恢复路径没有内存任务则可接受旧current。 */
|
||
if (example_upgrade_device.context == app && example_upgrade_device.taken &&
|
||
(after.state != IEC60870_FIRMWARE_UPDATE_TRIAL ||
|
||
after.images[slot].version != example_upgrade_device.activation.version ||
|
||
after.images[slot].size != example_upgrade_device.activation.size - 16U ||
|
||
after.images[slot].crc != example_upgrade_device.activation.crc)) { return false; }
|
||
return !app->user_log_failed;
|
||
}
|
||
|
||
/**
|
||
* 功能:网络初始化及COI登记成功后才确认文件健康;current只在持久Confirm成功后发布。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:此健康条件只覆盖宿主文件与协议准备,不声明负载曾运行或真实设备完成自检。
|
||
* STABLE确认幂等;TRIAL确认可能在返回失败前已提交,因此失败只能重开核对角色。
|
||
* 已确认后的日志失败由外层停机处理,不撤销确认、不重复轮转,也不抹掉已发布版本。
|
||
*/
|
||
static bool Example_Upgrade_Confirm_Boot(ExampleApp *app)
|
||
{
|
||
IEC60870_FirmwareUpdateDescriptor_t current;
|
||
IEC60870_FirmwareUpdateStatus_t before;
|
||
if (app->upgrade_store == NULL) { return true; }
|
||
if (!IEC60870_FirmwareUpdate_Get_Status(&app->upgrade_store->core, &before) || before.faulted ||
|
||
!Example_Upgrade_Store_Confirm(app->upgrade_store) ||
|
||
!Example_Upgrade_Store_Current(app->upgrade_store, ¤t)) {
|
||
Example_Upgrade_Store_Failed(app); return false;
|
||
}
|
||
example_image.version = current.version;
|
||
example_image.crc = current.crc;
|
||
if (before.state == IEC60870_FIRMWARE_UPDATE_TRIAL) {
|
||
char text[96];
|
||
(void)snprintf(text, sizeof(text), "HOST_FILE UPGRADE HEALTH_CONFIRMED version=%lu",
|
||
(unsigned long)current.version);
|
||
Example_User_Log_Append(app, 11U, 1U, IEC104_Net_Now_Ms(), text);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:打开固件持久存储,并在首次使用时导入显式基线包。
|
||
* 输入参数:app——示例应用上下文;store——固件持久适配实例;directory——持久存储目录;seed——首次初始化的基线包路径或句柄。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:首次启动必须导入完整基线包;seed为NULL表示只恢复已有库,不能凭默认版本制造映像。
|
||
* store由调用者保活至Destroy,directory/seed仅在同步Open期间读取;失败也保留已取得的后端供关闭。
|
||
* 此处只恢复、准备并读取最后确认版,尚未确认TRIAL;后续监听与COI就绪后才调用Confirm_Boot。
|
||
*/
|
||
static bool Example_Init_Upgrade_Store(ExampleApp *app, ExampleUpgrade *store,
|
||
const char *directory, const char *seed)
|
||
{
|
||
IEC60870_FirmwareUpdateDescriptor_t current;
|
||
if (app->software_upgrade == NULL || app->upgrade_store != NULL ||
|
||
!Example_Upgrade_Store_Open(store, directory, seed)) { return false; }
|
||
app->upgrade_store = store; /* 后续任一步失败仍由统一Destroy关闭,不隐式撤销磁盘授权。 */
|
||
if (!Example_Upgrade_Prepare_Boot(app) || !Example_Upgrade_Store_Current(store, ¤t)) { return false; }
|
||
example_image.version = current.version;
|
||
example_image.crc = current.crc;
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:已失效的owner只能在最后一个文件handle归还且没有已领取任务时释放。
|
||
* 输入参数:无。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:无。
|
||
* 说明:单调token从不清零,模块Destroy/Create也不能让旧应用工作重新匹配当前候选。
|
||
* 这里清掉的persistent_handoff只属于内存任务,不表示磁盘AUTH/TRIAL已经完成或取消。
|
||
*/
|
||
static void Example_Upgrade_Release(void)
|
||
{
|
||
ExampleUpgradeDevice *device = &example_upgrade_device;
|
||
if (!device->owned || !device->invalidated || device->file.active || device->taken) { return; }
|
||
device->owned = false;
|
||
device->context = NULL;
|
||
device->reserved = device->committed = device->verified = false;
|
||
device->persistent_handoff = false;
|
||
device->state = EXAMPLE_UPGRADE_EMPTY;
|
||
device->size = device->received = 0U;
|
||
memset(&device->owner, 0, sizeof(device->owner));
|
||
memset(&device->activation, 0, sizeof(device->activation));
|
||
}
|
||
|
||
/**
|
||
* 功能:撤销或ABANDON先失效,旧write立即失败;存在文件handle时仅延后释放owner,不擦除其存储。
|
||
* 输入参数:无。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:无。
|
||
* 说明:taken后所有权已移交激活任务,协议清理无权撤回;由Activation_Finished显式结束该任务。
|
||
*/
|
||
static void Example_Upgrade_Invalidate(void)
|
||
{
|
||
ExampleUpgradeDevice *device = &example_upgrade_device;
|
||
ExampleApp *app = device->context;
|
||
if (!device->owned || device->taken) { return; }
|
||
/* 领取后的提交结果即使不确定,也只能重开恢复;不能让退出清理擦除AUTH/TRIAL事实。 */
|
||
if (app->upgrade_store != NULL && !device->persistent_handoff &&
|
||
!Example_Upgrade_Store_Candidate_Abort(app->upgrade_store)) { Example_Upgrade_Store_Failed(app); }
|
||
device->invalidated = true;
|
||
device->reserved = device->committed = device->verified = false;
|
||
device->state = EXAMPLE_UPGRADE_INVALID;
|
||
memset(&device->activation, 0, sizeof(device->activation));
|
||
Example_Upgrade_Release();
|
||
}
|
||
|
||
/**
|
||
* 功能:11逐阶段记录已发生的升级动作;owner/transfer只是来源标识,绝不把ACK或END叫升级成功。
|
||
* 输入参数:app——示例应用上下文;phase——已发生的升级阶段名称。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:无。
|
||
* 说明:RAM模式标SIMULATED;持久模式标HOST_FILE,只声明真实文件安装,避免冒充Flash刷写或硬件重启。
|
||
* phase由调用处提供本次事实,value=1表示行为发生;FILE_REJECTED/取消等阶段并不表示升级成功。
|
||
* 本函数不改变设备owner或候选状态,写日志失败仍须由原动作完成自己的释放。
|
||
*/
|
||
static void Example_User_Log_Upgrade(ExampleApp *app, const char *phase)
|
||
{
|
||
char text[IEC60870_USER_LOG_TEXT_MAX + 1U];
|
||
ExampleUpgradeDevice *device = &example_upgrade_device;
|
||
int length;
|
||
if (app->user_log == NULL) { return; }
|
||
length = snprintf(text, sizeof(text), "%s UPGRADE %s owner=%llu transfer=%llu version=%lu",
|
||
app->upgrade_store == NULL ? "SIMULATED" : "HOST_FILE", phase,
|
||
(unsigned long long)device->owner_token, (unsigned long long)device->transfer_token,
|
||
(unsigned long)device->target_version);
|
||
if (length <= 0 || (size_t)length >= sizeof(text)) {
|
||
Example_User_Log_Result(app, IEC60870_USER_LOG_INVALID); return;
|
||
}
|
||
Example_User_Log_Append(app, 11U, 1U, IEC104_Net_Now_Ms(), text);
|
||
}
|
||
|
||
/**
|
||
* 功能:按字节累计CRC-32/ISO-HDLC;仅覆盖负载,不包含16字节工程包头。
|
||
* 输入参数:crc——跨片段CRC累积值;data——字节数据缓冲;length——本次数据或名称的有效字节数。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:可继续处理后续片段的CRC中间状态,最终异或在提交时执行。
|
||
* 说明:OPEN置初值0xFFFFFFFF,函数保留中间值供跨段续算,COMMIT才异或0xFFFFFFFF并比较包头期望值。
|
||
*/
|
||
static uint32_t Example_Upgrade_Crc(uint32_t crc, const uint8_t *data, uint32_t length)
|
||
{
|
||
uint32_t index;
|
||
for (index = 0U; index < length; ++index) {
|
||
unsigned bit;
|
||
crc ^= data[index];
|
||
for (bit = 0U; bit < 8U; ++bit) {
|
||
crc = (crc >> 1) ^ ((crc & 1U) != 0U ? UINT32_C(0xEDB88320) : 0U);
|
||
}
|
||
}
|
||
return crc;
|
||
}
|
||
|
||
/**
|
||
* 功能:包头采用小端且可能未对齐;显式逐字节解码,调用者先保证完整四字节可读。
|
||
* 输入参数:bytes——字节数据缓冲。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:解码后的32位无符号整数。
|
||
* 说明:无。
|
||
*/
|
||
static uint32_t Example_Upgrade_U32(const uint8_t *bytes)
|
||
{
|
||
return (uint32_t)bytes[0] | ((uint32_t)bytes[1] << 8) |
|
||
((uint32_t)bytes[2] << 16) | ((uint32_t)bytes[3] << 24);
|
||
}
|
||
|
||
/**
|
||
* 功能:文件服务必须先创建;这里只绑定协议实例,设备owner和映像记录不随实例初始化清零。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:无。
|
||
*/
|
||
static inline bool Example_Init_SoftwareUpgrade(ExampleApp *app)
|
||
{
|
||
IEC104_SoftwareUpgradeConfig_t config;
|
||
if (app->software_upgrade != NULL || app->file_service == NULL) { return false; }
|
||
IEC104_SoftwareUpgrade_Config_Default(&config);
|
||
app->software_upgrade = IEC104_SoftwareUpgrade_Create(app->slave, &config);
|
||
return app->software_upgrade != NULL;
|
||
}
|
||
|
||
/**
|
||
* 功能:START只取得设备owner;END仅冻结候选和预留任务,不能在协议动作内重启。
|
||
* 输入参数:context——调用方注册的回调上下文;request——仅在当前回调期间借用的协议请求。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:ACCEPT表示本阶段升级操作获准并已完成对应应用处理,REJECT表示会话、所有者或候选状态不允许。
|
||
* 说明:真实与TEST由模块隔离;本回调从不收到TEST。REJECT分支不改变应用状态。
|
||
*/
|
||
static IEC104_SoftwareUpgradeDecision_t Example_Upgrade_Action(void *context,
|
||
const IEC104_SoftwareUpgradeRequest_t *request)
|
||
{
|
||
ExampleApp *app = context;
|
||
ExampleUpgradeDevice *device = &example_upgrade_device;
|
||
if (request->operation == IEC104_SOFTWARE_UPGRADE_OP_ABANDON) {
|
||
/* 通知可在连接失效后到达,只按原START归属清理,不要求原站点仍注册。 */
|
||
if (Example_Upgrade_Owner(app, request) && !device->invalidated && !device->taken) {
|
||
Example_User_Log_Upgrade(app, "ABANDON");
|
||
Example_Upgrade_Invalidate();
|
||
}
|
||
return IEC104_SOFTWARE_UPGRADE_DECISION_ACCEPT;
|
||
}
|
||
if (request->operation == IEC104_SOFTWARE_UPGRADE_OP_START) {
|
||
/* 所有Slave在同一串行上下文竞争这一个owner;旧handle未收尾也不能覆盖候选。 */
|
||
if (app->quiescing || app->upgrade_store_failed || device->owned || device->file.active || device->owner_token == UINT64_MAX ||
|
||
!IEC104_Station_Is_Registered(&app->station) ||
|
||
request->station_id != IEC104_Station_Get_Id(&app->station) ||
|
||
request->common_address != IEC104_Station_Get_Common_Address(&app->station)) {
|
||
return IEC104_SOFTWARE_UPGRADE_DECISION_REJECT;
|
||
}
|
||
++device->owner_token;
|
||
device->context = app;
|
||
device->owner = *request;
|
||
device->owned = true;
|
||
device->invalidated = device->committed = device->verified = device->reserved = device->taken = false;
|
||
device->persistent_handoff = false;
|
||
device->state = EXAMPLE_UPGRADE_EMPTY;
|
||
device->size = device->received = 0U;
|
||
device->target_version = 0U;
|
||
Example_User_Log_Upgrade(app, "START");
|
||
return IEC104_SOFTWARE_UPGRADE_DECISION_ACCEPT;
|
||
}
|
||
if (!Example_Upgrade_Owner(app, request) || device->invalidated || device->taken) {
|
||
return IEC104_SOFTWARE_UPGRADE_DECISION_REJECT;
|
||
}
|
||
if (request->operation == IEC104_SOFTWARE_UPGRADE_OP_CANCEL) {
|
||
Example_User_Log_Upgrade(app, "CANCEL");
|
||
Example_Upgrade_Invalidate();
|
||
return IEC104_SOFTWARE_UPGRADE_DECISION_ACCEPT;
|
||
}
|
||
if (request->operation != IEC104_SOFTWARE_UPGRADE_OP_END || device->file.active ||
|
||
!device->committed || !device->verified || device->state != EXAMPLE_UPGRADE_VERIFIED ||
|
||
device->reserved || device->received != device->size || device->target_version <= example_image.version) {
|
||
return IEC104_SOFTWARE_UPGRADE_DECISION_REJECT;
|
||
}
|
||
if (app->upgrade_store != NULL) {
|
||
IEC60870_FirmwareUpdateDescriptor_t candidate;
|
||
/* 核对COMMIT发布的同一候选;END只冻结应用描述,核心仍为VERIFIED,尚未获得持久授权。
|
||
* 候选size仅含负载,而应用size含16字节头;比较前已由接收路径保证整包最小长度。 */
|
||
if (!Example_Upgrade_Store_Candidate_Info(app->upgrade_store, &candidate) ||
|
||
candidate.version != device->target_version || candidate.crc != device->payload_crc ||
|
||
candidate.size != device->size - 16U) {
|
||
(void)Example_Upgrade_Store_Healthy(app);
|
||
return IEC104_SOFTWARE_UPGRADE_DECISION_REJECT;
|
||
}
|
||
}
|
||
/* 当前COMMIT完整且验证通过才接受END;固定此transfer的目标,后续不能改取“最新文件”。
|
||
* 本例只有一个内嵌任务槽,reserved检查就是预留准入,不涉及领取后的堆分配。 */
|
||
device->activation.owner_token = device->owner_token;
|
||
device->activation.transfer_token = device->transfer_token;
|
||
device->activation.version = device->target_version;
|
||
device->activation.crc = device->payload_crc;
|
||
device->activation.size = device->size;
|
||
device->reserved = true;
|
||
device->state = EXAMPLE_UPGRADE_FROZEN;
|
||
Example_User_Log_Upgrade(app, "END_RESERVED");
|
||
return IEC104_SOFTWARE_UPGRADE_DECISION_ACCEPT;
|
||
}
|
||
|
||
/**
|
||
* 功能:每轮先冻结已有ACK事实,再执行一项请求;实际领取由统一仲裁器完成。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。
|
||
* 说明:无。
|
||
*/
|
||
static bool Example_Step_SoftwareUpgrade(ExampleApp *app)
|
||
{
|
||
IEC104_SoftwareUpgradeExecuteResult_t result;
|
||
if (app->software_upgrade == NULL) { return true; }
|
||
if (!IEC104_SoftwareUpgrade_Process(app->software_upgrade)) { return false; }
|
||
result = IEC104_SoftwareUpgrade_Execute_Next(app->software_upgrade, Example_Upgrade_Action, app);
|
||
return result != IEC104_SOFTWARE_UPGRADE_EXECUTE_ERROR && !app->upgrade_store_failed &&
|
||
IEC104_SoftwareUpgrade_Process(app->software_upgrade) &&
|
||
IEC104_SoftwareUpgrade_Get_Status(app->software_upgrade, &app->upgrade_status) && !app->upgrade_status.faulted;
|
||
}
|
||
|
||
/**
|
||
* 功能:成功发布发生在协议Init与COI登记之后、重新处理网络之前;失败保持原映像记录。
|
||
* 输入参数:app——示例应用上下文;success——激活过程是否成功。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:无。
|
||
* 说明:版本和CRC在同一串行上下文确认后发布,COMMIT/END/ACK都不会提前发布。
|
||
* 持久模式已经由Confirm_Boot读取确认版,这里只结算任务;不能再用activation描述冒充确认结果。
|
||
* 领取后的候选不受模块Cancel影响,只有本应用任务完成或失败才解除冻结;重复收尾无操作。
|
||
*/
|
||
static void Example_Upgrade_Activation_Finished(ExampleApp *app, bool success)
|
||
{
|
||
ExampleUpgradeDevice *device = &example_upgrade_device;
|
||
if (!device->owned || device->context != app || !device->taken) { return; }
|
||
if (success) {
|
||
if (app->upgrade_store == NULL) {
|
||
ExampleImage image;
|
||
image.version = device->activation.version;
|
||
image.crc = device->activation.crc;
|
||
example_image = image;
|
||
}
|
||
++device->succeeded;
|
||
} else { ++device->failed; }
|
||
Example_User_Log_Upgrade(app, success ? "ACTIVATION_SUCCESS" : "ACTIVATION_FAILED");
|
||
/* 映像发布结果已经确定,日志失败只能触发停机,仍须归还taken及候选;重复收尾不得改写成功结果。 */
|
||
device->taken = false;
|
||
Example_Upgrade_Invalidate();
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [FILE_SERVICE] Type210目录快照、内存只读文件、TEMP事务和BUSY接入
|
||
* ============================================================================ */
|
||
/* 这些只是传输演示内容,不声明符合COMTRADE或现场MSG文件格式;名称及大小由应用定义。 */
|
||
static const uint8_t example_file_soe[] = "SOE example: breaker closed\n";
|
||
static const uint8_t example_file_ulog[] = "ULOG example: service started\n";
|
||
static const struct {
|
||
const char *directory, *name, *path;
|
||
const uint8_t *data;
|
||
size_t size;
|
||
} example_files[] = {
|
||
{"HISTORY/SOE", "soe.msg", "HISTORY/SOE/soe.msg", example_file_soe, sizeof(example_file_soe) - 1U},
|
||
{"HISTORY/ULOG", "ulog.msg", "HISTORY/ULOG/ulog.msg", example_file_ulog, sizeof(example_file_ulog) - 1U}
|
||
};
|
||
|
||
/**
|
||
* 功能:按显式长度匹配线上名称与本地字符串常量,区分大小写且不读取线上结束符。
|
||
* 输入参数:name——文件名或显式长度的协议名称;length——本次数据或名称的有效字节数;literal——本地NUL结尾名称常量。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:显式长度名称与本地常量完全相同时返回true,否则返回false。
|
||
* 说明:空名称只匹配空常量;非空名称要求name有效。
|
||
*/
|
||
static bool Example_File_Name_Is(const uint8_t *name, uint8_t length, const char *literal)
|
||
{
|
||
size_t expected = strlen(literal); /* literal仅来自本文件的常量,线上名称没有结束符。 */
|
||
return (size_t)length == expected && (expected == 0U || (name != NULL && memcmp(name, literal, expected) == 0));
|
||
}
|
||
|
||
/**
|
||
* 功能:示例只允许TEMP下的单层ASCII文件名,不做路径归一化或宿主路径映射。
|
||
* 输入参数:name——文件名或显式长度的协议名称;length——本次数据或名称的有效字节数。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:名称属于允许的TEMP单层文件名时返回true,否则返回false。
|
||
* 说明:因而../、反斜线、绝对路径、NUL及编码别名都无法触及升级/运行资源。
|
||
* upgrade.bin由独立升级入口处理;TEMP/upgrade.bin只是独立TEMP文件,不映射候选。
|
||
* 叶名称还须能放入目录项,因此上限采用目录名容量,而非激活报文的完整路径容量。
|
||
*/
|
||
static bool Example_File_Temp_Name(const uint8_t *name, uint8_t length)
|
||
{
|
||
size_t index;
|
||
if (name == NULL || length <= 5U || (size_t)length > 5U + IEC104_FILE_SERVICE_MAX_DIRECTORY_NAME ||
|
||
memcmp(name, "TEMP/", 5U) != 0 || name[5] == '.') { return false; }
|
||
for (index = 5U; index < length; ++index) {
|
||
uint8_t ch = name[index];
|
||
if (!((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') ||
|
||
(ch >= '0' && ch <= '9') || ch == '_' || ch == '-' || ch == '.')) { return false; }
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:清理按保存的原归属匹配;站点注销、重连后仍允许清理旧handle,不能改查新注册站。
|
||
* 输入参数:resource——应用侧文件资源及归属身份;request——仅在当前回调期间借用的协议请求。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:文件资源保存的身份与请求完全匹配时返回true,否则返回false。
|
||
* 说明:handle区分同一站的连续OPEN,模块instance_id与Slave的identity.instance_id分别校验;
|
||
* OA只用于报文来源诊断,不把它当作访问权限或资源所有权凭证。
|
||
*/
|
||
static bool Example_File_Owner(const ExampleFileResource *resource, const IEC104_FileServiceRequest_t *request)
|
||
{
|
||
const IEC104_FileServiceRequest_t *owner = &resource->owner;
|
||
return resource->active && owner->handle == request->handle &&
|
||
owner->identity.slave == request->identity.slave &&
|
||
owner->identity.instance_id == request->identity.instance_id &&
|
||
owner->identity.generation == request->identity.generation &&
|
||
owner->instance_id == request->instance_id && owner->station_id == request->station_id &&
|
||
owner->common_address == request->common_address && owner->test == request->test;
|
||
}
|
||
|
||
/**
|
||
* 功能:只分配空闲资源并复制身份,不保存协议原文中的名称指针。
|
||
* 输入参数:files——应用文件存储与目录快照;resource——应用侧文件资源及归属身份;request——仅在当前回调期间借用的协议请求;open——文件打开结果回写位置。
|
||
* 输出参数:resource——本次操作更新的实例或工作区;open——文件打开结果回写位置。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:token耗尽拒绝新OPEN;不能回绕后让迟到CLOSE/ABORT匹配新资源。
|
||
*/
|
||
static bool Example_File_Open_Resource(ExampleFileStore *files, ExampleFileResource *resource,
|
||
const IEC104_FileServiceRequest_t *request, IEC104_FileServiceOpen_t *open)
|
||
{
|
||
if (resource->active || files->next_handle == UINTPTR_MAX) { return false; }
|
||
resource->owner = *request;
|
||
resource->owner.name = NULL;
|
||
resource->owner.name_length = 0U;
|
||
resource->owner.handle = ++files->next_handle;
|
||
resource->active = true;
|
||
open->handle = resource->owner.handle;
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:保留升级目标只能绑定当前OPEN会话;读取状态不推进任何协议模块。
|
||
* 输入参数:app——示例应用上下文;request——仅在当前回调期间借用的协议请求;open——文件打开结果回写位置。
|
||
* 输出参数:open——文件打开结果回写位置。
|
||
* 返回值:OK表示上传资源已建立,NAME_UNSUPPORTED表示目标或所有者不支持,SIZE_OUT_OF_RANGE表示声明大小越界,FAILED表示资源或存储准备失败。
|
||
* 说明:完整身份、CA、站点注册编号和会话序号同时匹配owner,WAIT_ACK/已冻结时禁止重写。
|
||
* 身份/状态拒绝不改变候选;新OPEN取得handle后,持久模式先撤销旧未授权候选,再接收新传输。
|
||
* 后端此时失败须归还刚取得的handle,并使旧验证标记失效,不能再END已被撤销的包。
|
||
*/
|
||
static IEC104_FileServiceResult_t Example_Upgrade_File_Open(ExampleApp *app,
|
||
const IEC104_FileServiceRequest_t *request, IEC104_FileServiceOpen_t *open)
|
||
{
|
||
ExampleUpgradeDevice *device = &example_upgrade_device;
|
||
IEC104_SoftwareUpgradeStatus_t status;
|
||
if (app->software_upgrade == NULL) { return IEC104_FILE_SERVICE_RESULT_NAME_UNSUPPORTED; }
|
||
/* 先限制整包至少16字节头加1字节负载,后续用size-16核对,避免头长加负载长度回绕。 */
|
||
if (request->file_size < 17U || request->file_size >
|
||
(app->upgrade_store == NULL ? EXAMPLE_UPGRADE_BYTES : EXAMPLE_UPGRADE_PACKAGE_MAX)) {
|
||
return IEC104_FILE_SERVICE_RESULT_SIZE_OUT_OF_RANGE;
|
||
}
|
||
if (request->test || app->quiescing || app->upgrade_store_failed || !device->owned || device->context != app || device->invalidated ||
|
||
device->taken || device->reserved || device->file.active || device->state == EXAMPLE_UPGRADE_VERIFYING ||
|
||
device->transfer_token == UINT64_MAX ||
|
||
!IEC104_SoftwareUpgrade_Get_Status(app->software_upgrade, &status) || status.faulted ||
|
||
status.session_state != IEC104_SOFTWARE_UPGRADE_SESSION_OPEN ||
|
||
!Example_Upgrade_Identity(&status.session_identity, &request->identity) ||
|
||
!Example_Upgrade_Identity(&device->owner.identity, &request->identity) ||
|
||
status.session_common_address != request->common_address ||
|
||
status.session_station_id != request->station_id || status.session_serial != device->owner.session_serial ||
|
||
device->owner.common_address != request->common_address || device->owner.station_id != request->station_id ||
|
||
!Example_File_Open_Resource(&app->files, &device->file, request, open)) {
|
||
return IEC104_FILE_SERVICE_RESULT_FAILED;
|
||
}
|
||
if (app->upgrade_store != NULL &&
|
||
(!Example_Upgrade_Store_Candidate_Abort(app->upgrade_store) ||
|
||
!Example_Upgrade_Store_Candidate_Open(app->upgrade_store, request->file_size))) {
|
||
/* OPEN被拒绝不会再收到最终回调,本次刚分配的handle必须立即归还。 */
|
||
device->file.active = false;
|
||
device->committed = device->verified = false;
|
||
device->state = EXAMPLE_UPGRADE_INVALID;
|
||
(void)Example_Upgrade_Store_Healthy(app);
|
||
return IEC104_FILE_SERVICE_RESULT_FAILED;
|
||
}
|
||
/* 文件句柄与两个token同时固定这一轮接收;重传产生新transfer,旧最终回调不能终结新候选。 */
|
||
++device->transfer_token;
|
||
device->file_owner_token = device->owner_token;
|
||
device->file_transfer_token = device->transfer_token;
|
||
device->committed = device->verified = false;
|
||
device->state = EXAMPLE_UPGRADE_RECEIVING;
|
||
device->size = request->file_size;
|
||
device->received = device->target_version = device->payload_crc = 0U;
|
||
device->rolling_crc = UINT32_C(0xFFFFFFFF);
|
||
return IEC104_FILE_SERVICE_RESULT_OK;
|
||
}
|
||
|
||
/**
|
||
* 功能:最终回调恰一次;COMMIT失败自行归还handle,不等待不会到来的ABORT。
|
||
* 输入参数:app——示例应用上下文;request——仅在当前回调期间借用的协议请求。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:归属正确且COMMIT有效或请求为ABORT_WRITE时返回OK;归属错误或提交校验失败返回FAILED。
|
||
* 说明:单缓冲不允许新OPEN跨越旧handle,因此旧token清理不会覆盖另一候选。
|
||
*/
|
||
static IEC104_FileServiceResult_t Example_Upgrade_File_Finish(ExampleApp *app,
|
||
const IEC104_FileServiceRequest_t *request)
|
||
{
|
||
ExampleUpgradeDevice *device = &example_upgrade_device;
|
||
IEC60870_FirmwareUpdateDescriptor_t candidate;
|
||
bool valid;
|
||
if (!Example_File_Owner(&device->file, request) || device->context != app) {
|
||
return IEC104_FILE_SERVICE_RESULT_FAILED;
|
||
}
|
||
/* 逐段传输校验不等于整包校验;实际累计CRC必须与主站包头给出的期望CRC比较。
|
||
* ABORT也走此出口归还handle,但不发布候选;被取消的旧COMMIT安全失败并完成自己的收尾。 */
|
||
valid = request->call == IEC104_FILE_SERVICE_CALL_COMMIT && device->owned && !device->invalidated &&
|
||
device->file_owner_token == device->owner_token && device->file_transfer_token == device->transfer_token &&
|
||
device->state == EXAMPLE_UPGRADE_RECEIVING && device->size >= 17U &&
|
||
device->received == device->size && request->transferred == device->size;
|
||
if (app->upgrade_store != NULL) {
|
||
/* COMMIT的成功凭证来自磁盘同步和读回校验;不以最后一段到齐代替完整性检查。
|
||
* CRC/许可拒绝仍可Abort后重传;存储故障会闭锁,但两者都必须归还原文件handle。 */
|
||
valid = valid && Example_Upgrade_Store_Candidate_Finish(app->upgrade_store) &&
|
||
Example_Upgrade_Store_Candidate_Info(app->upgrade_store, &candidate) &&
|
||
candidate.version > example_image.version && candidate.size == device->size - 16U;
|
||
if (!valid && !Example_Upgrade_Store_Candidate_Abort(app->upgrade_store)) {
|
||
(void)Example_Upgrade_Store_Healthy(app);
|
||
}
|
||
} else {
|
||
valid = valid && memcmp(device->bytes, "I104", 4U) == 0 &&
|
||
Example_Upgrade_U32(device->bytes + 8U) == device->size - 16U &&
|
||
Example_Upgrade_U32(device->bytes + 4U) > example_image.version &&
|
||
(device->rolling_crc ^ UINT32_C(0xFFFFFFFF)) == Example_Upgrade_U32(device->bytes + 12U);
|
||
}
|
||
device->file.active = false;
|
||
device->committed = device->verified = valid;
|
||
if (valid) {
|
||
device->target_version = app->upgrade_store == NULL ? Example_Upgrade_U32(device->bytes + 4U) : candidate.version;
|
||
device->payload_crc = app->upgrade_store == NULL ? Example_Upgrade_U32(device->bytes + 12U) : candidate.crc;
|
||
device->state = EXAMPLE_UPGRADE_VERIFIED;
|
||
} else { device->state = EXAMPLE_UPGRADE_INVALID; }
|
||
Example_User_Log_Upgrade(app, request->call == IEC104_FILE_SERVICE_CALL_ABORT_WRITE ? "FILE_ABORT" :
|
||
valid ? "FILE_VERIFIED" : "FILE_REJECTED");
|
||
Example_Upgrade_Release();
|
||
return valid || request->call == IEC104_FILE_SERVICE_CALL_ABORT_WRITE ?
|
||
IEC104_FILE_SERVICE_RESULT_OK : IEC104_FILE_SERVICE_RESULT_FAILED;
|
||
}
|
||
|
||
/**
|
||
* 功能:写入只接受OPEN捕获的handle和token,不重新解释用途;必须连续且不越过声明总长。
|
||
* 输入参数:app——示例应用上下文;request——仅在当前回调期间借用的协议请求;offset——从起点计算的字节偏移;data——字节数据缓冲;length——本次数据或名称的有效字节数;last——是否为本次上传的末段。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:坏包使当前候选失效但不释放handle,文件服务随后仍须交付一次最终收尾。
|
||
*/
|
||
static bool Example_Upgrade_File_Write(ExampleApp *app, const IEC104_FileServiceRequest_t *request,
|
||
uint32_t offset, const uint8_t *data, uint16_t length, bool last)
|
||
{
|
||
ExampleUpgradeDevice *device = &example_upgrade_device;
|
||
/* 包头可跨多个数据段;skip超过本段长度时整段不计CRC,跨越边界的段仅累计尾部负载。 */
|
||
uint32_t skip = offset < 16U ? 16U - offset : 0U;
|
||
if (!Example_File_Owner(&device->file, request) || device->context != app || !device->owned ||
|
||
device->invalidated || request->test || device->state != EXAMPLE_UPGRADE_RECEIVING ||
|
||
device->file_owner_token != device->owner_token || device->file_transfer_token != device->transfer_token ||
|
||
offset != device->received || offset > device->size || length > device->size - offset ||
|
||
(last && length != device->size - offset) || (length != 0U && data == NULL)) { return false; }
|
||
if (app->upgrade_store != NULL) {
|
||
/* 持久模式只把当前小段交给后端;64KB模拟缓冲保持不动,整包大小不占RAM。
|
||
* offset/received含包头,后端自行拆头;只有整段成功才推进应用偏移,失败不原位重试。 */
|
||
if (!Example_Upgrade_Store_Candidate_Write(app->upgrade_store, offset, data, length)) {
|
||
device->state = EXAMPLE_UPGRADE_INVALID;
|
||
(void)Example_Upgrade_Store_Healthy(app);
|
||
return false;
|
||
}
|
||
device->received += length;
|
||
return true;
|
||
}
|
||
if (length != 0U) { memcpy(device->bytes + offset, data, length); }
|
||
if (skip < length) { device->rolling_crc = Example_Upgrade_Crc(device->rolling_crc, data + skip, length - skip); }
|
||
device->received += length;
|
||
/* 收满16字节前不读包头字段;声明总长已在OPEN限界,size-16不会下溢。 */
|
||
if (device->received >= 16U && (memcmp(device->bytes, "I104", 4U) != 0 ||
|
||
Example_Upgrade_U32(device->bytes + 8U) != device->size - 16U ||
|
||
Example_Upgrade_U32(device->bytes + 4U) <= example_image.version)) {
|
||
device->state = EXAMPLE_UPGRADE_INVALID;
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:快照保存名称/大小/时标的值副本;即使之后TEMP被提交替换,list同一下标仍保持一致。
|
||
* 输入参数:files——应用文件存储与目录快照;name——文件名或显式长度的协议名称;length——本次数据或名称的有效字节数;size——本次数据的字节数;time——输入CP56日历时标。
|
||
* 输出参数:files——本次操作更新的实例或工作区。
|
||
* 返回值:无。
|
||
* 说明:调用点只枚举固定目录,最多两项;扩展演示清单时须同步核对固定快照容量,不能静默截断。
|
||
*/
|
||
static void Example_File_Entry(ExampleFileStore *files, const uint8_t *name, uint8_t length,
|
||
uint32_t size, const IEC60870_CP56Time2a_t *time)
|
||
{
|
||
ExampleFileDirectoryEntry *entry = &files->entries[files->entry_count++];
|
||
memcpy(entry->name, name, length);
|
||
entry->name_length = length;
|
||
entry->size = size;
|
||
entry->time = *time;
|
||
}
|
||
|
||
/**
|
||
* 功能:首次创建时固定演示文件的本地日历;时钟不可读则初始化失败,不伪造有效的文件时标。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:协议复位复用本模块和存储,不重新清空已经提交的TEMP文件。
|
||
*/
|
||
static inline bool Example_Init_FileService(ExampleApp *app)
|
||
{
|
||
IEC104_FileServiceConfig_t config;
|
||
IEC60870_ClockValue_t clock;
|
||
uint8_t encoded[IEC60870_CP56_LEN];
|
||
if (app->file_service != NULL || IEC60870_Clock_Read(&clock) == 0) { return false; }
|
||
memset(&app->files, 0, sizeof(app->files));
|
||
app->files.startup_time.time = clock.time;
|
||
app->files.startup_time.is_invalid = clock.is_invalid;
|
||
if (!IEC60870_Time_To_CP56(&app->files.startup_time, encoded, sizeof(encoded))) { return false; }
|
||
IEC104_FileService_Config_Default(&config);
|
||
app->file_service = IEC104_FileService_Create(app->slave, &config);
|
||
return app->file_service != NULL;
|
||
}
|
||
|
||
/**
|
||
* 功能:OPEN只准备快照或暂存;COMMIT在同一串行循环内发布,返回前释放暂存所有权。
|
||
* 输入参数:context——调用方注册的回调上下文;request——仅在当前回调期间借用的协议请求;open——文件打开结果回写位置。
|
||
* 输出参数:open——文件打开结果回写位置。
|
||
* 返回值:OK表示请求阶段处理成功;NAME_UNSUPPORTED、SIZE_OUT_OF_RANGE分别表示目标不支持和大小越界,FAILED表示身份、资源或存储处理失败。
|
||
* 说明:失败COMMIT也自行清理,协议不会再补ABORT;清理动作不要求原站仍注册。
|
||
* 历史目录和下载由独立适配器持有快照,录波借用冻结记录;owner 校验通过后才释放相应资源。
|
||
*/
|
||
static IEC104_FileServiceResult_t Example_File_Action(void *context,
|
||
const IEC104_FileServiceRequest_t *request, IEC104_FileServiceOpen_t *open)
|
||
{
|
||
ExampleApp *app = context;
|
||
ExampleFileStore *files = &app->files;
|
||
size_t index;
|
||
switch (request->call) {
|
||
case IEC104_FILE_SERVICE_CALL_CLOSE_DIRECTORY:
|
||
if (!Example_File_Owner(&files->directory, request)) { return IEC104_FILE_SERVICE_RESULT_FAILED; }
|
||
/* 历史和日志目录结束枚举后仍保留已列出的XML版本,供随后OPEN_READ取得一致文件。
|
||
* 必须先匹配原owner;日志故障也不能跳过关闭或误清另一请求的缓存。 */
|
||
if (files->directory_history) { Example_History_Directory_Close(app->history); }
|
||
files->directory_history = false;
|
||
if (files->directory_user_log) { Example_User_Log_Directory_Close(app->user_log); }
|
||
files->directory_user_log = false;
|
||
if (files->directory_energy) { Example_Energy_Freeze_Directory_Close(app->energy); }
|
||
files->directory_energy = false;
|
||
files->directory.active = false;
|
||
files->entry_count = 0U;
|
||
return IEC104_FILE_SERVICE_RESULT_OK;
|
||
case IEC104_FILE_SERVICE_CALL_CLOSE_READ:
|
||
if (!Example_File_Owner(&files->read, request)) { return IEC104_FILE_SERVICE_RESULT_FAILED; }
|
||
/* 历史和日志读句柄各自拥有独立临时副本;关闭不影响目录缓存,随后清除本次数据源标志。 */
|
||
if (files->read_history) { Example_History_Read_Close(app->history); }
|
||
files->read_history = false;
|
||
if (files->read_user_log) { Example_User_Log_Read_Close(app->user_log); }
|
||
files->read_user_log = false;
|
||
if (files->read_energy) { Example_Energy_Freeze_Read_Close(app->energy); }
|
||
files->read_energy = false;
|
||
files->read.active = false;
|
||
files->read_temp = false;
|
||
files->read_data = NULL;
|
||
files->read_recording = 0U;
|
||
files->read_size = 0U;
|
||
return IEC104_FILE_SERVICE_RESULT_OK;
|
||
case IEC104_FILE_SERVICE_CALL_ABORT_WRITE:
|
||
if (Example_File_Owner(&example_upgrade_device.file, request)) {
|
||
return Example_Upgrade_File_Finish(app, request);
|
||
}
|
||
if (!Example_File_Owner(&files->stage, request)) { return IEC104_FILE_SERVICE_RESULT_FAILED; }
|
||
files->stage.active = false;
|
||
files->stage_received = 0U;
|
||
return IEC104_FILE_SERVICE_RESULT_OK;
|
||
case IEC104_FILE_SERVICE_CALL_COMMIT:
|
||
if (Example_File_Owner(&example_upgrade_device.file, request)) {
|
||
return Example_Upgrade_File_Finish(app, request);
|
||
}
|
||
if (!Example_File_Owner(&files->stage, request)) { return IEC104_FILE_SERVICE_RESULT_FAILED; }
|
||
/* 失败前未触碰已提交区;成功发布仅一次,不以随后确认WAIT/丢失回滚。 */
|
||
files->stage.active = false;
|
||
if (files->stage_received != files->stage_size || files->read_temp) {
|
||
files->stage_received = 0U;
|
||
return IEC104_FILE_SERVICE_RESULT_FAILED;
|
||
}
|
||
/* 先保存完整名称/时标/内容快照,失败时磁盘与RAM均保留旧文件。
|
||
* 复制中途没有其他消费者观察此区;成功后确认丢失也不能回滚已提交文件。 */
|
||
if (app->config_path != NULL) {
|
||
ExampleTempConfig candidate = {0};
|
||
ExampleConfigResult result;
|
||
candidate.present = true;
|
||
candidate.name = files->stage_name;
|
||
candidate.name_length = files->stage_name_length;
|
||
candidate.bytes = files->stage_bytes;
|
||
candidate.size = files->stage_size;
|
||
candidate.time = files->startup_time;
|
||
result = Example_Config_Store(app, NULL, &candidate);
|
||
if (result != EXAMPLE_CONFIG_OK) {
|
||
fprintf(stderr, "FILE_CONFIG save failed: %s\n", Example_Config_Result_Name(result));
|
||
files->stage_received = 0U;
|
||
return IEC104_FILE_SERVICE_RESULT_FAILED;
|
||
}
|
||
puts("FILE_CONFIG SAVED"); fflush(stdout);
|
||
}
|
||
memcpy(files->file_bytes, files->stage_bytes, files->stage_size);
|
||
memcpy(files->file_name, files->stage_name, files->stage_name_length);
|
||
files->file_name_length = files->stage_name_length;
|
||
files->file_size = files->stage_size;
|
||
files->file_time = files->startup_time;
|
||
files->present = true;
|
||
files->stage_received = 0U;
|
||
return IEC104_FILE_SERVICE_RESULT_OK;
|
||
default: break;
|
||
}
|
||
/* 新OPEN只允许当前已注册站;上面的收尾先按旧owner处理,避免注销后无法归还旧资源。 */
|
||
if (open == NULL || request->identity.slave != app->slave ||
|
||
!IEC104_Station_Is_Registered(&app->station) ||
|
||
request->station_id != IEC104_Station_Get_Id(&app->station) ||
|
||
request->common_address != IEC104_Station_Get_Common_Address(&app->station)) {
|
||
return IEC104_FILE_SERVICE_RESULT_FAILED;
|
||
}
|
||
if (request->call == IEC104_FILE_SERVICE_CALL_OPEN_DIRECTORY) {
|
||
if (!Example_File_Open_Resource(files, &files->directory, request, open)) {
|
||
return IEC104_FILE_SERVICE_RESULT_FAILED;
|
||
}
|
||
files->entry_count = 0U;
|
||
files->directory_exists = false;
|
||
files->directory_history = false;
|
||
files->directory_user_log = false;
|
||
files->directory_energy = false;
|
||
if (app->energy != NULL &&
|
||
(Example_File_Name_Is(request->name, request->name_length, "HISTORY/FRZ") ||
|
||
Example_File_Name_Is(request->name, request->name_length, "HISTORY/FLOWREV"))) {
|
||
if (!Example_Energy_Freeze_Directory_Open(app->energy, request->name, request->name_length)) {
|
||
files->directory.active = false;
|
||
return IEC104_FILE_SERVICE_RESULT_FAILED;
|
||
}
|
||
files->directory_energy = files->directory_exists = true;
|
||
return IEC104_FILE_SERVICE_RESULT_OK;
|
||
}
|
||
/* 运行日志单独启用;目录按名称匹配,目录编号不参与后端路由。
|
||
* 已登记协议资源后才冻结文件;失败撤回本次active,不能让后续LIST读取半份清单。 */
|
||
if (app->user_log != NULL && Example_File_Name_Is(request->name, request->name_length, "HISTORY/ULOG")) {
|
||
if (!Example_User_Log_Directory_Open(app->user_log, request->name, request->name_length)) {
|
||
files->directory.active = false;
|
||
return IEC104_FILE_SERVICE_RESULT_FAILED;
|
||
}
|
||
files->directory_user_log = files->directory_exists = true;
|
||
return IEC104_FILE_SERVICE_RESULT_OK;
|
||
}
|
||
/* 历史模式按目录名切换到持久数据;空目录继续代表 SOE,不依赖主站目录编号。
|
||
* 适配器冻结清单,协议随后使用条目时间筛选,不能在 list 重试时重建。 */
|
||
if (app->history != NULL && (request->name_length == 0U ||
|
||
Example_File_Name_Is(request->name, request->name_length, "HISTORY/SOE") ||
|
||
Example_File_Name_Is(request->name, request->name_length, "HISTORY/CO") ||
|
||
Example_File_Name_Is(request->name, request->name_length, "HISTORY/EXV") ||
|
||
Example_File_Name_Is(request->name, request->name_length, "HISTORY/FIXPT"))) {
|
||
const uint8_t *name = request->name_length == 0U ? (const uint8_t *)"HISTORY/SOE" : request->name;
|
||
size_t length = request->name_length == 0U ? strlen("HISTORY/SOE") : request->name_length;
|
||
if (!Example_History_Directory_Open(app->history, name, length)) {
|
||
files->directory.active = false;
|
||
return IEC104_FILE_SERVICE_RESULT_FAILED;
|
||
}
|
||
files->directory_history = files->directory_exists = true;
|
||
return IEC104_FILE_SERVICE_RESULT_OK;
|
||
}
|
||
/* 默认目录固定为HISTORY/SOE。时间过滤交给协议模块,快照不因重试或过滤而重建。 */
|
||
for (index = 0U; index < sizeof(example_files) / sizeof(example_files[0]); ++index) {
|
||
if ((request->name_length == 0U && index == 0U) ||
|
||
Example_File_Name_Is(request->name, request->name_length, example_files[index].directory)) {
|
||
files->directory_exists = true;
|
||
Example_File_Entry(files, (const uint8_t *)example_files[index].path,
|
||
(uint8_t)strlen(example_files[index].path), (uint32_t)example_files[index].size,
|
||
&files->startup_time);
|
||
}
|
||
}
|
||
if (Example_File_Name_Is(request->name, request->name_length, "TEMP")) {
|
||
files->directory_exists = true;
|
||
if (files->present) {
|
||
Example_File_Entry(files, files->file_name, files->file_name_length,
|
||
files->file_size, &files->file_time);
|
||
}
|
||
}
|
||
if (Example_File_Name_Is(request->name, request->name_length, "COMTRADE")) {
|
||
files->directory_exists = true;
|
||
/* 两个文件均落盘且故障简报已入队后才一起列出;名称包含COMTRADE/,供主站原样回传。
|
||
* 清单复制到本次目录快照,后续list重取同一下标时不能看到变化中的条目。 */
|
||
if (app->recording != NULL && app->recording->saved && app->recording->published) {
|
||
for (index = 0U; index < 2U; ++index) {
|
||
Example_File_Entry(files, (const uint8_t *)app->recording->paths[index],
|
||
(uint8_t)strlen(app->recording->paths[index]),
|
||
index == 0U ? (uint32_t)app->recording->cfg_size : app->recording->dat_size,
|
||
&app->recording->trigger_time);
|
||
}
|
||
}
|
||
}
|
||
/* 不存在的目录也成功持有本次快照;list返回NO_DIRECTORY后仍由协议交付一次CLOSE。 */
|
||
return IEC104_FILE_SERVICE_RESULT_OK;
|
||
}
|
||
if (request->call == IEC104_FILE_SERVICE_CALL_OPEN_READ) {
|
||
const uint8_t *data = NULL, *name = NULL;
|
||
uint32_t size = 0U;
|
||
uint8_t length = 0U;
|
||
bool temporary = false;
|
||
unsigned recording_index = 0U;
|
||
/* 电能量目录独立启用,先于通用HISTORY分支路由;后端严格验证完整文件名。 */
|
||
if (app->energy != NULL && request->name != NULL &&
|
||
((request->name_length >= 12U && memcmp(request->name, "HISTORY/FRZ/", 12U) == 0) ||
|
||
(request->name_length >= 16U && memcmp(request->name, "HISTORY/FLOWREV/", 16U) == 0))) {
|
||
if (files->read.active ||
|
||
!Example_Energy_Freeze_Read_Open(app->energy, request->name, request->name_length, &size)) {
|
||
return IEC104_FILE_SERVICE_RESULT_FAILED;
|
||
}
|
||
if (!Example_File_Open_Resource(files, &files->read, request, open)) {
|
||
Example_Energy_Freeze_Read_Close(app->energy);
|
||
return IEC104_FILE_SERVICE_RESULT_FAILED;
|
||
}
|
||
files->read_energy = true;
|
||
files->read_user_log = files->read_history = files->read_temp = false;
|
||
files->read_recording = 0U;
|
||
files->read_data = NULL;
|
||
files->read_size = open->size = size;
|
||
return IEC104_FILE_SERVICE_RESULT_OK;
|
||
}
|
||
/* 启用后ULOG路径只允许真实XML,旧演示名或别名不得回落成固定文本。
|
||
* 先冻结完整文件,再发布协议资源;失败时只关闭本次候选。 */
|
||
if (app->user_log != NULL && request->name != NULL && request->name_length >= 13U &&
|
||
memcmp(request->name, "HISTORY/ULOG/", 13U) == 0) {
|
||
if (files->read.active ||
|
||
!Example_User_Log_Read_Open(app->user_log, request->name, request->name_length, &size)) {
|
||
return IEC104_FILE_SERVICE_RESULT_FAILED;
|
||
}
|
||
if (!Example_File_Open_Resource(files, &files->read, request, open)) {
|
||
Example_User_Log_Read_Close(app->user_log);
|
||
return IEC104_FILE_SERVICE_RESULT_FAILED;
|
||
}
|
||
files->read_user_log = true;
|
||
files->read_history = files->read_temp = false;
|
||
files->read_recording = 0U;
|
||
files->read_data = NULL;
|
||
files->read_size = open->size = size;
|
||
return IEC104_FILE_SERVICE_RESULT_OK;
|
||
}
|
||
/* 历史路径由适配器严格匹配,避免回落到固定 SOE 演示文本;日志演示仍沿用原分支。
|
||
* 先打开完整快照,后登记协议资源;登记失败时立即关闭候选,不遗留活动读句柄。 */
|
||
if (app->history != NULL && request->name != NULL && request->name_length > 8U &&
|
||
memcmp(request->name, "HISTORY/", 8U) == 0 &&
|
||
!Example_File_Name_Is(request->name, request->name_length, "HISTORY/ULOG/ulog.msg")) {
|
||
if (files->read.active ||
|
||
!Example_History_Read_Open(app->history, request->name, request->name_length, &size)) {
|
||
return IEC104_FILE_SERVICE_RESULT_FAILED;
|
||
}
|
||
if (!Example_File_Open_Resource(files, &files->read, request, open)) {
|
||
Example_History_Read_Close(app->history);
|
||
return IEC104_FILE_SERVICE_RESULT_FAILED;
|
||
}
|
||
files->read_history = true;
|
||
files->read_user_log = false;
|
||
files->read_temp = false;
|
||
files->read_recording = 0U;
|
||
files->read_data = NULL;
|
||
files->read_size = open->size = size;
|
||
return IEC104_FILE_SERVICE_RESULT_OK;
|
||
}
|
||
for (index = 0U; index < sizeof(example_files) / sizeof(example_files[0]); ++index) {
|
||
if (Example_File_Name_Is(request->name, request->name_length, example_files[index].path)) {
|
||
data = example_files[index].data;
|
||
size = (uint32_t)example_files[index].size;
|
||
name = (const uint8_t *)example_files[index].path;
|
||
length = (uint8_t)strlen(example_files[index].path);
|
||
break;
|
||
}
|
||
}
|
||
/* OPEN_READ沿用目录的可见性门禁,防止绕过召目录提前读到录波。
|
||
* 只匹配目录中给出的完整路径;本分支按冻结记录编码,data可以保持NULL。 */
|
||
if (app->recording != NULL && app->recording->saved && app->recording->published) {
|
||
for (index = 0U; index < 2U; ++index) {
|
||
if (Example_File_Name_Is(request->name, request->name_length, app->recording->paths[index])) {
|
||
recording_index = (unsigned)index + 1U;
|
||
size = index == 0U ? (uint32_t)app->recording->cfg_size : app->recording->dat_size;
|
||
name = (const uint8_t *)app->recording->paths[index];
|
||
length = (uint8_t)strlen(app->recording->paths[index]);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (data == NULL && files->present && request->name != NULL &&
|
||
request->name_length == files->file_name_length &&
|
||
memcmp(request->name, files->file_name, files->file_name_length) == 0) {
|
||
/* 暂存已打开就拒绝新的TEMP读取;反向由OPEN_WRITE检查read_temp,避免发布撞上读锁。 */
|
||
if (files->stage.active) { return IEC104_FILE_SERVICE_RESULT_FAILED; }
|
||
data = files->file_bytes;
|
||
size = files->file_size;
|
||
name = files->file_name;
|
||
length = files->file_name_length;
|
||
temporary = true;
|
||
}
|
||
if ((data == NULL && recording_index == 0U) || !Example_File_Open_Resource(files, &files->read, request, open)) {
|
||
return IEC104_FILE_SERVICE_RESULT_FAILED;
|
||
}
|
||
files->read_data = data;
|
||
files->read_size = size;
|
||
files->read_temp = temporary;
|
||
files->read_recording = recording_index;
|
||
files->read_history = false;
|
||
files->read_user_log = false;
|
||
/* 回显名来自常驻表或应用文件名数组,返回后仍有效,协议可立即复制;不借用局部数组。 */
|
||
open->size = size;
|
||
open->name = name;
|
||
open->name_length = length;
|
||
return IEC104_FILE_SERVICE_RESULT_OK;
|
||
}
|
||
if (request->call == IEC104_FILE_SERVICE_CALL_OPEN_WRITE) {
|
||
/* 用途在OPEN固定:保留升级名无论因何被拒绝,都直接返回,不降级到普通TEMP写入。 */
|
||
if (Example_File_Name_Is(request->name, request->name_length, "upgrade.bin")) {
|
||
return Example_Upgrade_File_Open(app, request, open);
|
||
}
|
||
/* 先判实际名称白名单,再检查大小及暂存占用;拒绝请求不会破坏前一次尚待COMMIT的候选。 */
|
||
if (!Example_File_Temp_Name(request->name, request->name_length)) {
|
||
return IEC104_FILE_SERVICE_RESULT_NAME_UNSUPPORTED;
|
||
}
|
||
if (request->file_size > EXAMPLE_FILE_BYTES) { return IEC104_FILE_SERVICE_RESULT_SIZE_OUT_OF_RANGE; }
|
||
if (request->test || files->read_temp || !Example_File_Open_Resource(files, &files->stage, request, open)) {
|
||
return IEC104_FILE_SERVICE_RESULT_FAILED;
|
||
}
|
||
memcpy(files->stage_name, request->name, request->name_length);
|
||
files->stage_name_length = request->name_length;
|
||
files->stage_size = request->file_size;
|
||
files->stage_received = 0U;
|
||
return IEC104_FILE_SERVICE_RESULT_OK;
|
||
}
|
||
return IEC104_FILE_SERVICE_RESULT_FAILED;
|
||
}
|
||
|
||
/**
|
||
* 功能:只读快照,不在index=0重建;WAIT重取只返回同一条,不消费记录或按当前文件重新计算。
|
||
* 输入参数:context——调用方注册的回调上下文;request——仅在当前回调期间借用的协议请求;index——本次条目、点或逻辑槽的下标;entry——目录条目。
|
||
* 输出参数:entry——目录条目。
|
||
* 返回值:ENTRY表示取得目录条目,END表示枚举结束,NO_DIRECTORY表示首项请求的目录不存在,ERROR表示资源身份或快照读取失败。
|
||
* 说明:无。
|
||
*/
|
||
static IEC104_FileServiceListResult_t Example_File_List(void *context,
|
||
const IEC104_FileServiceRequest_t *request, size_t index, IEC104_FileServiceEntry_t *entry)
|
||
{
|
||
ExampleFileStore *files = &((ExampleApp *)context)->files;
|
||
const ExampleFileDirectoryEntry *saved;
|
||
if (!Example_File_Owner(&files->directory, request)) { return IEC104_FILE_SERVICE_LIST_ERROR; }
|
||
if (files->directory_energy) {
|
||
ExampleEnergyFreeze *energy = ((ExampleApp *)context)->energy;
|
||
if (index >= Example_Energy_Freeze_Directory_Count(energy)) { return IEC104_FILE_SERVICE_LIST_END; }
|
||
if (!Example_Energy_Freeze_Directory_Get(energy, index, &files->energy_entry)) {
|
||
return IEC104_FILE_SERVICE_LIST_ERROR;
|
||
}
|
||
entry->name = (const uint8_t *)files->energy_entry.name;
|
||
entry->name_length = (uint8_t)strlen(files->energy_entry.name);
|
||
entry->attribute = 0U;
|
||
entry->size = files->energy_entry.size;
|
||
entry->time = files->energy_entry.time;
|
||
return IEC104_FILE_SERVICE_LIST_ENTRY;
|
||
}
|
||
if (files->directory_user_log) {
|
||
/* LIST可因发送WAIT重取同一index,只拷贝冻结条目;名称借自常驻字段,回调返回后仍可编码。 */
|
||
ExampleUserLog *log = ((ExampleApp *)context)->user_log;
|
||
if (index >= Example_User_Log_Directory_Count(log)) { return IEC104_FILE_SERVICE_LIST_END; }
|
||
if (!Example_User_Log_Directory_Get(log, index, &files->user_log_entry)) { return IEC104_FILE_SERVICE_LIST_ERROR; }
|
||
entry->name = (const uint8_t *)files->user_log_entry.name;
|
||
entry->name_length = (uint8_t)strlen(files->user_log_entry.name);
|
||
entry->attribute = 0U;
|
||
entry->size = files->user_log_entry.size;
|
||
entry->time = files->user_log_entry.time;
|
||
return IEC104_FILE_SERVICE_LIST_ENTRY;
|
||
}
|
||
if (files->directory_history) {
|
||
/* 名称复制到常驻 history_entry,供本次回调返回后协议编码,不能借用局部结构体字段。 */
|
||
ExampleHistory *history = ((ExampleApp *)context)->history;
|
||
if (index >= Example_History_Directory_Count(history)) { return IEC104_FILE_SERVICE_LIST_END; }
|
||
if (!Example_History_Directory_Get(history, index, &files->history_entry)) {
|
||
return IEC104_FILE_SERVICE_LIST_ERROR;
|
||
}
|
||
entry->name = (const uint8_t *)files->history_entry.name;
|
||
entry->name_length = (uint8_t)strlen(files->history_entry.name);
|
||
entry->attribute = 0U;
|
||
entry->size = files->history_entry.size;
|
||
entry->time = files->history_entry.time;
|
||
return IEC104_FILE_SERVICE_LIST_ENTRY;
|
||
}
|
||
if (!files->directory_exists) {
|
||
return index == 0U ? IEC104_FILE_SERVICE_LIST_NO_DIRECTORY : IEC104_FILE_SERVICE_LIST_ERROR;
|
||
}
|
||
if (index >= EXAMPLE_FILE_DIRECTORY_ITEMS || index >= files->entry_count) {
|
||
return IEC104_FILE_SERVICE_LIST_END;
|
||
}
|
||
saved = &files->entries[index];
|
||
entry->name = saved->name;
|
||
entry->name_length = saved->name_length;
|
||
entry->attribute = 0U;
|
||
entry->size = saved->size;
|
||
entry->time = saved->time;
|
||
return IEC104_FILE_SERVICE_LIST_ENTRY;
|
||
}
|
||
|
||
/**
|
||
* 功能:read没有消费游标;每次完全按offset取相同内容,适合IDLE提交WAIT后的同偏移重取。
|
||
* 输入参数:context——调用方注册的回调上下文;request——仅在当前回调期间借用的协议请求;offset——从起点计算的字节偏移;buffer——调用方提供的数据缓冲;length——本次数据或名称的有效字节数。
|
||
* 输出参数:buffer——调用方提供的数据缓冲。
|
||
* 返回值:true表示指定范围的数据已完整读出;false表示范围非法、读取失败或短读。
|
||
* 说明:先检查offset再做减法,避免offset+length溢出绕过应用缓冲边界;空文件不解引用buffer。
|
||
*/
|
||
static bool Example_File_Read(void *context, const IEC104_FileServiceRequest_t *request,
|
||
uint32_t offset, uint8_t *buffer, uint16_t length)
|
||
{
|
||
ExampleFileStore *files = &((ExampleApp *)context)->files;
|
||
if (!Example_File_Owner(&files->read, request) || offset > files->read_size ||
|
||
length > files->read_size - offset || (length != 0U && buffer == NULL)) { return false; }
|
||
if (files->read_energy) {
|
||
return Example_Energy_Freeze_Read(((ExampleApp *)context)->energy, offset, buffer, length);
|
||
}
|
||
if (files->read_user_log) {
|
||
return Example_User_Log_Read(((ExampleApp *)context)->user_log, offset, buffer, length);
|
||
}
|
||
if (files->read_history) {
|
||
/* 历史分支读取已冻结的临时文件,后台环形覆盖或重新召目录不会改变本会话字节。 */
|
||
return Example_History_Read(((ExampleApp *)context)->history, offset, buffer, length);
|
||
}
|
||
if (files->read_recording != 0U) {
|
||
/* 读会话绑定同一份冻结记录;任意偏移或重试都得到相同字节,网络回调不访问磁盘。 */
|
||
return Example_Recording_Read(((ExampleApp *)context)->recording,
|
||
files->read_recording - 1U, offset, buffer, length);
|
||
}
|
||
if (length != 0U) { memcpy(buffer, files->read_data + offset, length); }
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:模块检查线上偏移和模和,应用再次防御性检查自己的缓冲边界;分段仅写RAM,COMMIT才落盘。
|
||
* 输入参数:context——调用方注册的回调上下文;request——仅在当前回调期间借用的协议请求;offset——从起点计算的字节偏移;data——字节数据缓冲;length——本次数据或名称的有效字节数;last——是否为本次上传的末段。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:读锁与暂存互斥使TEMP内容在整次读会话内不变,COMMIT前所有读者仍只见旧完整文件。
|
||
* last仅验证完整长度,write仍不发布;确认排序和一次COMMIT由协议模块推进。
|
||
*/
|
||
static bool Example_File_Write(void *context, const IEC104_FileServiceRequest_t *request,
|
||
uint32_t offset, const uint8_t *data, uint16_t length, bool last)
|
||
{
|
||
ExampleFileStore *files = &((ExampleApp *)context)->files;
|
||
if (Example_File_Owner(&example_upgrade_device.file, request)) {
|
||
return Example_Upgrade_File_Write(context, request, offset, data, length, last);
|
||
}
|
||
if (!Example_File_Owner(&files->stage, request) || request->test ||
|
||
offset != files->stage_received || offset > files->stage_size ||
|
||
length > files->stage_size - offset || (last && length != files->stage_size - offset) ||
|
||
(length != 0U && data == NULL)) { return false; }
|
||
if (length != 0U) { memcpy(files->stage_bytes + offset, data, length); }
|
||
files->stage_received += length;
|
||
return true;
|
||
}
|
||
|
||
/* 全过程使用同一组回调及app上下文,旧资源收尾前不得换到另一份文件存储。 */
|
||
static const IEC104_FileServiceHandlers_t example_file_handlers = {
|
||
Example_File_List, Example_File_Action, Example_File_Read, Example_File_Write
|
||
};
|
||
|
||
/**
|
||
* 功能:用触发时的冻结帧发布TI42故障简报,入队成功后再开放成对录波文件。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:输入为调用者长期持有的模拟录波;本函数不重新采样、不改触发时间,也不从文件名反推故障。
|
||
* WAIT保留published=false,下一轮重试同一组数值和时标;true也可能表示仍待重试。
|
||
* OK仅代表发布队列已接收,不代表主站ACK或持久送达;覆盖/断线/复位仍受发布模块规则约束。
|
||
*/
|
||
static bool Example_Publish_Recording(ExampleApp *app)
|
||
{
|
||
IEC104_SpontaneousFaultEvent_t report;
|
||
IEC104_SpontaneousPublishInfo_t info;
|
||
IEC104_SpontaneousPublishResult_t result;
|
||
IEC60870_FaultEventSignal_t signal;
|
||
IEC60870_FaultEventMeasurement_t measurements[8];
|
||
IEC60870_FaultRecorderFrame_t frame;
|
||
ExampleRecording *recording = app->recording;
|
||
unsigned index;
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
if (recording != NULL && app->dtu_recording_directory != NULL && app->dtu_recording_pending != 0U &&
|
||
!app->files.directory.active && !app->files.read.active && (!recording->complete || recording->published)) {
|
||
if (app->dtu_recording_sequence == 9999U ||
|
||
!Example_Recording_Capture(recording, &app->dtu_recording_time, 1U,
|
||
(uint16_t)(app->dtu_recording_sequence + 1U), app->dtu_recording_before, app->dtu_recording_after,
|
||
app->dtu_recording_before_digital, app->dtu_recording_after_digital) ||
|
||
!Example_Recording_Save(recording, app->dtu_recording_directory)) {
|
||
fputs("DTU triggered recording failed\n", stderr); return false;
|
||
}
|
||
++app->dtu_recording_sequence;
|
||
printf("DTU_RECORDING reasons=%lu %s %s\n", (unsigned long)app->dtu_recording_pending,
|
||
recording->paths[0], recording->paths[1]);
|
||
fflush(stdout);
|
||
app->dtu_recording_pending = 0U;
|
||
app->dtu_digital[8U] = app->dtu_digital[0x46U] = 1U;
|
||
}
|
||
if (recording != NULL && app->dtu_recording_directory != NULL && !recording->complete) { return true; }
|
||
#endif
|
||
if (recording == NULL || recording->published) { return true; }
|
||
/* 本演示固定4 kHz、故障前4周波,逻辑下标320为触发点;它不是实时遥测的当前帧。 */
|
||
if (!recording->saved || !IEC60870_FaultRecorder_Get_Frame(&recording->recorder, 320U, &frame)) {
|
||
return false;
|
||
}
|
||
memset(&report, 0, sizeof(report));
|
||
memset(&signal, 0, sizeof(signal));
|
||
memset(measurements, 0, sizeof(measurements));
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
signal.ioa = 0x0022U;
|
||
#else
|
||
signal.ioa = 2U;
|
||
#endif
|
||
signal.value = 1U; signal.timestamp = recording->trigger_time;
|
||
/* 通道依次Ua/Ub/Uc/U0/Ia/Ib/Ic/I0,标度须与示例CFG的0.01 V、0.001 A一致。 */
|
||
for (index = 0U; index < 8U; ++index) {
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
/* PT1相压和零序、保护三相和零序电流,使用DTU实际点表地址。 */
|
||
static const uint32_t ioas[8] = {0x400CU, 0x400DU, 0x400EU, 0x400FU,
|
||
0x4015U, 0x4016U, 0x4017U, 0x4018U};
|
||
measurements[index].ioa = ioas[index];
|
||
#else
|
||
measurements[index].ioa = EXAMPLE_IOA_MEASUREMENT_BASE + index;
|
||
#endif
|
||
measurements[index].value.short_float = (float)frame.analog[index] / (index < 4U ? 100.0f : 1000.0f);
|
||
}
|
||
report.common_address = IEC104_Station_Get_Common_Address(&app->station);
|
||
report.station_id = IEC104_Station_Get_Id(&app->station);
|
||
IEC60870_FaultEvent_Init(&report.event);
|
||
report.event.signals = &signal; report.event.signal_count = 1U;
|
||
report.event.measurements = measurements; report.event.measurement_count = 8U;
|
||
/* Publish在本次调用内编码并复制内容,不借用这两个局部数组到函数返回之后。 */
|
||
result = IEC104_Spontaneous_Publish_Fault_Event(app->spontaneous, &report, &info);
|
||
if (result == IEC104_SPONTANEOUS_PUBLISH_ERROR) { return false; }
|
||
/* published 只标记本次简报已被发布模块接手,目录/直接读取共同使用此门,不等主站回执。 */
|
||
if (result == IEC104_SPONTANEOUS_PUBLISH_OK) { recording->published = true; }
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:普通推进位于参数之后、周期扫描之前;文件确认先进入HIGH,读数据先尝试共享IDLE机会。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。
|
||
* 说明:faulted由主循环停止服务并Cancel/排空收尾,不在此销毁重建或重复不可撤销的COMMIT。
|
||
*/
|
||
static bool Example_Step_FileService(ExampleApp *app)
|
||
{
|
||
IEC104_FileServiceExecuteResult_t result;
|
||
if (app->file_service == NULL) { return true; }
|
||
if (!IEC104_FileService_Process(app->file_service)) { return false; }
|
||
result = IEC104_FileService_Execute_Next(app->file_service, &example_file_handlers, app);
|
||
return result != IEC104_FILE_SERVICE_EXECUTE_ERROR && IEC104_FileService_Process(app->file_service) &&
|
||
IEC104_FileService_Get_Status(app->file_service, &app->file_status) && !app->file_status.faulted;
|
||
}
|
||
|
||
/**
|
||
* 功能:严格调度把控制与数据分开;CONTROL仍交付本地写入和资源收尾,DATA只推进已打开的读数据。
|
||
* 输入参数:app——示例应用上下文;mode——文件服务控制或数据执行阶段;executed——本轮执行结果回写位置。
|
||
* 输出参数:executed——本轮执行结果回写位置。
|
||
* 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。
|
||
* 说明:两阶段都保留Process,使目录/确认重试和期限照常推进;实际IDLE机会由发送层按当前等级裁决。
|
||
* executed 可选,用于区分本轮确有本地进展还是等待;函数成功不代表文件传输已结束。
|
||
*/
|
||
static bool Example_Step_FileService_Mode(ExampleApp *app, IEC104_FileServiceExecuteMode_t mode,
|
||
IEC104_FileServiceExecuteResult_t *executed)
|
||
{
|
||
IEC104_FileServiceExecuteResult_t result;
|
||
if (executed != NULL) { *executed = IEC104_FILE_SERVICE_EXECUTE_EMPTY; }
|
||
if (app->file_service == NULL) { return true; }
|
||
if (!IEC104_FileService_Process(app->file_service)) { return false; }
|
||
result = IEC104_FileService_Execute_Next_Mode(app->file_service, &example_file_handlers, app, mode);
|
||
if (executed != NULL) { *executed = result; }
|
||
return result != IEC104_FILE_SERVICE_EXECUTE_ERROR && IEC104_FileService_Process(app->file_service) &&
|
||
IEC104_FileService_Get_Status(app->file_service, &app->file_status) && !app->file_status.faulted;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [PERIODIC_SCAN/INIT] 扫描初始化:应用持有点表,模块复制组配置
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:app已由Example_Init绑定Slave和站点;cyclic_ms/background_ms分别是周期上送、背景扫描的组周期。
|
||
* 输入参数:app——示例应用上下文;cyclic_ms——周期上送间隔,单位毫秒;background_ms——背景扫描间隔,单位毫秒;sequence——是否使用SQ连续地址编码。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:两者均为0时不创建模块;否则须在消费首条连接通知前绑定,单组的0表示停用。
|
||
* 组0为COT=1遥测,组1为COT=2遥测;下标顺序使周期上送先使用同一轮留下的空闲发送机会。
|
||
* CLI默认关闭组0,仅每30秒以组1刷新当前值;这是低频刷新,不按变化门限筛选或重设COT3基准。
|
||
* 两组配置由Create复制,局部groups可在返回后消失;点表借用ExampleApp的固定存储至Destroy。
|
||
* 同时启用参数和周期组时使用点级周期;其余情况保留组周期模式。
|
||
* 返回true表示已创建或两组均关闭,false表示重复初始化或配置/静态池分配失败,由调用方统一回退。
|
||
*/
|
||
static inline bool Example_Init_PeriodicScan_Reserve(ExampleApp *app, uint32_t cyclic_ms,
|
||
uint32_t background_ms, bool sequence, uint16_t window_reserve)
|
||
{
|
||
IEC104_PeriodicScanConfig_t config;
|
||
IEC104_PeriodicScanGroupConfig_t groups[2] = {
|
||
{0U, 0U, IEC60870_ASDU_COT_PERIODIC, 0U, 0U},
|
||
{0U, 0U, IEC60870_ASDU_COT_BACKGROUND, 0U, 0U}
|
||
};
|
||
uint16_t ca = IEC104_Station_Get_Common_Address(&app->station);
|
||
size_t index;
|
||
if (app->periodic_scan != NULL) { return false; }
|
||
if (cyclic_ms == 0U && background_ms == 0U) { return true; }
|
||
/* 两个扫描组均只登记遥测,遥信在总召外由带CP56的变位、读取和遥控反馈路径提供。
|
||
* 扫描模块当前只接收无时标类型,不能只往点表填入30/31就扩展为带时标遥信扫描。 */
|
||
for (index = 0U; index < EXAMPLE_SCAN_POINT_COUNT; ++index) {
|
||
IEC104_PeriodicScanPoint_t *point = &app->scan_points[index];
|
||
point->common_address = ca;
|
||
point->type_id = EXAMPLE_MEASUREMENT_TYPE;
|
||
point->ioa = example_measurements[index].ioa;
|
||
point->groups = 0x03U;
|
||
}
|
||
/* 示例首轮延迟取各组一个周期,让STARTDT后的首轮也能观察到等待;这是示例策略,库默认延迟为0。 */
|
||
groups[0].period_ms = groups[0].first_delay_ms = cyclic_ms;
|
||
groups[1].period_ms = groups[1].first_delay_ms = background_ms;
|
||
/* 每个(CA, Type)段都是完整的8点连续段,阈值2便于联调观察SQ=1;实际主站确认兼容后再打开。
|
||
* 默认阈值0保持SQ=0,周期与背景组分别组帧,不会因共享测点把两种COT混在一帧。 */
|
||
groups[0].sequence_min_run = groups[1].sequence_min_run = sequence ? 2U : 0U;
|
||
/* 其余沿用库默认:reserve=2、OA=0、每帧按容量、每次Step至多交接一帧。 */
|
||
IEC104_PeriodicScan_Config_Default(&config);
|
||
config.window_reserve = window_reserve;
|
||
config.points = app->scan_points;
|
||
config.point_count = EXAMPLE_SCAN_POINT_COUNT;
|
||
config.groups = groups;
|
||
config.group_count = 2U;
|
||
/* QPA=3需要单点启停;只在参数和非零周期同时开启时改用点级组,保持其他CLI组合的原行为。
|
||
* 8项周期数组均为周期遥测;位图按全表每点1位提供,Create负责清零并独占维护。
|
||
* 两份存储均借用至Destroy,Create后只能用Set_Point_Period改周期,不能直接赋值或memset。 */
|
||
if (app->parameter != NULL && cyclic_ms != 0U) {
|
||
groups[0].point_period = 1U;
|
||
app->parameter_cyclic_ms = cyclic_ms;
|
||
for (index = 0U; index < EXAMPLE_SCAN_POINT_COUNT; ++index) {
|
||
app->point_period_ms[index] = (app->scan_points[index].groups & 1U) != 0U ? cyclic_ms : 0U;
|
||
}
|
||
config.point_period_ms = app->point_period_ms;
|
||
config.point_retry_pending = app->point_retry_pending;
|
||
config.point_retry_pending_size = sizeof(app->point_retry_pending);
|
||
}
|
||
app->periodic_scan = IEC104_PeriodicScan_Create(app->slave, &config);
|
||
return app->periodic_scan != NULL;
|
||
}
|
||
|
||
static inline bool Example_Init_PeriodicScan(ExampleApp *app, uint32_t cyclic_ms,
|
||
uint32_t background_ms, bool sequence)
|
||
{
|
||
return Example_Init_PeriodicScan_Reserve(app, cyclic_ms, background_ms, sequence, 2U);
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [PERIODIC_SCAN/LOOKUP] 空闲扫描共用应用当前值,不建立变化队列
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:读取周期或背景扫描请求的运行点并构造单对象ASDU。
|
||
* 输入参数:context——调用方注册的回调上下文;request——仅在当前回调期间借用的协议请求;object——单对象ASDU编码工作区。
|
||
* 输出参数:object——单对象ASDU编码工作区。
|
||
* 返回值:ADDED表示所请求运行点已加入ASDU,ERROR表示站点、地址、读取或编码失败。
|
||
* 说明:context为当前ExampleApp;request由模块借出,仅在本次回调中有效,包含所属组、COT、站点编号和IOA。
|
||
* object是模块已设好COT/CA/OA的SQ=0单对象临时容器;本回调只Create并Add恰好一个匹配对象,检查两步结果。
|
||
* 模块随后负责校验和合帧,SQ=1也不改变回调用法;回调不改容器头、不提交发送、不保存借用指针。
|
||
* 先核对站点context,再按Type和IOA映射到共享运行值数组,读到本轮已执行遥控更新后的当前值。
|
||
* 成功返回ADDED;站点/地址/类型或编码失败返回ERROR并由模块中止该组本轮,已交接帧不撤回。
|
||
* Send返回WAIT后同一点可能重新取值,因此这里不消费应用事件、不读后清零,也不缓存本次结果。
|
||
*/
|
||
static IEC104_PeriodicScanLookupResult_t Example_PeriodicScan_Point(void *context,
|
||
const IEC104_PeriodicScanRequest_t *request, IEC60870_Asdu_t *object)
|
||
{
|
||
ExampleApp *app = context;
|
||
IEC104_Station_t *station = IEC104_Slave_Get_Station_By_Id(app->slave, request->station_id);
|
||
size_t index;
|
||
if (IEC104_Station_Get_Context(station) != app) { return IEC104_PERIODIC_SCAN_LOOKUP_ERROR; }
|
||
switch (request->type_id) {
|
||
case IEC60870_ASDU_M_SP_NA_1: {
|
||
IEC60870_SinglePointInformation_t point;
|
||
index = request->ioa - EXAMPLE_IOA_SINGLE_BASE;
|
||
if (index >= EXAMPLE_SIGNAL_COUNT) { return IEC104_PERIODIC_SCAN_LOOKUP_ERROR; }
|
||
return IEC60870_SinglePointInformation_Create(&point, request->ioa,
|
||
app->signal_values[index], 0U) == IEC60870_ASDU_OK &&
|
||
IEC60870_Asdu_Add_InformationObject(object, &point.object) == IEC60870_ASDU_OK ?
|
||
IEC104_PERIODIC_SCAN_LOOKUP_ADDED : IEC104_PERIODIC_SCAN_LOOKUP_ERROR;
|
||
}
|
||
case IEC60870_ASDU_M_DP_NA_1: {
|
||
IEC60870_DoublePointInformation_t point;
|
||
index = request->ioa - EXAMPLE_IOA_DOUBLE_BASE;
|
||
if (index >= EXAMPLE_DOUBLE_COUNT) { return IEC104_PERIODIC_SCAN_LOOKUP_ERROR; }
|
||
return IEC60870_DoublePointInformation_Create(&point, request->ioa,
|
||
app->double_values[index], 0U) == IEC60870_ASDU_OK &&
|
||
IEC60870_Asdu_Add_InformationObject(object, &point.object) == IEC60870_ASDU_OK ?
|
||
IEC104_PERIODIC_SCAN_LOOKUP_ADDED : IEC104_PERIODIC_SCAN_LOOKUP_ERROR;
|
||
}
|
||
case EXAMPLE_MEASUREMENT_TYPE: {
|
||
ExampleMeasurementObject point;
|
||
index = request->ioa - EXAMPLE_IOA_MEASUREMENT_BASE;
|
||
if (index >= EXAMPLE_MEASUREMENT_COUNT) { return IEC104_PERIODIC_SCAN_LOOKUP_ERROR; }
|
||
return Example_Create_Measurement(&point, request->ioa,
|
||
app->scaled_values[index], Example_Measurement_Quality(app, index)) == IEC60870_ASDU_OK &&
|
||
IEC60870_Asdu_Add_InformationObject(object, &point.object) == IEC60870_ASDU_OK ?
|
||
IEC104_PERIODIC_SCAN_LOOKUP_ADDED : IEC104_PERIODIC_SCAN_LOOKUP_ERROR;
|
||
}
|
||
default: return IEC104_PERIODIC_SCAN_LOOKUP_ERROR;
|
||
}
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [SYSTEM_COMMAND/ACTION] Type104/107回显、Type70初始化结束、Type105复位许可与本站事件清除
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:Create只绑定模块,不登记初始化原因,也不启动网络。main须在消费首条Slave通知前调用。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:本例沿用默认标准功能及决定/ACK期限;启动同步启用时用EVERY_START,每轮重报初始化结束。
|
||
* 重报沿用登记的COI,不代表每次连接都执行设备上电初始化;仅ONCE无法为重连提供新轮完成证据。
|
||
* 未约定QRP128..255的专用语义,因此不启用FEATURE_RESET_PRIVATE。
|
||
* 接入专用复位时须同时补齐许可回调和Take_Reset后的qualifier分派,不能只打开功能位。
|
||
*/
|
||
static bool Example_Init_SystemCommand(ExampleApp *app)
|
||
{
|
||
IEC104_SystemCommandConfig_t config;
|
||
IEC104_Startup_Config_Default(NULL, &config, NULL, NULL, NULL);
|
||
app->system_command = IEC104_SystemCommand_Create(app->slave, &config);
|
||
return app->system_command != NULL;
|
||
}
|
||
|
||
/**
|
||
* 功能:库已检查请求站点仍注册且未被同CA新节点替换;这里仍用station_id取得原context。
|
||
* 输入参数:context——调用方注册的回调上下文;request——仅在当前回调期间借用的协议请求。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:ACCEPT表示本次复位限定词获准并完成允许的本地处理,REJECT表示站点、限定词或运行状态不允许。
|
||
* 说明:QRP=1仅许可,不能在回调中重启。真实设备可在许可前检查就地/远方、闭锁和运行状态。
|
||
* QRP=2只改变本CA应用缓存,发送层NORMAL由模块随后清除;不推进Slave、不自行发送确认。
|
||
* 返回REJECT的分支发生在任何修改之前;ACCEPT不表示NORMAL清除或后续确认必然成功。
|
||
*/
|
||
static IEC104_SystemCommandDecision_t Example_Reset_Action(void *context,
|
||
const IEC104_SystemCommandResetRequest_t *request)
|
||
{
|
||
ExampleApp *app = (ExampleApp *)context;
|
||
IEC104_Station_t *station = IEC104_Slave_Get_Station_By_Id(app->slave, request->station_id);
|
||
size_t index = 0U;
|
||
if (IEC104_Station_Get_Context(station) != app) { return IEC104_SYSTEM_COMMAND_DECISION_REJECT; }
|
||
if (request->qualifier == 1U) {
|
||
/* 本例Take_Reset后重建整个协议实例,只能在单站模型下授权。
|
||
* 多站集成须实现定向复位;某一站获准不能被扩大为所有站或整机的重启许可。 */
|
||
return station == &app->station && IEC104_Slave_Get_Station_Count(app->slave) == 1U ?
|
||
IEC104_SYSTEM_COMMAND_DECISION_ACCEPT : IEC104_SYSTEM_COMMAND_DECISION_REJECT;
|
||
}
|
||
/* 只实现QRP1/2;即使集成方开启专用入口,也必须明确拒绝尚未定义的QRP,不能按QRP2清缓存。 */
|
||
if (request->qualifier != 2U) { return IEC104_SYSTEM_COMMAND_DECISION_REJECT; }
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
/* QRP2清待发变位,保留当前遥信值。 */
|
||
app->dtu_signal_pending = 0U;
|
||
#endif
|
||
while (index < app->publication_count) {
|
||
ExamplePublication *entry = &app->publications[index];
|
||
if (entry->change.common_address != request->common_address) { ++index; continue; }
|
||
entry->time_tag_cleared = true;
|
||
/* 未决遥控占位还承担FINISHED配对,暂不移除;普通类型补报再应用同一形态清除规则。
|
||
* 独立SOE随后由核心按CA清除;保留旧票据以便FINISHED收尾,但解析不能重新生成已清原文。
|
||
* 删除普通条目会把下一条移到当前index,因此删除分支不递增游标。 */
|
||
if (entry->placeholder) { entry->time_tag_cleared = true; ++index; }
|
||
else if (Example_Clear_Publication_Time(app, entry)) { ++index; }
|
||
else { Example_Remove_Publication(app, index); }
|
||
}
|
||
/* 显式清除放弃此前差量,但不改参数/原始值/滤波。幸存旧条目不能在提交时回退此基准,
|
||
* 否则普通PLAIN排空或命令FINISHED后会把已清除的历史重新造为CP56事件。 */
|
||
if (app->parameter != NULL) {
|
||
for (index = 0U; index < EXAMPLE_MEASUREMENT_COUNT; ++index) {
|
||
ExampleMeasurement *state = &app->measurements[index];
|
||
state->submitted_value = app->scaled_values[index];
|
||
state->submitted_quality = state->quality;
|
||
state->submitted_range = state->range;
|
||
}
|
||
}
|
||
return IEC104_SYSTEM_COMMAND_DECISION_ACCEPT;
|
||
}
|
||
|
||
/**
|
||
* 功能:Take_Reset成功才置restart_requested;首次STOP前按时ACK的授权在断线后仍可领取。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:无。
|
||
* 说明:只保存布尔值是因为本例重建整个单站协议实例,许可回调已拒绝多站模型的QRP1。
|
||
* 多站设备若需定向复位,应保存返回请求的纯值身份/CA,并另行管理应用资源寿命。
|
||
* 专用QRP也可通过Take_Reset交出,但本例未实现其动作,绝不将任意授权转换为QRP1重启。
|
||
*/
|
||
static void Example_Take_System_Reset(ExampleApp *app)
|
||
{
|
||
IEC104_SystemCommandResetRequest_t request;
|
||
/* 启用211时此处不领取105授权;两种授权留给同一仲裁点选择,避免同轮分别Take两个设备动作。 */
|
||
if (app->system_command != NULL && app->software_upgrade == NULL &&
|
||
IEC104_SystemCommand_Take_Reset(app->system_command, &request)) {
|
||
if (request.qualifier == 1U) { app->restart_requested = app->quiescing = true; }
|
||
else {
|
||
/* 正常配置及许可回调不会产生此分支;扩展入口未配套动作分派时显式报告接入错误。 */
|
||
++app->system_command_faults;
|
||
(void)fputs("System command: granted QRP has no application handler; no action taken.\n", stderr);
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:每轮先推进旧回复、期限和ACK,再至多决定一条105;104/107和70由Process自行处理。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。
|
||
* 说明:Execute_Next的OK只表示队首已处理,新的回复可在后续Process提交,不能当作已送达。
|
||
* FAULT表示应用清除已发生、库清除失败;记录后继续推进否定回复,不重调同一请求的动作。
|
||
*/
|
||
static bool Example_Step_SystemCommand(ExampleApp *app)
|
||
{
|
||
IEC104_SystemCommandExecuteResult_t result;
|
||
if (app->system_command == NULL) { return true; }
|
||
if (!IEC104_SystemCommand_Process(app->system_command)) { return false; }
|
||
result = IEC104_SystemCommand_Execute_Next(app->system_command, Example_Reset_Action, app);
|
||
if (result == IEC104_SYSTEM_COMMAND_EXECUTE_ERROR) { return false; }
|
||
if (result == IEC104_SYSTEM_COMMAND_EXECUTE_FAULT) {
|
||
++app->system_command_faults;
|
||
EXAMPLE_SYSTEM_COMMAND_REPORT_FAULT(app);
|
||
}
|
||
Example_Take_System_Reset(app);
|
||
return IEC104_SystemCommand_Get_Status(app->system_command, &app->system_command_status);
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [COMMON/INIT] 公共初始化:运行值、站点注册、必需模块创建及失败回退
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:必须在开始消费Slave事件之前创建业务模块;config本地对象按值复制,广播数组仍为借用。
|
||
* 输入参数:app——示例应用上下文;slave——已创建的从站服务;common_address——站点公共地址;broadcast_states——调用方长期持有的广播站点工作区;broadcast_capacity——广播站点工作区容量;total_timeout_ms——整轮业务期限,单位毫秒。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:单站可传NULL/0;多站广播须提供覆盖全部目标的数组,保持独占和地址稳定直到模块Destroy。
|
||
* total_timeout_ms是部署指定的整体提交期限,0显式禁用;必须在Create复制配置之前写入。
|
||
* 命令行main只注册一个CA;多站回归提供状态数组并增加站点,复用本例的分派和取数函数。
|
||
*/
|
||
static bool Example_Init(ExampleApp *app, IEC104_Slave_t *slave, uint16_t common_address,
|
||
IEC104_InterrogationStationState_t *broadcast_states, size_t broadcast_capacity, uint32_t total_timeout_ms)
|
||
{
|
||
IEC104_InterrogationConfig_t config;
|
||
size_t index;
|
||
memset(app, 0, sizeof(*app));
|
||
app->slave = slave;
|
||
/* 每个应用实例独立保存受控运行值:单点取配置初值,通用双点1为分位,DTU双点2为合位。
|
||
* 上面的整实例清零已把步位置置0、位串所有位清0;两类值不由field/stress采样更新。
|
||
* 这里只在应用初始化时赋值,选择结束、撤销和FINISHED清理均不得恢复这些初值。 */
|
||
for (index = 0U; index < EXAMPLE_SIGNAL_COUNT; ++index) {
|
||
app->signal_values[index] = Example_Initial_Signal(index);
|
||
}
|
||
for (index = 0U; index < EXAMPLE_DOUBLE_COUNT; ++index) {
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
app->double_values[index] = 2U;
|
||
#else
|
||
app->double_values[index] = 1U;
|
||
#endif
|
||
}
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
app->dtu_started_ms = IEC104_Net_Now_Ms();
|
||
app->dtu_signal_pending = 0U;
|
||
Example_Dtu_Reset_Process(app);
|
||
app->dtu_energy_last_ms = app->dtu_started_ms;
|
||
memset(app->dtu_energy_wh, 0, sizeof(app->dtu_energy_wh));
|
||
memset(app->dtu_energy_frozen_wh, 0, sizeof(app->dtu_energy_frozen_wh));
|
||
#endif
|
||
for (index = 0U; index < EXAMPLE_MEASUREMENT_COUNT; ++index) {
|
||
app->scaled_values[index] = Example_Initial_Measurement(index);
|
||
}
|
||
if (IEC104_Slave_Add_Station(slave, &app->station, common_address, app) != IEC104_STATION_OK) { return false; }
|
||
IEC104_Startup_Config_Default(NULL, NULL, &config, NULL, NULL);
|
||
/* CA只在注册时指定;多站广播需提供每站状态区。 */
|
||
config.broadcast_states = broadcast_states;
|
||
config.broadcast_capacity = broadcast_capacity;
|
||
config.max_objects_per_asdu = 4U;
|
||
config.total_timeout_ms = total_timeout_ms;
|
||
app->interrogation = IEC104_Interrogation_Create(slave, &config);
|
||
if (app->interrogation != NULL) {
|
||
IEC104_SpontaneousConfig_t spontaneous_config;
|
||
IEC104_ReadConfig_t read_config;
|
||
IEC104_Startup_Config_Default(NULL, NULL, NULL, NULL, &spontaneous_config);
|
||
/* publication_forms须与统一配置一致,QRP2才能展开forms=0并删除遥信事件。 */
|
||
memcpy(app->publication_forms, spontaneous_config.forms, sizeof(app->publication_forms));
|
||
app->spontaneous = IEC104_Spontaneous_Create(slave, &spontaneous_config);
|
||
/* 在消费CONNECTED/ACTIVATED前绑定,模块从通知建立会话;默认15秒期限,无额外CLI项。 */
|
||
IEC104_Read_Config_Default(&read_config);
|
||
app->read = IEC104_Read_Create(slave, &read_config);
|
||
if (app->spontaneous != NULL && app->read != NULL) { return true; }
|
||
if (app->read != NULL) { (void)IEC104_Read_Destroy(app->read); app->read = NULL; }
|
||
if (app->spontaneous != NULL) { (void)IEC104_Spontaneous_Destroy(app->spontaneous); app->spontaneous = NULL; }
|
||
(void)IEC104_Interrogation_Destroy(app->interrogation);
|
||
app->interrogation = NULL;
|
||
}
|
||
(void)IEC104_Slave_Remove_Station(slave, &app->station);
|
||
return false;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [COMMON/SCHEDULING] 公共调度:取消、等待时间与Slave通知分派
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:统一取消应用业务;app为有效应用上下文,未创建的可选模块直接跳过,无返回值。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:无。
|
||
* 说明:遥控Cancel丢弃模块持有应答但保留应交付FINISHED,不回滚已经执行的输出。
|
||
* 本函数不消费终结通知;调用方还须Drain_Finished排空总召、计数量及遥控事件并归还应用引用。
|
||
* SystemCommand取消只撤销尚未交出的复位授权,已被发送层接手的确认仍可能发出。
|
||
* 扫描Cancel仅中止进行中的轮次,不停用组或清除网格;收尾期间不再调用普通Step,随后Close并分派断线。
|
||
* 已交给发送层的IDLE帧由原流程收尾,Cancel不会撤回它,也不产生待补发的点值队列。
|
||
*/
|
||
static void Example_Cancel(ExampleApp *app)
|
||
{
|
||
if (app->software_upgrade != NULL) {
|
||
/* 必须早于Slave_Close释放观察槽;已领取的激活任务在应用侧,不能在这里清候选。
|
||
* 未领取会话转ABANDON后由Drain_Finished交付,不能仅清状态快照就认定owner归还。 */
|
||
IEC104_SoftwareUpgrade_Cancel(app->software_upgrade);
|
||
(void)IEC104_SoftwareUpgrade_Get_Status(app->software_upgrade, &app->upgrade_status);
|
||
}
|
||
if (app->file_service != NULL) {
|
||
/* 暂存与句柄不能在Cancel时由应用抢先清掉;稍后由原归属的收尾恰一次释放。
|
||
* 未交付COMMIT会转ABORT;已经提交的file_bytes及present继续保留。 */
|
||
IEC104_FileService_Cancel(app->file_service);
|
||
(void)IEC104_FileService_Get_Status(app->file_service, &app->file_status);
|
||
}
|
||
if (app->remote_parameter != NULL) {
|
||
/* 只取消协议任务,已固化的运行值不回滚;健康连接上的恢复屏障仍在。
|
||
* 若存在真实暂存,稍后Close及生命周期分派后仍须交付一次DISCARD。 */
|
||
IEC104_RemoteParameter_Cancel(app->remote_parameter);
|
||
(void)IEC104_RemoteParameter_Get_Status(app->remote_parameter, &app->remote_status);
|
||
}
|
||
if (app->parameter != NULL) {
|
||
/* 示例不开ACK扩展,Cancel立即移除参数任务;运行值及周期启停配置保留。
|
||
* ACK模式应用还须在Destroy或改换资源之前交付全部COMMIT/ABORT,不能只照抄本例取消。 */
|
||
IEC104_Parameter_Cancel(app->parameter);
|
||
(void)IEC104_Parameter_Get_Status(app->parameter, &app->parameter_status);
|
||
}
|
||
if (app->periodic_scan != NULL) { IEC104_PeriodicScan_Cancel(app->periodic_scan); }
|
||
if (app->system_command != NULL) { IEC104_SystemCommand_Cancel(app->system_command); }
|
||
if (app->read != NULL) {
|
||
IEC104_Read_Cancel(app->read);
|
||
(void)IEC104_Read_Get_Status(app->read, &app->rd);
|
||
}
|
||
IEC104_Interrogation_Cancel(app->interrogation);
|
||
if (app->counter != NULL) {
|
||
IEC104_Interrogation_Cancel(app->counter);
|
||
(void)IEC104_Interrogation_Get_Status(app->counter, &app->ci);
|
||
}
|
||
if (app->clock != NULL) {
|
||
IEC104_ClockSynchronization_Cancel(app->clock);
|
||
(void)IEC104_ClockSynchronization_Get_Status(app->clock, &app->cs);
|
||
}
|
||
if (app->command != NULL) {
|
||
IEC104_Command_Cancel(app->command);
|
||
(void)IEC104_Command_Get_Status(app->command, &app->command_status);
|
||
}
|
||
(void)IEC104_Interrogation_Get_Status(app->interrogation, &app->gi);
|
||
}
|
||
|
||
/**
|
||
* 功能:两种授权统一仲裁;升级优先,选中Take返回false时不得取消另一授权或改取另一种。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:本轮仲裁无错误时返回true,未取得授权时可继续等待;身份或持久处理失败返回false。
|
||
* 说明:END已经预留任务,Take前只核验,不执行可能失败的分配;成功同轮进入QUIESCING并清队列。
|
||
*/
|
||
static bool Example_Arbitrate_Restart(ExampleApp *app)
|
||
{
|
||
ExampleUpgradeDevice *device = &example_upgrade_device;
|
||
IEC104_SoftwareUpgradeRequest_t upgrade;
|
||
IEC104_SystemCommandResetRequest_t reset;
|
||
if (app->software_upgrade == NULL || app->quiescing) { return true; }
|
||
if (!IEC104_SoftwareUpgrade_Get_Status(app->software_upgrade, &app->upgrade_status)) { return false; }
|
||
if (app->upgrade_status.restart_ready) {
|
||
/* 协议授权与应用预留须同时归属原会话;新连接或新站点不能接续旧候选。 */
|
||
if (!device->owned || device->context != app || device->invalidated || !device->reserved || device->taken ||
|
||
device->state != EXAMPLE_UPGRADE_FROZEN || device->activation.owner_token != device->owner_token ||
|
||
device->activation.transfer_token != device->transfer_token ||
|
||
!Example_Upgrade_Identity(&device->owner.identity, &app->upgrade_status.session_identity) ||
|
||
device->owner.common_address != app->upgrade_status.session_common_address ||
|
||
device->owner.station_id != app->upgrade_status.session_station_id ||
|
||
device->owner.session_serial != app->upgrade_status.session_serial) { return false; }
|
||
/* WAIT_EVENTS等暂缓不丢预留,也不提前撤销105;下一轮仍先尝试升级授权。
|
||
* 因而WAIT不会重复写授权元数据或阶段日志,ACK事实也不能跳过实际Take。 */
|
||
if (!IEC104_SoftwareUpgrade_Take_Restart(app->software_upgrade, &upgrade)) { return true; }
|
||
if (!Example_Upgrade_Owner(app, &upgrade)) { return false; }
|
||
device->taken = true;
|
||
device->activation.taken_ms = IEC104_Net_Now_Ms();
|
||
if (app->upgrade_store != NULL) {
|
||
/* Take是唯一授权入口。提交失败可能已经落盘,先移交所有权,再尝试持久授权。
|
||
* 失败后不回退到普通循环,也不让Cancel/退出把不确定的授权当未授权候选撤销。 */
|
||
device->persistent_handoff = true;
|
||
if (!Example_Upgrade_Store_Authorize(app->upgrade_store)) {
|
||
Example_Upgrade_Store_Failed(app); return false;
|
||
}
|
||
}
|
||
Example_User_Log_Upgrade(app, "ACTIVATION_AUTHORIZED");
|
||
} else {
|
||
if (app->system_command == NULL) { return true; }
|
||
if (!IEC104_SystemCommand_Get_Status(app->system_command, &app->system_command_status)) { return false; }
|
||
if (!app->system_command_status.reset_ready ||
|
||
!IEC104_SystemCommand_Take_Reset(app->system_command, &reset)) { return true; }
|
||
if (reset.qualifier != 1U) { return false; }
|
||
}
|
||
/* 只有选中授权真正交出,才取消未选中的授权和所有排队业务。
|
||
* 先置QUIESCING,使Take后到达的CANCEL不会按“无会话”回复肯定却仍执行重启。 */
|
||
app->restart_requested = app->quiescing = true;
|
||
Example_Cancel(app);
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:每次等待前重新查询剩余期限,避免采样/业务处理耗时后继续使用旧的毫秒数。
|
||
* 输入参数:app——示例应用上下文;maximum_ms——本轮允许等待的毫秒上限。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:受业务期限收紧后的等待毫秒数;0表示需要立即续跑。
|
||
* 说明:输入app为有效上下文,maximum_ms为调用方等待上限;返回0表示本地立即续跑,否则为缩短后的上限。
|
||
* 查询失败也返回0,让随后推进路径处理错误;本函数只查状态,不消费事件或触发业务到期转换。
|
||
* 本地可推进时不休眠;否则本例网络等待最多50ms,并受最近业务期限限制。
|
||
*/
|
||
static uint32_t Example_Wait_Time(ExampleApp *app, uint32_t maximum_ms)
|
||
{
|
||
if (app->quiescing) { return 0U; }
|
||
if (app->software_upgrade != NULL) {
|
||
IEC104_SoftwareUpgradeStatus_t *status = &app->upgrade_status;
|
||
if (!IEC104_SoftwareUpgrade_Get_Status(app->software_upgrade, status)) { return 0U; }
|
||
/* 仅等待ACK或观察槽不强制零等待;结果就绪、收尾或业务期限才唤醒本地推进。 */
|
||
if (status->events_pending || status->execute_ready || status->need_process || status->restart_ready) { return 0U; }
|
||
if (status->timer_active && status->timeout_remaining_ms < maximum_ms) {
|
||
maximum_ms = status->timeout_remaining_ms;
|
||
}
|
||
}
|
||
if (app->file_service != NULL) {
|
||
IEC104_FileServiceStatus_t *status = &app->file_status;
|
||
if (!IEC104_FileService_Get_Status(app->file_service, status)) { return 0U; }
|
||
/* execute_pending或暂缓COMMIT本身不要求零等待;HIGH/IDLE背压交网络推进后重试。 */
|
||
if (status->events_pending || status->execute_ready || status->need_process) { return 0U; }
|
||
if (status->timer_active && status->timeout_remaining_ms < maximum_ms) {
|
||
maximum_ms = status->timeout_remaining_ms;
|
||
}
|
||
}
|
||
if (app->remote_parameter != NULL) {
|
||
IEC104_RemoteParameterStatus_t *status = &app->remote_status;
|
||
if (!IEC104_RemoteParameter_Get_Status(app->remote_parameter, status)) { return 0U; }
|
||
/* 单纯有排队、确认WAIT或恢复状态不要求零等待;只合并模块可处理的最近期限。
|
||
* 网络再次唤醒后仍调用Step,让上一次容量WAIT有重试机会。 */
|
||
if (status->events_pending || status->execute_ready || status->need_process) { return 0U; }
|
||
if (status->timer_active && status->timeout_remaining_ms < maximum_ms) {
|
||
maximum_ms = status->timeout_remaining_ms;
|
||
}
|
||
}
|
||
if (app->parameter != NULL) {
|
||
IEC104_ParameterStatus_t *status = &app->parameter_status;
|
||
if (!IEC104_Parameter_Get_Status(app->parameter, status)) { return 0U; }
|
||
/* execute_ready表示本轮能推进;不能用仅表示排队的execute_pending触发零等待。
|
||
* 默认模式二者相同,ACK模式排队可能受前序准备阻挡,单纯ack_pending也不应忙轮询。 */
|
||
if (status->events_pending || status->execute_ready || status->need_process) { return 0U; }
|
||
if (status->timer_active && status->timeout_remaining_ms < maximum_ms) {
|
||
maximum_ms = status->timeout_remaining_ms;
|
||
}
|
||
}
|
||
if (app->periodic_scan != NULL) {
|
||
IEC104_PeriodicScanStatus_t status;
|
||
if (!IEC104_PeriodicScan_Get_Status(app->periodic_scan, &status)) { return 0U; }
|
||
/* 未读通知先交给Drain;need_process才表示需要立即再推进扫描,不能因轮次尚未完成就强制零等待。
|
||
* 扫描被发送层阻塞时允许Poll等待网络/ACK/协议期限;尚未开轮的最近起点才用于缩短本次等待。 */
|
||
if (status.events_pending || status.need_process) { return 0U; }
|
||
if (status.timer_active && status.timeout_remaining_ms < maximum_ms) {
|
||
maximum_ms = status.timeout_remaining_ms;
|
||
}
|
||
}
|
||
if (app->system_command != NULL) {
|
||
IEC104_SystemCommandStatus_t *status = &app->system_command_status;
|
||
if (!IEC104_SystemCommand_Get_Status(app->system_command, status)) { return 0U; }
|
||
/* 两个发送来源的WAIT、等待交接及等待ACK本身都不要求忙轮询。
|
||
* need_process包含已出现的交接/ACK结果;reset_ready则要求本轮尽快Take_Reset。 */
|
||
if (status->events_pending || status->need_process || status->decide_pending || status->reset_ready) { return 0U; }
|
||
if (status->timer_active && status->timeout_remaining_ms < maximum_ms) {
|
||
maximum_ms = status->timeout_remaining_ms;
|
||
}
|
||
}
|
||
if (app->read != NULL) {
|
||
if (!IEC104_Read_Get_Status(app->read, &app->rd)) { return 0U; }
|
||
/* READ仍排队不代表本轮可发送;send_waiting时允许网络等待,避免反复空取。
|
||
* REPLY背压同样由Process在下一轮网络推进后重试,期限继续限制等待上限。 */
|
||
if (app->rd.events_pending || app->rd.need_process ||
|
||
(app->rd.execute_pending && !app->rd.send_waiting)) { return 0U; }
|
||
if (app->rd.timer_active && app->rd.timeout_remaining_ms < maximum_ms) {
|
||
maximum_ms = app->rd.timeout_remaining_ms;
|
||
}
|
||
}
|
||
if (app->events_interval_ms != 0U) {
|
||
uint64_t now = IEC104_Net_Now_Ms();
|
||
uint64_t elapsed = now >= app->events_last_ms ? now - app->events_last_ms : app->events_interval_ms;
|
||
if (elapsed >= app->events_interval_ms) { return 0U; }
|
||
if (app->events_interval_ms - elapsed < maximum_ms) {
|
||
maximum_ms = (uint32_t)(app->events_interval_ms - elapsed);
|
||
}
|
||
}
|
||
if (app->command != NULL) {
|
||
if (!IEC104_Command_Get_Status(app->command, &app->command_status)) { return 0U; }
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
if (app->command_step == 1U && app->dtu_command_due_ms != 0U) {
|
||
uint64_t command_now = IEC104_Net_Now_Ms();
|
||
if (command_now >= app->dtu_command_due_ms) { return 0U; }
|
||
if (app->dtu_command_due_ms - command_now < maximum_ms) {
|
||
maximum_ms = (uint32_t)(app->dtu_command_due_ms - command_now);
|
||
}
|
||
}
|
||
#endif
|
||
/* 未读Slave通知、FINISHED等业务事件及模块本地进度都须立即处理。
|
||
* 应用持有事件/收尾步骤不代表能立即发送:上次WAIT时允许Poll等待,避免确认拥塞造成空转。 */
|
||
if (app->command_status.events_pending || app->command_status.pending_events != 0U ||
|
||
app->command_status.need_process ||
|
||
((app->command_pending || app->command_step != 0U) && !app->command_waiting)) { return 0U; }
|
||
if (app->command_status.timer_active && app->command_status.timeout_remaining_ms < maximum_ms) {
|
||
maximum_ms = app->command_status.timeout_remaining_ms;
|
||
}
|
||
}
|
||
if (!IEC104_Interrogation_Get_Status(app->interrogation, &app->gi)) { return 0U; }
|
||
if (app->counter != NULL) {
|
||
if (!IEC104_Interrogation_Get_Status(app->counter, &app->ci)) { return 0U; }
|
||
if (app->ci.events_pending || app->ci.pending_events != 0U || app->ci.need_process) { return 0U; }
|
||
if (app->ci.timer_active && app->ci.timeout_remaining_ms < maximum_ms) {
|
||
maximum_ms = app->ci.timeout_remaining_ms;
|
||
}
|
||
}
|
||
if (app->clock != NULL) {
|
||
if (!IEC104_ClockSynchronization_Get_Status(app->clock, &app->cs)) { return 0U; }
|
||
/* execute_pending包含尚未取样的READ;不能只用设时专属confirm_pending决定是否推进。
|
||
* 固定读回复的发送WAIT可以等待网络,下一轮Step_Clock仍须先Process再查询状态。 */
|
||
if (app->cs.events_pending || app->cs.execute_pending || app->cs.need_process) { return 0U; }
|
||
if (app->cs.timer_active && app->cs.timeout_remaining_ms < maximum_ms) {
|
||
maximum_ms = app->cs.timeout_remaining_ms;
|
||
}
|
||
}
|
||
/* 撤销后的FINISHED须及时消费;逐站COT=9遇WAIT则由模块need_process反映可推进性。
|
||
* 不能仅因pending_requests非零就零超时重试:它也包含等网络和等应用清理的任务。 */
|
||
if (app->events_pending || app->gi.events_pending) { return 0U; }
|
||
/* 初始化交接前暂存总召BEGIN;未读业务事件不是当前可推进的工作,不能触发空转。
|
||
* 网络事件及下面的请求期限仍参与等待,初始化完成后恢复正常消费。 */
|
||
if (IEC104_Startup_Can_Consume_General(&app->startup) &&
|
||
(app->gi.pending_events != 0U || app->gi.need_process)) { return 0U; }
|
||
if (app->publication_count != 0U && !app->publications[0].placeholder &&
|
||
!app->publication_waiting) { return 0U; }
|
||
if (app->gi.timer_active && app->gi.timeout_remaining_ms < maximum_ms) { return app->gi.timeout_remaining_ms; }
|
||
return maximum_ms;
|
||
}
|
||
|
||
/**
|
||
* 功能:状态事件交给所有实例;I帧由总召、计数量、校时、遥控、读、系统命令、参数、文件及兜底接手。
|
||
* 输入参数:app——示例应用上下文;event——本轮借用的协议事件。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:输入app为有效上下文,event是刚由Slave_NextEvent交付的借用事件,本函数不保存它的指针。
|
||
* 返回true表示分派完成(包括模块拒绝/丢弃),false表示业务入口或状态查询失败,应统一收尾。
|
||
* 生命周期通知不能因前一个模块HANDLED而短路,否则遥控可能漏读STOP/换代后继续执行旧请求。
|
||
* Handle_Event负责消费这些通知,不能在它之前用Check_Request等待通知读空而阻断分派。
|
||
*/
|
||
static bool Example_Handle_Event(ExampleApp *app, const IEC104_SlaveEvent_t *event)
|
||
{
|
||
IEC104_InterrogationEventResult_t result;
|
||
/* 一条生命周期只在此分派入口记一次;日志失败不提前return,所有模块仍须收到原通知完成清理。 */
|
||
Example_User_Log_Connection(app, event);
|
||
if (!Example_Startup_Handle_Event(app, event)) { return false; }
|
||
/* 激活任务取得候选后停收新业务;生命周期仍须传给所有模块,才能归还旧请求资源。 */
|
||
if (event->transport.type == IEC104_TCP_EVENT_I_FRAME && (app->quiescing || example_upgrade_device.taken)) {
|
||
return true;
|
||
}
|
||
/* Receiver已过滤线上基础格式错误;仍防御性过滤不可用视图,避免误交给业务分派或未知类型兜底。 */
|
||
if (event->transport.type == IEC104_TCP_EVENT_I_FRAME && event->asdu_result != IEC60870_ASDU_OK) { return true; }
|
||
/* 扫描只据生命周期建立/停用会话,ACTIVATED时校验reserve并设置首轮网格;I帧和回执返回IGNORED。
|
||
* 即使扫描已HANDLED,仍继续向其他业务分派同一通知;STOP、断线和换代都不能只送到一个模块。 */
|
||
if (app->periodic_scan != NULL &&
|
||
IEC104_PeriodicScan_Handle_Event(app->periodic_scan, event) == IEC104_PERIODIC_SCAN_EVENT_ERROR) {
|
||
return false;
|
||
}
|
||
/* COT=8同其他Type100请求一样交给总召模块,它负责匹配、停止目标及保存确认。
|
||
* 不能改为Example_Cancel:本地取消会丢弃待发回复并影响其他业务,也不会生成撤销确认。 */
|
||
result = IEC104_Interrogation_Handle_Event(app->interrogation, event);
|
||
if (app->counter != NULL && (event->transport.type != IEC104_TCP_EVENT_I_FRAME ||
|
||
result == IEC104_INTERROGATION_EVENT_IGNORED)) {
|
||
IEC104_InterrogationEventResult_t counter_result = IEC104_Interrogation_Handle_Event(app->counter, event);
|
||
if (counter_result == IEC104_INTERROGATION_EVENT_ERROR ||
|
||
!IEC104_Interrogation_Get_Status(app->counter, &app->ci)) { return false; }
|
||
if (result == IEC104_INTERROGATION_EVENT_IGNORED) { result = counter_result; }
|
||
}
|
||
if (result == IEC104_INTERROGATION_EVENT_ERROR ||
|
||
!IEC104_Interrogation_Get_Status(app->interrogation, &app->gi)) { return false; }
|
||
if (app->clock != NULL && (event->transport.type != IEC104_TCP_EVENT_I_FRAME ||
|
||
result == IEC104_INTERROGATION_EVENT_IGNORED)) {
|
||
IEC104_ClockSynchronizationEventResult_t clock_result =
|
||
IEC104_ClockSynchronization_Handle_Event(app->clock, event);
|
||
if (clock_result == IEC104_CLOCK_SYNCHRONIZATION_EVENT_ERROR ||
|
||
!IEC104_ClockSynchronization_Get_Status(app->clock, &app->cs)) { return false; }
|
||
if (clock_result != IEC104_CLOCK_SYNCHRONIZATION_EVENT_IGNORED &&
|
||
event->transport.type == IEC104_TCP_EVENT_I_FRAME) { return true; }
|
||
}
|
||
if (app->command != NULL && (event->transport.type != IEC104_TCP_EVENT_I_FRAME ||
|
||
result == IEC104_INTERROGATION_EVENT_IGNORED)) {
|
||
/* HANDLED也包括格式否定、实例忙和过载丢弃,不能再走44兜底;未启用类型仍可继续分派。 */
|
||
IEC104_CommandEventResult_t command_result = IEC104_Command_Handle_Event(app->command, event);
|
||
if (command_result == IEC104_COMMAND_EVENT_ERROR ||
|
||
!IEC104_Command_Get_Status(app->command, &app->command_status)) { return false; }
|
||
if (command_result != IEC104_COMMAND_EVENT_IGNORED &&
|
||
event->transport.type == IEC104_TCP_EVENT_I_FRAME) { return true; }
|
||
}
|
||
if (app->read != NULL && (event->transport.type != IEC104_TCP_EVENT_I_FRAME ||
|
||
result == IEC104_INTERROGATION_EVENT_IGNORED)) {
|
||
IEC104_ReadEventResult_t read_result = IEC104_Read_Handle_Event(app->read, event);
|
||
if (read_result == IEC104_READ_EVENT_ERROR || !IEC104_Read_Get_Status(app->read, &app->rd)) { return false; }
|
||
if (read_result != IEC104_READ_EVENT_IGNORED && event->transport.type == IEC104_TCP_EVENT_I_FRAME) { return true; }
|
||
}
|
||
if (app->system_command != NULL && (event->transport.type != IEC104_TCP_EVENT_I_FRAME ||
|
||
result == IEC104_INTERROGATION_EVENT_IGNORED)) {
|
||
IEC104_SystemCommandEventResult_t handled = IEC104_SystemCommand_Handle_Event(app->system_command, event);
|
||
if (handled == IEC104_SYSTEM_COMMAND_EVENT_ERROR) { return false; }
|
||
if (handled == IEC104_SYSTEM_COMMAND_EVENT_HANDLED && event->transport.type == IEC104_TCP_EVENT_I_FRAME) { return true; }
|
||
}
|
||
/* 参数置于未知类型兜底前;HANDLED包含拒绝和槽满丢新,不能再回44。
|
||
* 生命周期通知仍逐个广播给本模块,不能因其他业务接手而跳过会话清理。 */
|
||
if (app->parameter != NULL && (event->transport.type != IEC104_TCP_EVENT_I_FRAME ||
|
||
result == IEC104_INTERROGATION_EVENT_IGNORED)) {
|
||
IEC104_ParameterEventResult_t handled = IEC104_Parameter_Handle_Event(app->parameter, event);
|
||
if (handled == IEC104_PARAMETER_EVENT_ERROR) { return false; }
|
||
if (handled == IEC104_PARAMETER_EVENT_HANDLED && event->transport.type == IEC104_TCP_EVENT_I_FRAME) { return true; }
|
||
}
|
||
/* 200–203在标准参数之后接手;HANDLED还包括满槽丢新和faulted丢弃,不能再回44。
|
||
* 生命周期继续广播,尤其不可漏掉旧代次DISCARD所依赖的断线清理。 */
|
||
if (app->remote_parameter != NULL && (event->transport.type != IEC104_TCP_EVENT_I_FRAME ||
|
||
result == IEC104_INTERROGATION_EVENT_IGNORED)) {
|
||
IEC104_RemoteParameterEventResult_t handled = IEC104_RemoteParameter_Handle_Event(app->remote_parameter, event);
|
||
if (handled == IEC104_REMOTE_PARAMETER_EVENT_ERROR) { return false; }
|
||
if (handled == IEC104_REMOTE_PARAMETER_EVENT_HANDLED && event->transport.type == IEC104_TCP_EVENT_I_FRAME) { return true; }
|
||
}
|
||
if (app->file_service != NULL && (event->transport.type != IEC104_TCP_EVENT_I_FRAME ||
|
||
result == IEC104_INTERROGATION_EVENT_IGNORED)) {
|
||
IEC104_FileServiceEventResult_t handled;
|
||
unsigned steps = 0U;
|
||
/* 此处是“先读空通知再执行”的唯一业务例外:环满时保留当前event和ASDU视图,
|
||
* 不调用NextEvent、不分派后续通知;Execute只推进暂存/收尾,COMMIT仍检查READY。
|
||
* 被保留的是最后一条通知时Check_Request可为READY,此时允许交付已安排的COMMIT。
|
||
* 内存回调短时完成;真实Flash接入必须约束整轮写回调累计耗时,不能只测单次write。
|
||
* BUSY不等于已消费;只有重试返回HANDLED才能读下一条,ERROR或超过上界立即停止。 */
|
||
while ((handled = IEC104_FileService_Handle_Event(app->file_service, event)) ==
|
||
IEC104_FILE_SERVICE_EVENT_BUSY) {
|
||
if (++steps > IEC104_FILE_SERVICE_BUSY_STEP_LIMIT ||
|
||
IEC104_FileService_Execute_Next(app->file_service, &example_file_handlers, app) !=
|
||
IEC104_FILE_SERVICE_EXECUTE_OK) { return false; }
|
||
}
|
||
if (handled == IEC104_FILE_SERVICE_EVENT_ERROR) { return false; }
|
||
if (handled == IEC104_FILE_SERVICE_EVENT_HANDLED && event->transport.type == IEC104_TCP_EVENT_I_FRAME) { return true; }
|
||
}
|
||
/* 211接在文件服务之后、未知类型兜底之前;HANDLED含拒绝和故障丢弃,不能再回复44。 */
|
||
if (app->software_upgrade != NULL && (event->transport.type != IEC104_TCP_EVENT_I_FRAME ||
|
||
result == IEC104_INTERROGATION_EVENT_IGNORED)) {
|
||
IEC104_SoftwareUpgradeEventResult_t handled = IEC104_SoftwareUpgrade_Handle_Event(app->software_upgrade, event);
|
||
if (handled == IEC104_SOFTWARE_UPGRADE_EVENT_ERROR) { return false; }
|
||
if (handled == IEC104_SOFTWARE_UPGRADE_EVENT_HANDLED && event->transport.type == IEC104_TCP_EVENT_I_FRAME) { return true; }
|
||
}
|
||
if (result != IEC104_INTERROGATION_EVENT_IGNORED ||
|
||
event->transport.type != IEC104_TCP_EVENT_I_FRAME || !app->gi.active ||
|
||
event->transport.generation != app->gi.generation) { return true; }
|
||
/* 当前事件当场提交,必须在NextEvent读取后续通知之前调用;应用不保存兜底请求。
|
||
* HIGH满只丢本条并计数;原连接停用/断开则取消,不跨启停续发。 */
|
||
++app->other_rejected;
|
||
switch (IEC104_Slave_Reject_Request(app->slave, event, IEC60870_ASDU_COT_UNKNOWN_TYPE)) {
|
||
case IEC104_TCP_SUBMIT_OK: ++app->other_submitted; break;
|
||
case IEC104_TCP_SUBMIT_WAIT: ++app->other_overloads; break;
|
||
case IEC104_TCP_SUBMIT_FATAL:
|
||
/* 可能已写出字节;cancelled仅表示不再重试,继续读取断线通知。 */
|
||
++app->other_cancelled;
|
||
break;
|
||
default: ++app->other_cancelled; break;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [COMMON/LOOP] 公共主循环:协调所有业务并读空Slave通知
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:strict_business_priority关闭时保留原应用调用顺序及两类召唤轮换,不用严格调度的业务轮接口。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。
|
||
* 说明:已执行参数/校时确认先重试,随后遥控、读命令、系统命令、发布队列、两类召唤轮换、新校时/参数及扫描。
|
||
* app为有效上下文;返回true表示本轮成功或因未读通知暂缓,false交给主循环停止并清理。
|
||
* Command_Process只推进协议应答,Drain_Command才执行应用决定及结果/返回信息步骤,最后刷新调度快照。
|
||
* 通知预算尚未读空时不能调用Accept;否则可能在尚未分派的STOP或撤销之后错误启动设备。
|
||
*/
|
||
static bool Example_Step_Compatible(ExampleApp *app)
|
||
{
|
||
if (app->quiescing || example_upgrade_device.taken) { return true; }
|
||
if (app->events_pending) { return true; }
|
||
/* 即使--events=0也继续收敛遥调产生的阶跃;lookup和发送重试不推进滤波。 */
|
||
Example_Update_Measurements(app);
|
||
if (app->parameter != NULL) {
|
||
if (!IEC104_Parameter_Get_Status(app->parameter, &app->parameter_status)) { return false; }
|
||
if (app->parameter_status.confirm_pending && !IEC104_Parameter_Process(app->parameter)) { return false; }
|
||
}
|
||
/* 优先重试已经执行动作的校时确认;HIGH拥塞不暂停独立的NORMAL发布。
|
||
* 随后的读命令仍须通过自己的HIGH余量预检,不能因业务独立就绕过背压。 */
|
||
if (app->clock != NULL) {
|
||
if (!IEC104_ClockSynchronization_Get_Status(app->clock, &app->cs)) { return false; }
|
||
if (app->cs.confirm_pending && (!IEC104_ClockSynchronization_Process(app->clock) ||
|
||
!IEC104_ClockSynchronization_Get_Status(app->clock, &app->cs))) { return false; }
|
||
}
|
||
if (!Example_Collect_Events(app)) { return false; }
|
||
if (app->command != NULL && (!IEC104_Command_Process(app->command) || !Example_Drain_Command(app) ||
|
||
!IEC104_Command_Get_Status(app->command, &app->command_status))) { return false; }
|
||
/* 读可见本轮已执行遥控的新值;位置本身不保证与校时等其他HIGH生产者的应答先后。
|
||
* 105先推进观察记录,211再重试提交,最后统一领取,避免同轮各取一次设备动作授权。 */
|
||
if (!Example_Step_Read(app) || !Example_Step_SystemCommand(app) ||
|
||
!Example_Step_SoftwareUpgrade(app) || app->user_log_failed || !Example_Arbitrate_Restart(app)) { return false; }
|
||
/* 先观察本轮Type70是否已交接,使下面GI消费者只在初始化完成后领取BEGIN。 */
|
||
if (!Example_Startup_Step(app)) { return false; }
|
||
/* 授权已交给应用,立即让出正常业务Step;主循环收尾前不再发布变化或启动新的业务动作。 */
|
||
if (app->restart_requested) { return true; }
|
||
if (!Example_Publish_Recording(app) || !Example_Collect_Measurement_Changes(app) ||
|
||
!Example_Drain_Publications(app)) { return false; }
|
||
/* 轮换两类召唤的推进机会;这只是应用调用次序,不承诺跨业务报文先后。 */
|
||
app->counter_first = !app->counter_first;
|
||
if (app->counter_first) {
|
||
if (!Example_Step_Counter(app) || !Example_Step_General(app)) { return false; }
|
||
} else {
|
||
if (!Example_Step_General(app) || !Example_Step_Counter(app)) { return false; }
|
||
}
|
||
/* GI消费者可能刚保存末站完成票据;再次检查可及时放行,PENDING仍留待网络推进。 */
|
||
if (!Example_Startup_Step(app)) { return false; }
|
||
/* 参数动作位于复位授权检查之后、空闲扫描之前;本轮QPA=3的启停立即影响随后扫描。
|
||
* 总召本轮先前已取的批次仍可带旧值,下一批再读取运行值,不构造整轮快照。 */
|
||
/* 远程参数使用同一串行循环发布运行值;各模块FIFO仅保证各自顺序,不组成跨模块事务。 */
|
||
if (!Example_Step_Clock(app) || !Example_Step_Parameter(app) || app->user_log_failed ||
|
||
!Example_Step_RemoteParameter(app) || app->user_log_failed || !Example_Step_FileService(app)) { return false; }
|
||
/* 参数动作可立即改变范围品质或关闭平滑;排队后下轮按正常发布顺序交接。 */
|
||
if (!Example_Collect_Measurement_Changes(app)) { return false; }
|
||
/* 周期/背景扫描最后推进,使本轮其他业务先提交已准备好的HIGH/NORMAL数据;发送层仍会复查IDLE准入。
|
||
* 总召期间不额外暂停背景组,取数间隙若满足准入仍可扫描;名义周期不保证送达时限。
|
||
* IDLE/WAIT/PROGRESS都可正常交回主循环,是否立即续跑由下一次Get_Status决定,不能对WAIT就地重试。 */
|
||
return app->periodic_scan == NULL ||
|
||
IEC104_PeriodicScan_Step(app->periodic_scan, Example_PeriodicScan_Point, app) !=
|
||
IEC104_PERIODIC_SCAN_STEP_ERROR;
|
||
}
|
||
|
||
/**
|
||
* 功能:Begin后的NONE阶段先处理期限、会话失效和已有回复,再为各等级准备新候选,避免过期工作继续参与发送。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。
|
||
* 说明:此时不交接IDLE或队满旁路帧,但所有固定回复仍可入队;不能以发送等级为由停掉其他模块期限。
|
||
* 本阶段不执行lookup、设备动作或文件读;这些工作留到所属等级,并继续使用模块自身的WAIT契约。
|
||
*/
|
||
static bool Example_Maintain_Business(ExampleApp *app)
|
||
{
|
||
return IEC104_Interrogation_Process(app->interrogation) &&
|
||
(app->counter == NULL || IEC104_Interrogation_Process(app->counter)) &&
|
||
(app->command == NULL || IEC104_Command_Process(app->command)) &&
|
||
(app->clock == NULL || IEC104_ClockSynchronization_Process(app->clock)) &&
|
||
(app->read == NULL || IEC104_Read_Process(app->read)) &&
|
||
(app->system_command == NULL || IEC104_SystemCommand_Process(app->system_command)) &&
|
||
(app->parameter == NULL || IEC104_Parameter_Process(app->parameter)) &&
|
||
(app->remote_parameter == NULL || IEC104_RemoteParameter_Process(app->remote_parameter)) &&
|
||
(app->file_service == NULL || IEC104_FileService_Process(app->file_service)) &&
|
||
(app->software_upgrade == NULL || IEC104_SoftwareUpgrade_Process(app->software_upgrade));
|
||
}
|
||
|
||
/**
|
||
* 功能:BEGIN决定和每批数据交接之后,Process才会准备下一条CON/NEED_DATA/TERM。
|
||
* 输入参数:app——示例应用上下文;counter——是否推进计数量召唤。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。
|
||
* 说明:离开当前等级前有界续推这些本地步骤,不能把尚未调用Process误认为没有可发业务。
|
||
* 预算限制本地推进次数,不是每轮发送帧数;遇发送WAIT或应用保留事件即停止,绝不就地等待网络。
|
||
*/
|
||
static bool Example_Drain_Interrogation_Priority(ExampleApp *app, bool counter)
|
||
{
|
||
unsigned round;
|
||
for (round = 0U; round < EXAMPLE_EVENT_BUDGET; ++round) {
|
||
IEC104_InterrogationStatus_t *status = counter ? &app->ci : &app->gi;
|
||
if (counter) {
|
||
if (!Example_Step_Counter(app)) { return false; }
|
||
if (app->counter == NULL || app->counter_pending) { return true; }
|
||
} else {
|
||
if (!Example_Step_General(app)) { return false; }
|
||
if (app->business_pending || !IEC104_Startup_Can_Consume_General(&app->startup)) { return true; }
|
||
}
|
||
if (status->waiting || status->data_send_waiting ||
|
||
(!status->need_process && status->pending_events == 0U)) { return true; }
|
||
}
|
||
/* 等级取自受理时冻结的任务;不能把当前phase2误当成正在准备的普通总召5。
|
||
* pending只补记预算用完后仍可立即准备的候选,不预约发送容量;它保留到下一次Begin,约束其间选帧。
|
||
* 应用取数、初始化前置及发送WAIT已在循环内退出,不能借此把等待外部条件的任务变成低级业务屏障。 */
|
||
{
|
||
IEC104_BusinessPriority_t priority = IEC104_Interrogation_Get_Pending_Priority(
|
||
counter ? app->counter : app->interrogation);
|
||
return priority == IEC104_BUSINESS_PRIORITY_NONE ||
|
||
IEC104_Slave_Set_Pending_Business_Priority(app->slave, priority) == IEC104_TCP_SUBMIT_OK;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:同一轮只采样一次;随后按12级业务优先级递增准备候选,不重复执行十二轮完整应用Step。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。
|
||
* 说明:阶段限制IDLE和队满旁路;非当前等级的固定回复仍可入队,最终线序由发送层同时比较队列与候选。
|
||
* 入队本身不发送。HIGH已满时仅当前等级可尝试旁路,与IDLE共用本轮一次直接交接额度,低级不得先占帧边界。
|
||
* System/GI分别承载多个等级,重复推进仍由模块的请求身份、FIFO和已提交状态防止重复动作/报文。
|
||
*/
|
||
static bool Example_Step_Strict(ExampleApp *app)
|
||
{
|
||
unsigned priority;
|
||
if (!Example_Maintain_Business(app)) { return false; }
|
||
/* 先由维护更新ACK/期限,再统一领取仍有效的重启许可;领取成功即停止新采样和候选准备。
|
||
* 复位业务等级约束报文候选,不把已成立的设备重启授权延后到该阶段,避免其间再启动其他动作。 */
|
||
Example_Take_System_Reset(app);
|
||
if (!Example_Arbitrate_Restart(app)) { return false; }
|
||
if (app->restart_requested) { return true; }
|
||
Example_Update_Measurements(app);
|
||
if (!Example_Collect_Events(app) || !Example_Collect_Measurement_Changes(app) ||
|
||
!Example_Drain_Publications(app)) { return false; }
|
||
for (priority = IEC104_BUSINESS_PRIORITY_INITIALIZATION;
|
||
priority < IEC104_BUSINESS_PRIORITY_COUNT; ++priority) {
|
||
if (IEC104_Slave_Set_Business_Priority(app->slave, (IEC104_BusinessPriority_t)priority) !=
|
||
IEC104_TCP_SUBMIT_OK) { return false; }
|
||
switch ((IEC104_BusinessPriority_t)priority) {
|
||
case IEC104_BUSINESS_PRIORITY_INITIALIZATION:
|
||
if (app->system_command != NULL && !IEC104_SystemCommand_Process(app->system_command)) { return false; }
|
||
if (!Example_Startup_Step(app)) { return false; }
|
||
break;
|
||
case IEC104_BUSINESS_PRIORITY_INITIAL_INTERROGATION:
|
||
if (!Example_Drain_Interrogation_Priority(app, false) || !Example_Startup_Step(app)) { return false; }
|
||
break;
|
||
case IEC104_BUSINESS_PRIORITY_COMMAND:
|
||
if (app->command != NULL && (!IEC104_Command_Process(app->command) || !Example_Drain_Command(app) ||
|
||
!IEC104_Command_Process(app->command) ||
|
||
!IEC104_Command_Get_Status(app->command, &app->command_status))) { return false; }
|
||
if (!Example_Step_Parameter(app) || app->user_log_failed ||
|
||
!Example_Step_RemoteParameter(app) || app->user_log_failed) { return false; }
|
||
/* 参数或遥调改变本轮品质/处理值时,须在后面的事件/遥测机会前形成候选。 */
|
||
if (!Example_Collect_Measurement_Changes(app)) { return false; }
|
||
break;
|
||
case IEC104_BUSINESS_PRIORITY_SEQUENCE_EVENT:
|
||
case IEC104_BUSINESS_PRIORITY_FAULT_EVENT:
|
||
/* 严格调度模式在故障优先级形成录波简报,再由原有发布队列推进发送。 */
|
||
if (priority == IEC104_BUSINESS_PRIORITY_FAULT_EVENT && !Example_Publish_Recording(app)) { return false; }
|
||
if (!Example_Drain_Publications(app)) { return false; }
|
||
break;
|
||
case IEC104_BUSINESS_PRIORITY_INTERROGATION:
|
||
if (!Example_Drain_Interrogation_Priority(app, false) || !Example_Step_Read(app) ||
|
||
!Example_Startup_Step(app)) { return false; }
|
||
break;
|
||
case IEC104_BUSINESS_PRIORITY_CLOCK:
|
||
if (app->system_command != NULL && !IEC104_SystemCommand_Process(app->system_command)) { return false; }
|
||
if (!Example_Step_Clock(app)) { return false; }
|
||
if (app->clock != NULL && !IEC104_ClockSynchronization_Process(app->clock)) { return false; }
|
||
break;
|
||
case IEC104_BUSINESS_PRIORITY_MEASUREMENT:
|
||
if (!Example_Drain_Publications(app)) { return false; }
|
||
if (app->periodic_scan != NULL &&
|
||
IEC104_PeriodicScan_Step(app->periodic_scan, Example_PeriodicScan_Point, app) ==
|
||
IEC104_PERIODIC_SCAN_STEP_ERROR) { return false; }
|
||
break;
|
||
case IEC104_BUSINESS_PRIORITY_RESET:
|
||
if (!Example_Step_SystemCommand(app) || !Example_Step_SoftwareUpgrade(app) || app->user_log_failed ||
|
||
!Example_Arbitrate_Restart(app)) { return false; }
|
||
if (app->system_command != NULL && !IEC104_SystemCommand_Process(app->system_command)) { return false; }
|
||
if (app->restart_requested) { return true; }
|
||
break;
|
||
case IEC104_BUSINESS_PRIORITY_FILE_CALL:
|
||
{
|
||
unsigned round;
|
||
/* OPEN/CLOSE等本地步骤之后才会形成目录回复。先有界续推CONTROL,不能让旧读数据抢在目录之前。
|
||
* 只有预算耗尽且目录仍execute_ready才登记10级候选,连下一次Poll也不能越过它选低级帧。
|
||
* 单有活动读句柄或未完成请求不够;等待ACK、数据或发送余量时仍须让出,其他模块维护已先完成。 */
|
||
for (round = 0U; round < EXAMPLE_EVENT_BUDGET; ++round) {
|
||
IEC104_FileServiceExecuteResult_t executed;
|
||
if (!Example_Step_FileService_Mode(app, IEC104_FILE_SERVICE_EXECUTE_CONTROL, &executed)) { return false; }
|
||
if (executed != IEC104_FILE_SERVICE_EXECUTE_OK) { break; }
|
||
}
|
||
if (round == EXAMPLE_EVENT_BUDGET && app->file_status.execute_ready &&
|
||
app->file_status.directory_active && app->file_status.pending_requests != 0U &&
|
||
IEC104_Slave_Set_Pending_Business_Priority(app->slave, IEC104_BUSINESS_PRIORITY_FILE_CALL) !=
|
||
IEC104_TCP_SUBMIT_OK) { return false; }
|
||
break;
|
||
}
|
||
case IEC104_BUSINESS_PRIORITY_FILE_TRANSFER:
|
||
/* 第十级已准备控制候选,第十一级只推进数据;读回调不获得额外发送资格。 */
|
||
if (!Example_Step_FileService_Mode(app, IEC104_FILE_SERVICE_EXECUTE_DATA, NULL)) { return false; }
|
||
break;
|
||
case IEC104_BUSINESS_PRIORITY_COUNTER_INTERROGATION:
|
||
if (!Example_Drain_Interrogation_Priority(app, true)) { return false; }
|
||
break;
|
||
default:
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:在匹配的业务收集周期内推进一次应用业务。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。
|
||
* 说明:Begin/End限定候选收集轮,不代替Poll。只有Begin成功才配对End;业务失败或已领取重启授权的提前返回也须End。
|
||
* 服务使用业务轮后,每次新I帧交接后暂停下一帧编号,直到下一次Begin重新收集;连续Poll不能绕过未组帧候选。
|
||
* 已编号帧的续写以及S/U帧、ACK仍由网络推进,严格排序不打断正在发送的APDU。
|
||
* 历史观测接在成功业务推进之后;严格路径的 Begin 等待不补做过去定点,持久化错误照常传播。
|
||
*/
|
||
static bool Example_Step(ExampleApp *app)
|
||
{
|
||
IEC104_TcpSubmitResult_t result;
|
||
bool succeeded;
|
||
/* 这里只停止新业务轮;Cancel、生命周期分派及Drain_Finished不经此门,必须继续归还旧资源。 */
|
||
if (app->user_log_failed || app->upgrade_store_failed) { return false; }
|
||
if (!IEC104_Slave_Strict_Priority_Enabled(app->slave)) {
|
||
return Example_Step_Compatible(app) && Example_History_Observe(app) && Example_Energy_Step(app) &&
|
||
!app->user_log_failed && !app->upgrade_store_failed;
|
||
}
|
||
if (app->quiescing || example_upgrade_device.taken || app->events_pending) { return true; }
|
||
result = IEC104_Slave_Begin_Business_Cycle(app->slave);
|
||
if (result == IEC104_TCP_SUBMIT_WAIT) { return true; }
|
||
if (result != IEC104_TCP_SUBMIT_OK) { return false; }
|
||
succeeded = Example_Step_Strict(app);
|
||
/* 无论业务成功与否都结束已开启的收集轮;只有两者成功才把最终遥测交给历史核心。 */
|
||
result = IEC104_Slave_End_Business_Cycle(app->slave);
|
||
return succeeded && result == IEC104_TCP_SUBMIT_OK && Example_History_Observe(app) && Example_Energy_Step(app) &&
|
||
!app->user_log_failed && !app->upgrade_store_failed;
|
||
}
|
||
|
||
/**
|
||
* 功能:有界消费通知。预算用完先续读,不能跨过排在后面的STOP/START直接续发旧总召或执行旧遥控。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。
|
||
* 说明:只有读到EMPTY才清events_pending并允许Example_Step推进动作,避免用最终激活状态掩盖中间STOP。
|
||
* 广播撤销也须先分派:否则应用可能在COT=8已到达但尚未处理时,先接受后续站的BEGIN。
|
||
* 文件BUSY例外在Handle_Event内同步保留本条通知,有限步腾出数据槽后才进入下一次NextEvent。
|
||
*/
|
||
static bool Example_Drain(ExampleApp *app)
|
||
{
|
||
unsigned count;
|
||
IEC104_SlaveEvent_t event;
|
||
Example_Refresh_System_Clock(app, false);
|
||
for (count = 0U; count < EXAMPLE_EVENT_BUDGET; ++count) {
|
||
IEC104_TcpEventResult_t result = IEC104_Slave_NextEvent(app->slave, &event);
|
||
if (result == IEC104_TCP_EVENT_EMPTY) { app->events_pending = false; return true; }
|
||
if (result != IEC104_TCP_EVENT_READY || !Example_Handle_Event(app, &event)) { return false; }
|
||
}
|
||
app->events_pending = true;
|
||
return true;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [COMMON/LIFECYCLE] 跨业务生命周期:终结排空、协议重建与引用归还
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:在取消后排空业务终结事件并归还应用持有的引用。
|
||
* 输入参数:app——示例应用上下文。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。
|
||
* 说明:仅用于Cancel之后的收尾,绝不能改成调用普通Example_Drain:后者会分派新的Slave I帧。
|
||
* 各Drain有独立预算,须循环到所有业务队列为空且三份应用站点引用都已归还。
|
||
* pending每轮必须下降,防止违反收尾约定时无进展自旋;失败交上层停止重建。
|
||
* 本函数不要求Slave通知为空;Close之后还须分派非I帧,再调用本函数处理新增终结通知。
|
||
*/
|
||
static bool Example_Drain_Finished(ExampleApp *app)
|
||
{
|
||
unsigned previous = UINT_MAX;
|
||
/* 收尾不再尝试放行启动流程。先归还集合锁及读取引用,避免历史COMPLETED
|
||
* 因尚未分派的Slave通知反复WAIT,阻断后面的FINISHED清理。
|
||
* Reset不消费Slave通知、不开放发送门禁;取消后的资源清理不依赖连接仍然可用。 */
|
||
if (!Example_Startup_Reset(app)) { return false; }
|
||
for (;;) {
|
||
unsigned pending;
|
||
if (!Example_Drain_Business(app) || !Example_Drain_Counter(app) || !Example_Drain_Command(app) ||
|
||
!IEC104_Interrogation_Get_Status(app->interrogation, &app->gi)) { return false; }
|
||
pending = app->gi.pending_events;
|
||
if (app->counter != NULL) {
|
||
if (!IEC104_Interrogation_Get_Status(app->counter, &app->ci)) { return false; }
|
||
pending += app->ci.pending_events;
|
||
}
|
||
if (app->command != NULL) {
|
||
if (!IEC104_Command_Get_Status(app->command, &app->command_status)) { return false; }
|
||
pending += app->command_status.pending_events;
|
||
}
|
||
if (app->file_service != NULL) {
|
||
unsigned file_pending;
|
||
if (!IEC104_FileService_Get_Status(app->file_service, &app->file_status)) { return false; }
|
||
if (app->file_status.finish_pending) {
|
||
/* Cancel已把所有未执行COMMIT改为ABORT;离线也可交付,不等待通知或发送容量。
|
||
* 每轮最多交付一个,应用持有资源数计入下降量,禁止仅用布尔pending判断进展。 */
|
||
if (IEC104_FileService_Execute_Next(app->file_service, &example_file_handlers, app) !=
|
||
IEC104_FILE_SERVICE_EXECUTE_OK ||
|
||
!IEC104_FileService_Get_Status(app->file_service, &app->file_status)) { return false; }
|
||
}
|
||
file_pending = (app->files.directory.active ? 1U : 0U) +
|
||
(app->files.read.active ? 1U : 0U) + (app->files.stage.active ? 1U : 0U) +
|
||
(example_upgrade_device.context == app && example_upgrade_device.file.active ? 1U : 0U);
|
||
/* 示例每类仅一个应用资源;协议清理标志必须与剩余所有权一致,不能带着悬挂句柄重建。 */
|
||
if ((file_pending != 0U) != app->file_status.finish_pending) { return false; }
|
||
pending += file_pending;
|
||
}
|
||
if (app->software_upgrade != NULL) {
|
||
/* Cancel已清执行FIFO,此处只能交付ABANDON;允许有未读通知时返回EMPTY。
|
||
* 文件最终回调与ABANDON任一先完成都不提前放开owner,最后一个义务结束才释放。 */
|
||
IEC104_SoftwareUpgradeExecuteResult_t executed =
|
||
IEC104_SoftwareUpgrade_Execute_Next(app->software_upgrade, Example_Upgrade_Action, app);
|
||
if ((executed != IEC104_SOFTWARE_UPGRADE_EXECUTE_OK && executed != IEC104_SOFTWARE_UPGRADE_EXECUTE_EMPTY) ||
|
||
!IEC104_SoftwareUpgrade_Get_Status(app->software_upgrade, &app->upgrade_status)) { return false; }
|
||
pending += app->upgrade_status.abandon_pending ? 1U : 0U;
|
||
}
|
||
if (pending == 0U) {
|
||
return app->gi_station == NULL && app->counter_station == NULL && app->command_station == NULL;
|
||
}
|
||
if (pending >= previous) { return false; }
|
||
previous = pending;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:协议实例模拟重启:不重启宿主、不操作硬件,只在正常Step返回且应用已取得复位授权后调用。
|
||
* 输入参数:app——示例应用上下文;config——初始化配置。
|
||
* 输出参数:app——本次操作更新的实例或工作区。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:顺序为Cancel -> 业务终结读空 -> Close -> Slave收尾读空 -> 新业务终结读空 -> 清应用状态 -> Init。
|
||
* 全部模块保留对象地址并收到非I帧收尾通知;本函数内不执行业务Step、不重新受理残留I帧。
|
||
* config来自main保存的原配置;port=0启动时main已换成实际端口,确保重建后仍在原端口监听。
|
||
* false表示某步未完成,主循环进入退出清理;不能绕过失败继续清事务字段或宣称重建成功。
|
||
*/
|
||
static bool Example_Rebuild_Protocol(ExampleApp *app, const IEC104_SlaveConfig_t *config)
|
||
{
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
static const int32_t initial[EXAMPLE_COUNTER_COUNT] = {0};
|
||
#else
|
||
static const int32_t initial[EXAMPLE_COUNTER_COUNT] = {120000, 345600, 7890, 0, 1, 65535, INT32_MAX, 42};
|
||
#endif
|
||
IEC104_SlaveEvent_t event;
|
||
IEC104_TcpEventResult_t next;
|
||
size_t index;
|
||
/* 短延时可跨多轮;收尾和运行值复位只做一次,后续直接进入激活等待/Init阶段。 */
|
||
if (app->restart_quiesced) { goto initialize_protocol; }
|
||
Example_Cancel(app);
|
||
/* 此时FINISHED仍可能引用旧事务编号和原站context,先处理完才能关闭/重置应用状态。 */
|
||
if (!Example_Drain_Finished(app) || IEC104_Slave_Close(app->slave, NULL) != IEC104_TCP_OK) { return false; }
|
||
while ((next = IEC104_Slave_NextEvent(app->slave, &event)) == IEC104_TCP_EVENT_READY) {
|
||
if (event.transport.type != IEC104_TCP_EVENT_I_FRAME && !Example_Handle_Event(app, &event)) { return false; }
|
||
}
|
||
if (next != IEC104_TCP_EVENT_EMPTY || !Example_Drain_Finished(app) || !Example_Drain_RemoteParameter(app)) { return false; }
|
||
/* 105只复位协议和演示运行点;已COMMIT的文件保留,旧暂存/读锁/目录快照已排空。
|
||
* faulted不能靠普通协议复位恢复,须结束服务后销毁故障实例。 */
|
||
if (app->file_service != NULL && app->file_status.faulted) { return false; }
|
||
if (app->software_upgrade != NULL && app->upgrade_status.faulted) { return false; }
|
||
if (app->remote_parameter != NULL) {
|
||
/* 旧批次和清理义务已结束;持久化模式保留选区和已固化值,RAM模式恢复初值。
|
||
* faulted不能靠复位绕过;映像版本/CRC始终不在此清零。 */
|
||
if (app->remote_status.faulted) { return false; }
|
||
if (app->config_path == NULL) { Example_Reset_Remote_Values(app); }
|
||
Example_Remote_Report_Settings(app, "reset", app->remote_area);
|
||
}
|
||
/* Close已经清空发送队列,所有旧事务通知也已处理;以下仅恢复应用运行值与游标。
|
||
* 模块统计从Create累计,保留模块对象意味着这些诊断数不会随模拟复位清零。 */
|
||
app->business_pending = app->counter_pending = app->command_pending = false;
|
||
app->command_waiting = app->command_selected = app->command_output = false;
|
||
app->command_step = 0U;
|
||
app->session_instance = app->session_request = app->counter_instance = app->counter_request = 0U;
|
||
app->command_instance = app->command_transaction = 0U;
|
||
app->command_soe_active = false;
|
||
app->command_soe_instance = app->command_soe_transaction = 0U;
|
||
memset(&app->command_soe_ticket, 0, sizeof(app->command_soe_ticket));
|
||
memset(&app->gi_data, 0, sizeof(app->gi_data));
|
||
app->counter_cursor = app->counter_end = 0U;
|
||
app->counter_first = false;
|
||
app->energy_snapshot_instance = app->energy_snapshot_request = 0U;
|
||
app->publication_count = 0U;
|
||
app->publication_waiting = app->events_pending = false;
|
||
/* QRP1从第0拍重新开始,DTU另在下方重设30秒工况起点;保留CLI选择的field/stress
|
||
* 及采样间隔,下一拍仍等待一个间隔。
|
||
* 普通STOP/重连与QRP2不走这里,继续原模拟相位,不能把每次重连当成设备重新上电。 */
|
||
app->events_index = 0U; app->events_measurement = false;
|
||
app->events_last_ms = IEC104_Net_Now_Ms();
|
||
app->command_action_called = app->command_has_change = false;
|
||
app->clock_valid = app->clock_update_pending = false;
|
||
if (app->command != NULL) { IEC104_Command_Clear_Time_Base(app->command); }
|
||
IEC104_Spontaneous_Clear_Time_Base(app->spontaneous);
|
||
/* 模拟重建协议实例时恢复步位置、位串和单/双点初值;旧事务/发布占位已在上方排空。
|
||
* 普通STOP/START及重连不走此路径,也不能在每条命令FINISHED时清零运行值。 */
|
||
memset(app->step_values, 0, sizeof(app->step_values));
|
||
memset(app->bitstring_values, 0, sizeof(app->bitstring_values));
|
||
for (index = 0U; index < EXAMPLE_SIGNAL_COUNT; ++index) {
|
||
app->signal_values[index] = Example_Initial_Signal(index);
|
||
}
|
||
for (index = 0U; index < EXAMPLE_DOUBLE_COUNT; ++index) {
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
app->double_values[index] = 2U;
|
||
#else
|
||
app->double_values[index] = 1U;
|
||
#endif
|
||
}
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
/* 重建重置DTU工况、过流延时与普通模式电量/冻结快照。
|
||
* 可选energy服务拥有独立持久计量状态,不在这些演示数组中,也不随此处清零。 */
|
||
app->dtu_started_ms = IEC104_Net_Now_Ms();
|
||
app->dtu_signal_pending = 0U;
|
||
Example_Dtu_Reset_Process(app);
|
||
app->dtu_energy_last_ms = app->dtu_started_ms;
|
||
memset(app->dtu_energy_wh, 0, sizeof(app->dtu_energy_wh));
|
||
memset(app->dtu_energy_frozen_wh, 0, sizeof(app->dtu_energy_frozen_wh));
|
||
#endif
|
||
for (index = 0U; index < EXAMPLE_MEASUREMENT_COUNT; ++index) { app->scaled_values[index] = Example_Initial_Measurement(index); }
|
||
/* 旧任务已清除。纯内存演示恢复参数初值;有配置文件时QRP1只复位协议与测量状态,
|
||
* 保留当前运行参数及dirty/退避状态,不能从较旧磁盘值覆盖尚未保存的有效修改。 */
|
||
if (app->parameter != NULL) {
|
||
if (app->config_path == NULL) { Example_Reset_Parameter_Values(app); }
|
||
else { Example_Reset_Measurements(app); }
|
||
}
|
||
/* 周期数组仍被扫描模块借用,逐点setter同时更新内部调度;不能直接改数组或清重试位图。
|
||
* 普通STOP/重连保留启停结果,只有本次模拟协议复位按示例策略恢复配置周期。 */
|
||
if (app->parameter_cyclic_ms != 0U) {
|
||
for (index = 0U; index < EXAMPLE_SCAN_POINT_COUNT; ++index) {
|
||
if ((app->scan_points[index].groups & 1U) != 0U &&
|
||
!IEC104_PeriodicScan_Set_Point_Period(app->periodic_scan, index, app->parameter_cyclic_ms)) {
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
memset(app->counter_frozen, 0, sizeof(app->counter_frozen));
|
||
memset(app->counter_snapshot, 0, sizeof(app->counter_snapshot));
|
||
memset(app->counter_snapshot_time, 0, sizeof(app->counter_snapshot_time));
|
||
for (index = 0U; index < EXAMPLE_COUNTER_COUNT; ++index) {
|
||
app->counter_current[index] = initial[index]; app->counter_frozen[index].value = initial[index];
|
||
Example_Counter_Time(app, &app->counter_frozen_time[index]);
|
||
}
|
||
app->restart_quiesced = true;
|
||
initialize_protocol:
|
||
/* 普通105没有taken升级任务,不调用Prepare_Boot;协议复位不能被解释为新的试运行启动。
|
||
* 达到短延时后一次性安装;之后任何初始化/确认失败都退出,避免第二次Prepare把本次TRIAL回退。 */
|
||
if (example_upgrade_device.context == app && example_upgrade_device.taken) {
|
||
uint64_t now = IEC104_Net_Now_Ms();
|
||
if (now < example_upgrade_device.activation.taken_ms) { return false; }
|
||
/* 监听和连接已关闭;主循环在QUIESCING内有界定时等待,不推进普通业务。 */
|
||
if (now - example_upgrade_device.activation.taken_ms < EXAMPLE_UPGRADE_DELAY_MS) { return true; }
|
||
if (!Example_Upgrade_Prepare_Boot(app)) { return false; }
|
||
}
|
||
if (IEC104_Slave_Init(app->slave, config, NULL) != IEC104_TCP_OK ||
|
||
!IEC104_SystemCommand_Set_Initialization(app->system_command, 2U)) { return false; }
|
||
/* COI2登记在尚未激活的新实例上;下一次ACTIVATED才开始逐站上送初始化结束。
|
||
* 新协议初始化全部成功才结清应用激活任务并发布版本/CRC,随后才恢复正常业务。 */
|
||
if (!Example_Upgrade_Confirm_Boot(app)) { return false; }
|
||
Example_Refresh_System_Clock(app, true);
|
||
Example_Upgrade_Activation_Finished(app, true);
|
||
Example_User_Log_Append(app, 1U, 1U, IEC104_Net_Now_Ms(), "SIMULATED PROTOCOL_RESTART");
|
||
app->restart_requested = app->restart_quiesced = app->quiescing = false;
|
||
++app->protocol_restarts;
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:统一激活失败出口:保留最后确认的映像值、记录失败并释放内存任务。
|
||
* 输入参数:app——示例应用上下文;config——初始化配置。
|
||
* 输出参数:无独立输出参数。
|
||
* 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。
|
||
* 说明:持久AUTH/TRIAL留给下次启动恢复,协议不会二次授权或重发确认。
|
||
*/
|
||
static bool Example_Restart_Protocol(ExampleApp *app, const IEC104_SlaveConfig_t *config)
|
||
{
|
||
bool result = Example_Rebuild_Protocol(app, config);
|
||
if (!result) { Example_Upgrade_Activation_Finished(app, false); }
|
||
return result && !app->user_log_failed && !app->upgrade_store_failed;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [COMMON/DESTROY] 初始化失败及正常退出共用的资源释放
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:释放已创建的业务模块并移除应用站点,供初始化回退及正常退出共用。
|
||
* 输入参数:app——非NULL,已由Example_Init清零并记录slave;非空业务句柄尚未销毁。
|
||
* 输出参数:归还业务模块槽及其站点引用,最后尝试移除仍注册的app->station。
|
||
* 返回值:true表示所有需要执行的释放均成功;任一失败返回false,但仍尝试其余释放。
|
||
* 说明:本函数不取消事务、不关闭连接,也不消费通知。运行期先Cancel并调用
|
||
* Example_Drain_Finished,再Close并分派剩余Slave通知,最后再次调用
|
||
* Example_Drain_Finished,确保终结事件读空、应用引用已归还后才进入本函数。
|
||
* 初始化失败尚未接收通知,允许部分句柄为NULL,无须走运行期排空流程。
|
||
* 扫描不跨调用持有站点引用,Destroy归还静态池槽并结束对app->scan_points的借用,不关闭Slave。
|
||
* 运行期仍统一遵守Cancel -> Close并读空通知 -> Destroy,确保扫描收到停用/断线后再结束借用。
|
||
* 本函数不清空句柄;即使返回false也可能已部分释放,不可重复调用或继续执行业务。
|
||
* Slave由main或测试夹具持有,须由调用方另行销毁;app存储本身仍属于调用方。
|
||
*/
|
||
static bool Example_Destroy(ExampleApp *app)
|
||
{
|
||
bool result = true;
|
||
if (!Example_Startup_Reset(app)) { result = false; }
|
||
if (app->software_upgrade != NULL && !IEC104_SoftwareUpgrade_Destroy(app->software_upgrade)) { result = false; }
|
||
if (example_upgrade_device.owned && example_upgrade_device.context == app) { result = false; }
|
||
if (app->interrogation != NULL && !IEC104_Interrogation_Destroy(app->interrogation)) { result = false; }
|
||
if (app->counter != NULL && !IEC104_Interrogation_Destroy(app->counter)) { result = false; }
|
||
if (app->clock != NULL && !IEC104_ClockSynchronization_Destroy(app->clock)) { result = false; }
|
||
if (app->command != NULL && !IEC104_Command_Destroy(app->command)) { result = false; }
|
||
if (app->read != NULL && !IEC104_Read_Destroy(app->read)) { result = false; }
|
||
if (app->parameter != NULL && !IEC104_Parameter_Destroy(app->parameter)) { result = false; }
|
||
/* Destroy不隐式取消或回调清理;调用方必须先完成RemoteParameter专用排空。 */
|
||
if (app->remote_parameter != NULL && !IEC104_RemoteParameter_Destroy(app->remote_parameter)) { result = false; }
|
||
/* 文件模块Destroy只归还协议池槽;应用目录/读锁/暂存必须已经在原context中完成收尾。 */
|
||
if (app->file_service != NULL && !IEC104_FileService_Destroy(app->file_service)) { result = false; }
|
||
/* 历史和日志存储须晚于文件协议资源收尾关闭;这里释放缓存和文件锁,不清空持久记录。
|
||
* 初始化后半段失败也沿用此出口,不能因user_log_failed而遗漏已取得的存储锁。 */
|
||
if (app->history != NULL) { Example_History_Close(app->history); app->history = NULL; }
|
||
if (app->energy != NULL) {
|
||
IEC60870_EnergyFreezeStatus_t energy_status;
|
||
if (IEC60870_EnergyFreeze_Get_Status(&app->energy->core, &energy_status)) {
|
||
printf("ENERGY_FREEZE flowrev=%llu dropped=%llu evicted_unsealed=%lu seal_backlog=%lu faulted=%u\n",
|
||
(unsigned long long)energy_status.flow_sequence,
|
||
(unsigned long long)app->energy_meter->flowrev_dropped,
|
||
(unsigned long)energy_status.evicted_unsealed, (unsigned long)energy_status.seal_backlog,
|
||
energy_status.faulted ? 1U : 0U);
|
||
}
|
||
Example_Energy_Freeze_Close(app->energy); app->energy = NULL; app->energy_meter = NULL;
|
||
}
|
||
if (app->user_log != NULL) { Example_User_Log_Close(app->user_log); app->user_log = NULL; }
|
||
/* 升级最终回调及内存owner已结清后才释放独占目录锁;Close不撤回持久授权或试运行事实。 */
|
||
if (app->upgrade_store != NULL) { Example_Upgrade_Store_Close(app->upgrade_store); app->upgrade_store = NULL; }
|
||
if (app->system_command != NULL && !IEC104_SystemCommand_Destroy(app->system_command)) { result = false; }
|
||
if (app->spontaneous != NULL && !IEC104_Spontaneous_Destroy(app->spontaneous)) { result = false; }
|
||
if (app->periodic_scan != NULL && !IEC104_PeriodicScan_Destroy(app->periodic_scan)) { result = false; }
|
||
if (IEC104_Station_Is_Registered(&app->station) &&
|
||
IEC104_Slave_Remove_Station(app->slave, &app->station) != IEC104_STATION_OK) { result = false; }
|
||
return result;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [CLI/HELPERS] 程序入口辅助:平台依赖、退出信号、参数解析与帮助
|
||
* ============================================================================ */
|
||
#ifndef IEC104_SLAVE_EXAMPLE_NO_MAIN
|
||
#ifndef _WIN32
|
||
#error "This executable uses the Windows network backend"
|
||
#endif
|
||
#ifndef _WIN32_WINNT
|
||
/* GetTickCount64所需的最低Windows API声明;这里只用于示例运行时长,不处理业务时标。 */
|
||
#define _WIN32_WINNT 0x0600
|
||
#endif
|
||
#ifndef WIN32_LEAN_AND_MEAN
|
||
/* 只引入本入口需要的Windows基础声明,socket操作仍全部留在协议库的Net后端。 */
|
||
#define WIN32_LEAN_AND_MEAN
|
||
#endif
|
||
#include <windows.h>
|
||
#include <errno.h>
|
||
#include <signal.h>
|
||
|
||
/* 信号处理器和主循环之间只交换停止标志;静态初始化为0,不在信号处理器中访问任务或网络。 */
|
||
static volatile sig_atomic_t example_stop;
|
||
|
||
/**
|
||
* 功能:在已注册的停止信号到来时请求主循环退出。
|
||
* 输入参数:signal_number——运行库传入的信号编号,这里不区分SIGINT与SIGTERM。
|
||
* 输出参数:example_stop置1。
|
||
* 返回值:无。
|
||
* 说明:信号上下文只写sig_atomic_t,不打印、不分配、不调用Slave;资源由main正常收尾。
|
||
*/
|
||
static void Example_Stop(int signal_number) { (void)signal_number; example_stop = 1; }
|
||
|
||
/**
|
||
* 功能:把纯十进制命令行文本解析为不超过max的unsigned long。
|
||
* 输入参数:text——非NULL且以NUL结束的字符串;max——此选项允许的最大值。
|
||
* 输出参数:value——非NULL输出存储,仅成功时写入;失败保持原值。
|
||
* 返回值:true为整个字符串解析成功且未越界;false为空串、符号/空白前缀、尾部字符或溢出。
|
||
* 说明:先检查再截窄为端口、CA或窗口类型,避免越界数值被静默截断;允许前导零及数值0。
|
||
* 某些选项禁止0,由main另查;端口0表示自动分配,run-ms=0表示持续运行。
|
||
*/
|
||
static bool Example_Number(const char *text, unsigned long max, unsigned long *value)
|
||
{
|
||
char *end;
|
||
unsigned long parsed;
|
||
if (text[0] < '0' || text[0] > '9') { return false; }
|
||
/* strtoul通过errno报告数值溢出;先清零,避免沿用上一次库调用的错误。 */
|
||
errno = 0;
|
||
parsed = strtoul(text, &end, 10);
|
||
if (errno != 0 || *end != '\0' || parsed > max) { return false; }
|
||
*value = parsed;
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:向标准输出打印本示例支持的选项、默认监听配置及模拟点地址范围。
|
||
* 输入参数:program——非NULL程序名称,main传入argv[0]。
|
||
* 输出参数:无,文本写入stdout。
|
||
* 返回值:无。
|
||
* 说明:本函数不创建服务或退出进程;main根据--help或缺少参数分别选择成功/失败退出。
|
||
*/
|
||
static void Example_Usage(const char *program)
|
||
{
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
printf("Usage: %s [--bind IPv4] [--port 0..65535] [--ca 1..65534]\n"
|
||
" [--window N | --k N] [--run-ms N] [--events N] [--simulation field|stress]\n"
|
||
" [--cyclic-ms N] [--background-ms N] [--sequence] [--clock simulated|system]\n"
|
||
" [--parameter | --no-parameter] [--remote-parameter] [--command-extensions]\n"
|
||
" [--counter-type 15|37|206|207] [--config FILE] [--file-service]\n"
|
||
" [--history DIR] [--user-log DIR] [--recording-demo DIR]\n"
|
||
" [--dtu-input FILE] [--dtu-recording DIR] (secondary inputs / triggered recording)\n"
|
||
" [--energy-freeze DIR] [--energy-period-ms 2000..86400000]\n"
|
||
" [--software-upgrade] [--upgrade-store DIR] [--upgrade-seed I104-PACKAGE]\n"
|
||
" [--gi-total-timeout N] [--ci-total-timeout N]\n"
|
||
"DTU 100V/1A: 59 source SP, 30 physical Type13 YC, 19 source controls.\n"
|
||
"Supplemental DP1001..1010, step1201..1208, bits1301..1308 (hex IOAs).\n"
|
||
"Controls: battery6001, switches6002..6011, reset6012, enable6013; select/execute/cancel.\n"
|
||
"Extensions: step6101..6108, scaled setpoints6201..621E; direct bits6301..6308 require --command-extensions.\n"
|
||
"YC4001..401E; energy6401..6408 starts at zero (first four P+/Q+/P-/Q-).\n"
|
||
"GI100 all/group/cancel, Read102 SP/DP/YC/step/bits, SOE30/31, scans13 COT1/2/3.\n"
|
||
"Clock103, tests104/107, reset105 QRP1 protocol restart, QRP2 pending timestamped events clear.\n"
|
||
"Remote200..203 enabled: five areas0..4; 345 filled source settings, 85 empty entries stay absent.\n"
|
||
"Action settings8820..88FF are per-area; running/scales/inversions use SN0; source maps are fixed.\n"
|
||
"Preset stages, solidify validates/saves/applies, cancel discards; selecting an area is separate.\n"
|
||
"Standard parameters: threshold8601..861E, low8621..863E, high8641..865E, smooth8661..867E.\n"
|
||
"Threshold first4 Type111, remaining Type110; low/high Type111; smoothing Type112 seconds; Type113 cyclic enable.\n"
|
||
"Scaled parameters/setpoints use internal units: V/Hz/temp/humidity/h x100, A x1000, PF x10000, W/var x10.\n"
|
||
"Threshold default200 internal counts; normalized655/32768 of10000; limits -10000..10000.\n"
|
||
"Defaults: localhost2404 CA1 k12, field100ms, background30000ms, cyclic off, standard/remote parameters on.\n"
|
||
"Field30s: first5s0.4A, next10s1.3A, then recovery; three OC stages use configured threshold/delay/enable.\n"
|
||
"Protection uses secondary values; trip/reclose changes SW00. --events 0 pauses process sampling.\n"
|
||
"Read102 source aliases: 9601..962C analog (except961C..961E), 9141..919D digital, B100..B10F coils.\n"
|
||
"FA topology, proprietary encryption and serial101 require external definitions/backends.\n"
|
||
"Type210 TEMP upload/download up to4KiB. Storage DIRs must already exist.\n"
|
||
"History creates SOE/CO/FIXPT/EXV XML; user-log creates ULOG XML; energy adds FRZ/FLOWREV and durable recovery.\n"
|
||
"Recording generates COMTRADE1999 CFG/BINARY DAT and Type42 fault summary.\n"
|
||
"RAM211 requires --file-service; --upgrade-store enables210/211 HOST_FILE install/backup/confirm/rollback.\n"
|
||
"Empty upgrade store requires --upgrade-seed; uploaded payload files are never executed.\n"
|
||
"--config persists standard parameters, five remote areas and TEMP; invalid files stop startup.\n"
|
||
"See docs/examples/DTU configuration demonstration for the complete source mapping and test commands.\n", program);
|
||
#else
|
||
printf("Usage: %s [--bind IPv4] [--port 0..65535] [--ca 1..65534]\n"
|
||
" [--window 1..32767] [--run-ms milliseconds] [--clock simulated|system]\n"
|
||
" [--events milliseconds] (0 disables periodic simulated changes)\n"
|
||
" [--simulation field|stress]\n"
|
||
" [--counter-type 15|37|206|207] (default 206)\n"
|
||
" [--command-extensions] (optional Type51/64 direct bitstring controls)\n"
|
||
" [--cyclic-ms milliseconds] [--background-ms milliseconds] [--sequence]\n"
|
||
" [--parameter|--no-parameter] [--config file.ini]\n"
|
||
" [--remote-parameter] (optional Type200..203, default disabled)\n"
|
||
" [--file-service] (optional Type210, default disabled)\n"
|
||
" [--recording-demo existing-directory] (synthetic fault, enables Type210)\n"
|
||
" [--history existing-directory] (durable SOE/CO/FIXPT/EXV XML, enables Type210)\n"
|
||
" [--energy-freeze existing-directory] [--energy-period-ms 2000..86400000]\n"
|
||
" [--user-log existing-directory] (durable Annex C ULOG XML, enables Type210)\n"
|
||
" [--software-upgrade] (optional Type211; requires --file-service)\n"
|
||
" [--upgrade-store existing-directory] [--upgrade-seed complete-I104-package]\n"
|
||
" [--gi-total-timeout milliseconds] [--ci-total-timeout milliseconds]\n"
|
||
"Remote parameters: five settings (areas 0..4); Type200 selects, Type202 reads the requested area.\n"
|
||
"Type203 stages then solidifies; saving an inactive area does not select it. Non-area values require SN=0.\n"
|
||
"Defaults: reset seconds=30/60/90/120/150, X time seconds=1/2/3/4/5; REMOTE_SETTINGS shows the selected set.\n"
|
||
"Files: HISTORY/SOE and HISTORY/ULOG contain demonstration text; TEMP/name is writable up to 4096 bytes.\n"
|
||
"COMTRADE is empty unless --recording-demo captures and saves one synthetic CFG/BINARY DAT pair.\n"
|
||
"--history replaces the SOE demo with Annex B XML and adds CO, EXV and FIXPT directories.\n"
|
||
"--user-log replaces the ULOG demo with ulog.xml; storage is independent from --history.\n"
|
||
"ULOG records host starts, TCP state, applied parameters and SIMULATED or HOST_FILE upgrade stages.\n"
|
||
"History needs a valid startup wall clock; data survives protocol reset and process restart.\n"
|
||
"--energy-freeze adds FRZ/FLOWREV XML in energy.store; requires Type206 and QCC=0x05.\n"
|
||
"Energy period must be divisible by 4 (default 1200000); periods below 60000 are for testing.\n"
|
||
"Type211 uses upgrade.bin (17..65536 bytes, I104 header); only a protocol restart is simulated.\n"
|
||
"--upgrade-store enables Type210/211 and streams packages up to 16 MiB to durable storage.\n"
|
||
"An empty store requires --upgrade-seed; an existing store rejects seed replacement.\n"
|
||
"HOST_FILE mode installs and verifies dtu/dtu-1 payload files; it never executes a payload.\n"
|
||
"Defaults: 127.0.0.1:2404, CA=1, k=12, run until Ctrl+C.\n"
|
||
"GI/CI total timeouts default to %lu/%lu ms; explicit 0 disables with a warning.\n"
|
||
"Totals cover BEGIN through ACT_TERM acceptance, not delivery; tune for each deployment.\n"
|
||
"Pure counter freeze/reset confirmation is outside the total timeout.\n"
|
||
"GI: QOI=20 (all), 21 (single/double signals), 22 (scaled); IOA=0.\n"
|
||
"Single signals 1001..1008, double signals 1101..1108, scaled values 0x4001..0x4008.\n"
|
||
"COT=8 cancels matching GI.\n"
|
||
"Defaults: parameters on, field simulation every 100ms, cyclic off, background every 30000ms.\n"
|
||
"Field simulation updates all measurements with small noise, slow load changes and finite steps; signals stay stable.\n"
|
||
"Stress simulation alternates signal toggles and measurement increments; --events sets the sample interval.\n"
|
||
"Scan periods must be 0 or >=100ms, with first delay equal to period.\n"
|
||
"Cyclic sends Type11 COT1; background sends Type11 COT2 using idle opportunities only.\n"
|
||
"--sequence enables SQ=1 for cyclic/background scans; general interrogation monitoring data always uses SQ=1.\n"
|
||
"--parameter enables default standard Type110..113 services; --no-parameter disables them and the 32 QOI20 parameters.\n"
|
||
"--config stores standard parameters, remote settings and TEMP in one INI; parent directory must exist.\n"
|
||
"All stored sections are validated and preserved even when their protocol service is disabled.\n"
|
||
"Edit INI only while stopped; comments/order are rewritten on save. TEMP data uses hex with CRC32.\n"
|
||
"Missing config is created; legacy layout may migrate to version 2, but old parameter IOAs must be migrated explicitly.\n"
|
||
"Invalid files stop startup; use one writer per config path.\n"
|
||
"Standard parameter writes coalesce for 500ms, retry after 5000ms and flush on exit; their ACT_CON is not a disk receipt.\n"
|
||
"Remote switch/solidify and TEMP COMMIT save before publishing; storage failure rejects and retains old values.\n"
|
||
"QRP1 keeps configured parameters and TEMP; without --config, parameters reset and TEMP lasts until process exit.\n"
|
||
"Thresholds 0x8601..0x8604 use Type111, 0x8605..0x8608 Type110; lows0x8611..0x8618/highs0x8621..0x8628 Type111.\n"
|
||
"Smoothing 0x8631..0x8638 uses Type112, 0..60 seconds. Thresholds must be nonnegative.\n"
|
||
"Default thresholds: Type111=200, Type110 raw=655 (integer delta 200); smoothing=0 seconds.\n"
|
||
"These values illustrate the simulation and must be calibrated for an actual process.\n"
|
||
"Limits must stay ordered within -10000..10000: raise the upper limit before raising the lower.\n"
|
||
"QPA3 controls cyclic measurements0x4001..0x4008 with --cyclic-ms; QPA1/2 are rejected.\n"
|
||
"Parameters drive smoothing, range quality (OV), and COT3 change thresholds; COT1/2 and reads are unfiltered by thresholds.\n"
|
||
"Type110 thresholds use a fixed full-scale magnitude of 10000; smoothing uses elapsed monotonic time.\n"
|
||
"Read: Type102 COT5, IOA1001..1008/1101..1108/1201..1208/1301..1308/0x4001..0x4008 -> Type30/31/5/7/11.\n"
|
||
"Other read IOAs return COT47; TEST is echoed; acceptance timeout defaults to 15000ms.\n"
|
||
"System commands: Type107 COT6 IOA0 echoes TSC/CP56 with ACT_CON.\n"
|
||
"Type70 COT4 reports COI=0 after initialization, COI=2 after simulated reset.\n"
|
||
"Type105 COT6 IOA0: QRP1 restarts this protocol instance only after ACT_CON ACK (30000ms).\n"
|
||
"QRP2 clears pending time-tagged events for this CA; plain events remain. TEST only confirms.\n"
|
||
"Cancellation revokes reset permission; an accepted positive confirmation may still arrive without reset.\n"
|
||
"Counters: default Type206, IOA0x6401..0x6408, kWh from integer Wh, SQ=1, RQT=5 only.\n"
|
||
"Type206 reads current values; Type207 reads frozen values with their original CP56 timestamps.\n"
|
||
"Type15/37 use IOA0x6401..0x6408, integer frozen values, SQ=0 and RQT=1/2/5. Four points per batch.\n"
|
||
"FRZ=1 freezes; 2 freezes/resets; 3 resets current values. Unclocked freeze timestamps carry IV=1.\n"
|
||
"Without --energy-freeze counters are simulated RAM values; --config does not persist energy.\n"
|
||
"Freeze/reset completes with ACT_CON only; TEST confirms without action; COT=8 is rejected.\n"
|
||
"Clock: simulated by default; system sets the actual clock and requires permission.\n"
|
||
"Clock requests use UTC+8 standard time; valid TEST confirms without setting time.\n"
|
||
"Commands: Type45 IOA0x6001..0x6008 -> signals1001..1008; Type46 IOA0x6011..0x6018 -> double1101..1108.\n"
|
||
"Setpoints: Type49 IOA0x6031..0x6038 -> scaled0x4001..0x4008; allowed range -10000..10000.\n"
|
||
"Step commands: Type47 IOA0x6021..0x6028 -> Type5 positions1201..1208; state1 lowers, state2 raises, QU=0.\n"
|
||
"Positions start at 0, range -64..63; each execution moves one step, out-of-range requests are rejected.\n"
|
||
"Bitstrings (--command-extensions only): Type51 IOA0x6041..0x6048 -> Type7 bits1301..1308, initially 0.\n"
|
||
"Step/bitstring monitor points support reads and command returns; GI/cyclic/background point sets are unchanged.\n"
|
||
"Timed commands: Type58/59/60/62/64 use the same points and returns as Type45/46/47/49/51.\n"
|
||
"Timed commands require a valid clock; max age/future difference is 10000ms; expired requests get negative COT49.\n"
|
||
"System clock is read at startup and every 60s; invalid reads clear the command time base.\n"
|
||
"Signals outside GI use Type30/31 only; SOE is invalid until clock synchronization, acquisition time is frozen.\n"
|
||
"Responses use HIGH; event publication uses NORMAL without a cross-queue ordering barrier.\n"
|
||
"Select/execute: IOA0x6001..0x6008, 0x6011..0x6018, 0x6021..0x6028, 0x6031..0x6038; select timeout 60000ms.\n"
|
||
"Direct execute: only IOA0x6041..0x6048 with --command-extensions; bitstrings have no S/E field.\n"
|
||
"Command completion: COT10 P/N=0 for success, P/N=1 for failure or execution-result timeout.\n"
|
||
"Execution-result timeout keeps TCP open; the physical result remains unknown.\n"
|
||
"Simulated command actions normally succeed immediately.\n"
|
||
"COT8 cancels matching selection; TEST simulates the protocol without device output.\n", program,
|
||
(unsigned long)EXAMPLE_GI_TOTAL_TIMEOUT_MS, (unsigned long)EXAMPLE_CI_TOTAL_TIMEOUT_MS);
|
||
#endif
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [ENTRY/MAIN] 程序入口:配置、启动、事件循环、统计与有序退出
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:配置并运行子站示例,退出时关闭服务、读空通知并归还静态槽。
|
||
* 输入参数:argc/argv——命令行;开关与带值选项见Example_Usage。
|
||
* 输出参数:stdout输出帮助、监听端点和累计统计;stderr输出参数或运行失败信息。
|
||
* 返回值:EXIT_SUCCESS为帮助输出或正常停止;参数、初始化、运行或清理失败为EXIT_FAILURE。
|
||
* 说明:服务生命周期为Create -> Init -> 循环Poll/Drain/Step -> Close -> 读空事件 -> Destroy。
|
||
* main拥有Slave句柄,app只借用;静态app和库内任务在整个运行期间保持地址不变。
|
||
* run-ms使用单调毫秒时钟,在循环边界检查,表示约定运行时长而非精确的退出截止时刻。
|
||
*/
|
||
int main(int argc, char **argv)
|
||
{
|
||
static ExampleApp app; /* 注册站点及业务借用的存储在退出前保持地址不变。 */
|
||
static ExampleRecording recording; /* 主机示例专用存储,存活到退出;不并入协议实例池,也不占main的栈。 */
|
||
static ExampleHistory history; /* 宿主存储工作区与快照句柄跨协议重建保留,进程退出时统一关闭。 */
|
||
static ExampleEnergyFreeze energy;
|
||
static ExampleEnergyMeter energy_meter;
|
||
static ExampleUserLog user_log; /* 独立运行日志;只由显式开关启用,协议重建保留。 */
|
||
static ExampleUpgrade upgrade_store; /* 仅持久模式使用;关闭协议与文件回调后才归还存储锁。 */
|
||
IEC104_SlaveConfig_t config; /* 本地配置,Slave_Init会复制,不在运行中借用它。 */
|
||
IEC104_TcpError_t error; /* 最近一次服务接口调用的诊断,与历史网络错误分开。 */
|
||
IEC104_TcpServerStatus_t status; /* 启动后查询实际端口,尤其用于--port=0。 */
|
||
IEC104_Slave_t *slave; /* main持有的唯一服务句柄,清理结束后不再使用。 */
|
||
IEC104_TcpResult_t result; /* 服务结果须显式比较IEC104_TCP_OK,不能作布尔判断。 */
|
||
uint16_t common_address = 1U; /* 应用地址校验条件,不是TCP端口或单点IOA。 */
|
||
uint8_t counter_type = IEC60870_ASDU_M_IT_NB_1;
|
||
unsigned long run_ms = 0U; /* 0为持续运行,非零为命令行指定的运行毫秒数。 */
|
||
/* 默认用门限变化上送加低频背景刷新;100ms是输入采样间隔,不是强制上送周期。
|
||
* 固定周期由--cyclic-ms单独开启;只关参数不自动关闭模拟或扫描,选项各自独立。 */
|
||
uint32_t events_interval_ms = EXAMPLE_SAMPLE_MS;
|
||
uint32_t cyclic_ms = 0U, background_ms = EXAMPLE_BACKGROUND_MS;
|
||
bool sequence = false, command_extensions = false;
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
bool parameter = true, events_field = true, remote_parameter = true;
|
||
const char *dtu_input_path = NULL, *dtu_recording_directory = NULL;
|
||
#else
|
||
bool parameter = true, events_field = true, remote_parameter = false; /* 远程参数独立于标准参数开关,默认关闭。 */
|
||
#endif
|
||
bool file_service = false, software_upgrade = false; /* 两个运行开关;211需要210已经开启。 */
|
||
const char *config_path = NULL; /* argv中的路径至进程退出始终有效,ExampleApp只借用。 */
|
||
const char *recording_directory = NULL; /* 借用argv中的输出父目录;NULL表示未启用模拟录波。 */
|
||
const char *history_directory = NULL; /* 借用已有存储目录路径;NULL 不打开持久历史,也不创建后台任务。 */
|
||
const char *energy_directory = NULL;
|
||
uint32_t energy_period_ms = 1200000U;
|
||
bool energy_period_set = false;
|
||
const char *user_log_directory = NULL; /* 与历史独立,可指定同一父目录但使用不同持久文件。 */
|
||
const char *upgrade_directory = NULL, *upgrade_seed = NULL; /* 种子仅用于首次建库,后端禁止覆盖已有库。 */
|
||
uint32_t gi_total_timeout_ms = EXAMPLE_GI_TOTAL_TIMEOUT_MS;
|
||
uint32_t ci_total_timeout_ms = EXAMPLE_CI_TOTAL_TIMEOUT_MS;
|
||
IEC104_SpontaneousStatus_t event_status = {0};
|
||
bool clock_system = false; /* 默认模拟;解析后再写入Example_Init清零后的app。 */
|
||
uint64_t started; /* 开始主循环前的单调时刻,与CP56日历时间无关。 */
|
||
int arg, exit_code = EXIT_SUCCESS; /* arg遍历选项和值;任一阶段失败后保留失败退出码。 */
|
||
/* 第1步:使用统一细则配置,之后再填写设备地址;同一入口配置各业务模块。
|
||
* Init_Startup与EVERY_START配套协调本轮完成,不提供静默关闭门禁的默认分支。 */
|
||
IEC104_Startup_Config_Default(&config, NULL, NULL, NULL, NULL);
|
||
memcpy(config.bind_address, "127.0.0.1", sizeof("127.0.0.1"));
|
||
for (arg = 1; arg < argc; ++arg) {
|
||
unsigned long value; /* 先在宽整数中验证范围,再赋给配置中的较窄字段。 */
|
||
const char *option = argv[arg];
|
||
if (strcmp(option, "--help") == 0) { Example_Usage(argv[0]); return EXIT_SUCCESS; }
|
||
if (strcmp(option, "--sequence") == 0) { sequence = true; continue; }
|
||
if (strcmp(option, "--command-extensions") == 0) { command_extensions = true; continue; }
|
||
/* 参数开关按出现顺序覆盖;--parameter保留显式启用写法,未指定时本来就开启。 */
|
||
if (strcmp(option, "--parameter") == 0) { parameter = true; continue; }
|
||
if (strcmp(option, "--no-parameter") == 0) { parameter = false; continue; }
|
||
/* 只打开200–203示例;--config另行选择是否持久化,不启用升级或通信重配置。 */
|
||
if (strcmp(option, "--remote-parameter") == 0) { remote_parameter = true; continue; }
|
||
if (strcmp(option, "--file-service") == 0) { file_service = true; continue; }
|
||
if (strcmp(option, "--software-upgrade") == 0) { software_upgrade = true; continue; }
|
||
/* 其余选项必须有值;此处前进一次取值,for尾部再前进一次到下一个选项。 */
|
||
if (++arg == argc) { Example_Usage(argv[0]); return EXIT_FAILURE; }
|
||
if (strcmp(option, "--bind") == 0) {
|
||
/* 这里只保证固定数组能容纳含NUL的文本,IPv4语法由Slave_Init中的Net后端检查。 */
|
||
if (strlen(argv[arg]) >= sizeof(config.bind_address)) { return EXIT_FAILURE; }
|
||
strcpy(config.bind_address, argv[arg]);
|
||
} else if (strcmp(option, "--config") == 0 && argv[arg][0] != '\0') {
|
||
config_path = argv[arg];
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
} else if (strcmp(option, "--dtu-input") == 0 && argv[arg][0] != '\0') {
|
||
dtu_input_path = argv[arg];
|
||
} else if (strcmp(option, "--dtu-recording") == 0 && argv[arg][0] != '\0') {
|
||
dtu_recording_directory = argv[arg]; file_service = true;
|
||
#endif
|
||
} else if (strcmp(option, "--recording-demo") == 0 && argv[arg][0] != '\0') {
|
||
/* 演示需要TI210供主站主动取回文件,因此同时启用文件服务。 */
|
||
recording_directory = argv[arg]; file_service = true;
|
||
} else if (strcmp(option, "--user-log") == 0 && argv[arg][0] != '\0') {
|
||
user_log_directory = argv[arg]; file_service = true;
|
||
} else if (strcmp(option, "--upgrade-store") == 0 && argv[arg][0] != '\0') {
|
||
/* 显式选择文件安装模式,同时接通210上传与211授权;不改变单独模拟开关的默认行为。 */
|
||
upgrade_directory = argv[arg]; software_upgrade = file_service = true;
|
||
} else if (strcmp(option, "--upgrade-seed") == 0 && argv[arg][0] != '\0') {
|
||
/* 只借用输入路径;空库必需、已有库禁止覆盖的条件由持锁后的后端判定。 */
|
||
upgrade_seed = argv[arg];
|
||
} else if (strcmp(option, "--history") == 0 && argv[arg][0] != '\0') {
|
||
/* 历史与录波共用 TI210 调阅入口;此选项只打开历史,不隐式开启模拟录波。 */
|
||
history_directory = argv[arg]; file_service = true;
|
||
} else if (strcmp(option, "--energy-freeze") == 0 && argv[arg][0] != '\0') {
|
||
energy_directory = argv[arg]; file_service = true;
|
||
} else if (strcmp(option, "--energy-period-ms") == 0 &&
|
||
Example_Number(argv[arg], 86400000U, &value) && value >= 2000U && value % 4U == 0U) {
|
||
energy_period_ms = (uint32_t)value; energy_period_set = true;
|
||
} else if (strcmp(option, "--port") == 0 && Example_Number(argv[arg], UINT16_MAX, &value)) {
|
||
config.port = (uint16_t)value;
|
||
} else if (strcmp(option, "--ca") == 0 && Example_Number(argv[arg], 65534U, &value) && value != 0U) {
|
||
common_address = (uint16_t)value;
|
||
} else if (strcmp(option, "--counter-type") == 0 && Example_Number(argv[arg], UINT8_MAX, &value) &&
|
||
(value == 15U || value == 37U || value == 206U || value == 207U)) {
|
||
counter_type = (uint8_t)value;
|
||
} else if ((strcmp(option, "--window") == 0 || strcmp(option, "--k") == 0) &&
|
||
Example_Number(argv[arg], IEC104_SEQUENCE_MASK, &value) && value != 0U) {
|
||
config.protocol.link.k = (uint16_t)value;
|
||
} else if (strcmp(option, "--run-ms") == 0 && Example_Number(argv[arg], UINT32_MAX, &value)) {
|
||
run_ms = value;
|
||
} else if (strcmp(option, "--events") == 0 && Example_Number(argv[arg], UINT32_MAX, &value)) {
|
||
events_interval_ms = (uint32_t)value;
|
||
} else if (strcmp(option, "--simulation") == 0 && strcmp(argv[arg], "field") == 0) {
|
||
events_field = true;
|
||
} else if (strcmp(option, "--simulation") == 0 && strcmp(argv[arg], "stress") == 0) {
|
||
events_field = false;
|
||
} else if (strcmp(option, "--cyclic-ms") == 0 && Example_Number(argv[arg], UINT32_MAX, &value) &&
|
||
(value == 0U || value >= IEC104_PERIODIC_SCAN_MIN_PERIOD_MS)) {
|
||
cyclic_ms = (uint32_t)value;
|
||
} else if (strcmp(option, "--background-ms") == 0 && Example_Number(argv[arg], UINT32_MAX, &value) &&
|
||
(value == 0U || value >= IEC104_PERIODIC_SCAN_MIN_PERIOD_MS)) {
|
||
background_ms = (uint32_t)value;
|
||
} else if (strcmp(option, "--gi-total-timeout") == 0 && Example_Number(argv[arg], UINT32_MAX, &value)) {
|
||
gi_total_timeout_ms = (uint32_t)value;
|
||
} else if (strcmp(option, "--ci-total-timeout") == 0 && Example_Number(argv[arg], UINT32_MAX, &value)) {
|
||
ci_total_timeout_ms = (uint32_t)value;
|
||
} else if (strcmp(option, "--clock") == 0 && strcmp(argv[arg], "simulated") == 0) {
|
||
clock_system = false;
|
||
} else if (strcmp(option, "--clock") == 0 && strcmp(argv[arg], "system") == 0) {
|
||
clock_system = true;
|
||
} else {
|
||
fprintf(stderr, "Invalid option/value: %s %s\n", option, argv[arg]);
|
||
return EXIT_FAILURE;
|
||
}
|
||
}
|
||
/* 按最终开关值检查;至少有一种可持久化服务,不能静默忽略配置路径。 */
|
||
if (config_path != NULL && !parameter && !remote_parameter && !file_service) {
|
||
fputs("--config requires parameters enabled or --remote-parameter or --file-service\n", stderr);
|
||
return EXIT_FAILURE;
|
||
}
|
||
if (software_upgrade && !file_service) {
|
||
fputs("--software-upgrade requires --file-service\n", stderr); return EXIT_FAILURE;
|
||
}
|
||
if (upgrade_seed != NULL && upgrade_directory == NULL) {
|
||
fputs("--upgrade-seed requires --upgrade-store\n", stderr); return EXIT_FAILURE;
|
||
}
|
||
if ((energy_directory != NULL && counter_type != IEC60870_ASDU_M_IT_NB_1) ||
|
||
(energy_period_set && energy_directory == NULL)) {
|
||
fputs("--energy-freeze requires --counter-type 206; --energy-period-ms requires --energy-freeze\n", stderr);
|
||
return EXIT_FAILURE;
|
||
}
|
||
/* 第2步:取得静态池句柄后绑定应用上下文,再初始化实际网络监听。 */
|
||
slave = IEC104_Slave_Create();
|
||
if (slave == NULL) { fputs("No free Slave service slot\n", stderr); return EXIT_FAILURE; }
|
||
/* 所有模块须在网络监听及首条Slave通知之前绑定;||按创建顺序短路,失败后不再建后续模块。
|
||
* 此时尚无事务或终结通知,统一释放已创建的非空句柄即可;NULL表示未创建或已在Init内回退。 */
|
||
if (!Example_Init(&app, slave, common_address, NULL, 0U, gi_total_timeout_ms) ||
|
||
!Example_Init_Startup(&app) ||
|
||
!Example_Init_Counters(&app, NULL, 0U, ci_total_timeout_ms) ||
|
||
!Example_Init_Clock(&app, NULL) ||
|
||
!(command_extensions ? Example_Init_Command_Mode(&app, true) : Example_Init_Command(&app)) ||
|
||
!Example_Init_SystemCommand(&app) ||
|
||
(parameter && !Example_Init_Parameter(&app)) ||
|
||
(remote_parameter && !Example_Init_RemoteParameter(&app)) ||
|
||
(file_service && !Example_Init_FileService(&app)) ||
|
||
(software_upgrade && !Example_Init_SoftwareUpgrade(&app)) ||
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
!Example_Init_PeriodicScan_Reserve(&app, cyclic_ms, background_ms, sequence,
|
||
config.protocol.link.k > 2U ? 2U : (uint16_t)(config.protocol.link.k - 1U)) ||
|
||
#else
|
||
!Example_Init_PeriodicScan(&app, cyclic_ms, background_ms, sequence) ||
|
||
#endif
|
||
!Example_Config_Open(&app, config_path)) {
|
||
(void)Example_Destroy(&app);
|
||
(void)IEC104_Slave_Destroy(slave, NULL);
|
||
return EXIT_FAILURE;
|
||
}
|
||
app.clock_system = clock_system;
|
||
app.counter_type = counter_type;
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
if (dtu_recording_directory != NULL && recording_directory != NULL) {
|
||
fputs("Choose --dtu-recording or --recording-demo\n", stderr);
|
||
(void)Example_Destroy(&app); (void)IEC104_Slave_Destroy(slave, NULL); return EXIT_FAILURE;
|
||
}
|
||
app.dtu_input_path = dtu_input_path;
|
||
app.dtu_recording_directory = dtu_recording_directory;
|
||
if (dtu_recording_directory != NULL) { app.recording = &recording; }
|
||
#endif
|
||
if (recording_directory != NULL) {
|
||
/* 监听前生成并保存一条模拟记录,时间取启动快照;此处没有真实ADC采集或4 kHz调度。
|
||
* saved只表示两个文件已写完,稍后Example_Publish_Recording入队TI42后才允许读取。 */
|
||
if (!Example_Recording_Demo(&recording, &app.files.startup_time, 1U, 1U) ||
|
||
!Example_Recording_Save(&recording, recording_directory)) {
|
||
fputs("Synthetic recording failed (directory, clock, or duplicate name); no files published.\n", stderr);
|
||
(void)Example_Destroy(&app);
|
||
(void)IEC104_Slave_Destroy(slave, NULL);
|
||
return EXIT_FAILURE;
|
||
}
|
||
app.recording = &recording;
|
||
printf("RECORDING SIMULATED %s %s DAT_BYTES=%lu\n", recording.paths[0], recording.paths[1],
|
||
(unsigned long)recording.dat_size);
|
||
}
|
||
/* Example_Init会清零app,故先在main解析局部配置,再于全部模块创建后写入采样状态。
|
||
* 采样从当前单调时刻计时,不依赖主站连接;离线变化沿用现有NORMAL缓存规则。 */
|
||
app.events_interval_ms = events_interval_ms;
|
||
app.events_field = events_field;
|
||
app.events_last_ms = IEC104_Net_Now_Ms();
|
||
Example_Refresh_System_Clock(&app, true);
|
||
/* 点表和时钟准备完成、网络监听之前恢复历史;失败时不接入主站,不将损坏存储降级成空记录。 */
|
||
if (history_directory != NULL && !Example_Init_History(&app, &history, history_directory)) {
|
||
fputs("History open failed (directory, storage integrity, point table, or wall clock).\n", stderr);
|
||
(void)Example_Destroy(&app);
|
||
(void)IEC104_Slave_Destroy(slave, NULL);
|
||
return EXIT_FAILURE;
|
||
}
|
||
if (energy_directory != NULL && !Example_Init_Energy(&app, &energy, &energy_meter,
|
||
energy_directory, energy_period_ms)) {
|
||
fputs("Energy freeze open failed (directory, storage integrity, meter data, or wall clock).\n", stderr);
|
||
(void)Example_Destroy(&app);
|
||
(void)IEC104_Slave_Destroy(slave, NULL);
|
||
return EXIT_FAILURE;
|
||
}
|
||
#ifdef IEC104_EXAMPLE_DTU_PROFILE
|
||
if (!Example_Dtu_Energy_Settings(&app, &app.dtu_settings, IEC104_Net_Now_Ms(), true)) {
|
||
fputs("DTU energy gain configuration rejected\n", stderr);
|
||
(void)Example_Destroy(&app); (void)IEC104_Slave_Destroy(slave, NULL); return EXIT_FAILURE;
|
||
}
|
||
#endif
|
||
/* 日志独立恢复后才开始监听,避免首次CONNECTED先于时基/存储就绪;失败仍释放已创建的其他模块。 */
|
||
if (user_log_directory != NULL && !Example_Init_User_Log(&app, &user_log, user_log_directory)) {
|
||
fputs("User log open failed (directory, storage integrity, or wall clock).\n", stderr);
|
||
(void)Example_Destroy(&app);
|
||
(void)IEC104_Slave_Destroy(slave, NULL);
|
||
return EXIT_FAILURE;
|
||
}
|
||
/* 监听前恢复升级介质,先保证安装/回退有明确结局;损坏库或缺种子不降级成RAM模拟。
|
||
* 日志已就绪,可记录真实恢复阶段;若后续监听失败,Destroy仅关闭后端,TRIAL留待下次回退。 */
|
||
if (upgrade_directory != NULL && !Example_Init_Upgrade_Store(&app, &upgrade_store, upgrade_directory, upgrade_seed)) {
|
||
fputs("Upgrade store open/boot failed (directory, seed, integrity, or pending recovery).\n", stderr);
|
||
(void)Example_Destroy(&app);
|
||
(void)IEC104_Slave_Destroy(slave, NULL);
|
||
return EXIT_FAILURE;
|
||
}
|
||
result = IEC104_Slave_Init(slave, &config, &error);
|
||
if (result != IEC104_TCP_OK) {
|
||
fprintf(stderr, "Init failed: result=%d stage=%d socket=%d\n", result, error.stage, error.socket_error);
|
||
/* Init失败仍须释放已创建的业务模块和Slave槽。 */
|
||
(void)Example_Destroy(&app);
|
||
(void)IEC104_Slave_Destroy(slave, NULL);
|
||
return EXIT_FAILURE;
|
||
}
|
||
/* 监听成功后取得系统实际绑定的端口,不能把配置中的0当作可连接端口输出。 */
|
||
if (IEC104_Slave_Get_Status(slave, &status, &error) != IEC104_TCP_OK) {
|
||
exit_code = EXIT_FAILURE;
|
||
goto cleanup;
|
||
}
|
||
/* --port=0首次由系统选端口;模拟重启保留这个实际端口,主站可按原端点重新连接。 */
|
||
config.port = status.bound_port;
|
||
if (!IEC104_SystemCommand_Set_Initialization(app.system_command, 0U)) { exit_code = EXIT_FAILURE; goto cleanup; }
|
||
/* 首次启动仍使用COI0;确认在输出LISTEN及进入网络循环之前完成,主站看不到未确认版本。 */
|
||
if (!Example_Upgrade_Confirm_Boot(&app)) { exit_code = EXIT_FAILURE; goto cleanup; }
|
||
/* 第3步:安装仅置标志的信号处理器;真正的资源关闭仍在主线程执行。 */
|
||
(void)signal(SIGINT, Example_Stop);
|
||
(void)signal(SIGTERM, Example_Stop);
|
||
started = GetTickCount64();
|
||
if (gi_total_timeout_ms == 0U) { fputs("WARNING: GI total timeout disabled (--gi-total-timeout 0).\n", stderr); }
|
||
if (ci_total_timeout_ms == 0U) { fputs("WARNING: CI total timeout disabled (--ci-total-timeout 0).\n", stderr); }
|
||
printf("TIMEOUTS GI_TOTAL_MS=%lu CI_TOTAL_MS=%lu\n",
|
||
(unsigned long)gi_total_timeout_ms, (unsigned long)ci_total_timeout_ms);
|
||
printf("PROFILE PARAMETER=%u SIMULATION=%s SAMPLE_MS=%lu CYCLIC_MS=%lu BACKGROUND_MS=%lu\n",
|
||
parameter ? 1U : 0U, events_field ? "field" : "stress", (unsigned long)events_interval_ms,
|
||
(unsigned long)cyclic_ms, (unsigned long)background_ms);
|
||
printf("LISTEN %s:%u CA=%u\n", config.bind_address, (unsigned)status.bound_port, (unsigned)common_address);
|
||
fflush(stdout); /* 让终端或通过管道启动本程序的测试立即取得实际监听端点。 */
|
||
while (!example_stop && (run_ms == 0U || GetTickCount64() - started < run_ms)) {
|
||
if (app.user_log_failed || app.upgrade_store_failed) { exit_code = EXIT_FAILURE; break; }
|
||
if (app.quiescing && app.restart_requested) {
|
||
uint32_t ready = 0U;
|
||
if (!Example_Restart_Protocol(&app, &config)) {
|
||
fputs("Protocol restart failed\n", stderr); exit_code = EXIT_FAILURE; break;
|
||
}
|
||
if (app.restart_requested) {
|
||
/* 空集合等待不接入客户端;提前唤醒后仍由单调时钟决定是否达到短延时。 */
|
||
IEC104_NetResult_t waited = IEC104_Net_Wait(IEC104_NET_INVALID_SOCKET,
|
||
IEC104_NET_INVALID_SOCKET, 0U, EXAMPLE_UPGRADE_DELAY_MS, &ready, NULL);
|
||
if (waited != IEC104_NET_OK && waited != IEC104_NET_RETRY) {
|
||
Example_Upgrade_Activation_Finished(&app, false);
|
||
exit_code = EXIT_FAILURE; break;
|
||
}
|
||
}
|
||
continue;
|
||
}
|
||
/* 有待续读通知或可立即提交的任务时安排0等待;WAIT则交回网络循环,等待上限50ms。
|
||
* Poll还会按库内本地工作和协议期限缩短等待;50ms只约束等待,不保证整轮执行耗时。 */
|
||
uint32_t wait_ms = Example_Wait_Time(&app, 50U);
|
||
result = IEC104_Slave_Poll(slave, wait_ms, &error);
|
||
if (result != IEC104_TCP_OK) {
|
||
/* 客户端普通断线由事件表达;这里收到的是服务接口失败,结束循环统一清理。 */
|
||
fprintf(stderr, "Poll failed: result=%d stage=%d socket=%d\n", result, error.stage, error.socket_error);
|
||
exit_code = EXIT_FAILURE;
|
||
break;
|
||
}
|
||
/* Poll之后先读空通知,再由Step开启新业务轮;未读完STOP/撤销时不能恢复新I帧选取或执行动作。
|
||
* Drain失败会短路,不继续对不可信状态提交应答;下一次单独Poll不能代替这次业务收集。 */
|
||
if (!Example_Drain(&app) || !Example_Step(&app)) {
|
||
fputs("Application event/build failure\n", stderr);
|
||
exit_code = EXIT_FAILURE;
|
||
break;
|
||
}
|
||
/* 即使本轮因通知未读空而暂缓业务,也给文件保存一次调度机会;网络最大等待50ms。
|
||
* 普通保存失败只进入诊断/退避,参数确认与连接继续运行;正常退出才强制检查最终结果。 */
|
||
(void)Example_Config_Flush(&app, false);
|
||
if (app.restart_requested && !Example_Restart_Protocol(&app, &config)) {
|
||
fputs("Protocol restart failed\n", stderr); exit_code = EXIT_FAILURE; break;
|
||
}
|
||
}
|
||
cleanup:
|
||
/* 退出结束内存任务;持久模式的AUTH/TRIAL继续留在磁盘,由下次启动安装或回退。 */
|
||
Example_Upgrade_Activation_Finished(&app, false);
|
||
/* 退出不再执行新参数动作,先尝试保存现有运行值;失败仍继续释放全部协议资源。
|
||
* Ctrl+C处理器仅置标志,这里才做I/O;强杀进程/断电没有此机会,最多恢复最后成功保存版。 */
|
||
if (!Example_Config_Flush(&app, true)) {
|
||
fputs("CONFIG unsaved parameters at exit\n", stderr); exit_code = EXIT_FAILURE;
|
||
}
|
||
/* 第4步:停止应用任务,再结束网络;取消只丢弃尚未提交完毕的任务,不重发已接手数据。 */
|
||
Example_Cancel(&app);
|
||
/* Cancel只将终结通知排队;释放业务实例前必须读完,并清理应用自己的遍历状态及资源。
|
||
* 遥控FINISHED在离线时仍可读;这里只释放已同步完成的模拟输出,真实设备须自行等实际结束。 */
|
||
if (!Example_Drain_Finished(&app)) {
|
||
exit_code = EXIT_FAILURE;
|
||
}
|
||
if (IEC104_Slave_Close(slave, &error) != IEC104_TCP_OK) { exit_code = EXIT_FAILURE; }
|
||
{
|
||
IEC104_SlaveEvent_t event;
|
||
IEC104_TcpEventResult_t next;
|
||
/* Close保留收尾通知。全部业务只消费非I帧状态,不再受理请求或执行动作。
|
||
* 即使Cancel已经终结事务,也须交付断线通知让模块清除会话;首次终结原因不会被改写。 */
|
||
while ((next = IEC104_Slave_NextEvent(slave, &event)) == IEC104_TCP_EVENT_READY) {
|
||
if (event.transport.type != IEC104_TCP_EVENT_I_FRAME && !Example_Handle_Event(&app, &event)) { exit_code = EXIT_FAILURE; }
|
||
}
|
||
if (next != IEC104_TCP_EVENT_EMPTY) { exit_code = EXIT_FAILURE; }
|
||
}
|
||
if (!IEC104_ClockSynchronization_Get_Status(app.clock, &app.cs)) { exit_code = EXIT_FAILURE; }
|
||
/* Close期间新产生的终结仍需读完;刷新统计后才能Destroy,不能用Destroy代替FINISHED清理。 */
|
||
if (!Example_Drain_Finished(&app) || !IEC104_Command_Get_Status(app.command, &app.command_status)) {
|
||
exit_code = EXIT_FAILURE;
|
||
}
|
||
/* 只有关闭且FIFO读空后才能归还槽;清理失败也必须体现在程序退出码中。
|
||
* Command还要求事务/独立应答全部清空;应用站点引用已在FINISHED分支释放,再Remove_Station。 */
|
||
if (!IEC104_Spontaneous_Get_Status(app.spontaneous, &event_status)) { exit_code = EXIT_FAILURE; }
|
||
if (app.parameter != NULL && !IEC104_Parameter_Get_Status(app.parameter, &app.parameter_status)) { exit_code = EXIT_FAILURE; }
|
||
/* 此时连接已关闭且生命周期读空;最终DISCARD仍使用原app环境,不能提前销毁暂存。 */
|
||
if (!Example_Drain_RemoteParameter(&app)) { exit_code = EXIT_FAILURE; }
|
||
if (app.user_log_failed || app.upgrade_store_failed) { exit_code = EXIT_FAILURE; }
|
||
if (!Example_Destroy(&app)) { exit_code = EXIT_FAILURE; }
|
||
if (IEC104_Slave_Destroy(slave, &error) != IEC104_TCP_OK) { exit_code = EXIT_FAILURE; }
|
||
/* 打印应用提交统计;这些值不用于推断未确认帧是否已到达主站,也不作为自动重试依据。 */
|
||
printf("STOP submitted=%lu gi_submitted=%lu waits=%lu rejected=%lu cancelled=%lu overloads=%lu deactivated=%lu timeouts=%lu negative_submitted=%lu dropped_requests=%lu counter_submitted=%lu counter_completed=%lu clock_executed=%lu clock_synchronized=%lu clock_submitted=%lu command_selected=%lu command_executed=%lu command_completed=%lu command_submitted=%lu command_returns=%lu command_time_expired=%lu command_time_rejected=%lu\n",
|
||
app.gi.submitted + app.other_submitted, app.gi.gi_submitted, app.gi.waits,
|
||
app.gi.rejected + app.other_rejected, app.gi.cancelled + app.other_cancelled,
|
||
app.gi.overloads + app.other_overloads, app.gi.deactivated, app.gi.timeouts,
|
||
app.gi.negative_submitted, app.gi.dropped_requests + app.other_overloads,
|
||
app.ci.submitted, app.counter_completed, app.cs.executed, app.cs.synchronized, app.cs.submitted,
|
||
app.command_status.selected, app.command_status.executed, app.command_status.completed,
|
||
app.command_status.submitted, app.command_status.return_info_submitted,
|
||
app.command_status.time_expired, app.command_status.time_rejected);
|
||
printf("CLOCK_READ executed=%lu succeeded=%lu\n", app.cs.read_executed, app.cs.read_succeeded);
|
||
printf("EVENTS event_published=%lu event_asdus=%lu event_objects=%lu event_time_invalid=%lu event_overflow=%u event_dropped_pending=%lu event_overwritten_submitted=%lu event_accounting_errors=%lu event_queue_dropped=%lu event_queue_invalid=%lu event_queue_pending=%lu\n",
|
||
event_status.published, event_status.asdus, event_status.objects, event_status.time_invalid,
|
||
(unsigned)event_status.overflow, event_status.dropped_pending_asdus,
|
||
event_status.overwritten_submitted_asdus, event_status.accounting_errors,
|
||
app.publication_dropped, app.publication_invalid, (unsigned long)app.publication_count);
|
||
printf("SYSTEM_COMMAND restarts=%lu partial_failures=%lu events_cleared=%lu events_discarded=%lu\n",
|
||
app.protocol_restarts, app.system_command_faults,
|
||
app.system_command_status.events_cleared_requests, app.system_command_status.events_discarded);
|
||
if (parameter) {
|
||
printf("PARAMETER accepted=%lu executed=%lu applied=%lu unknown_ioa=%lu submitted=%lu negative_submitted=%lu rejected=%lu waits=%lu cancelled=%lu dropped_requests=%lu timeouts=%lu\n",
|
||
app.parameter_status.accepted, app.parameter_status.executed, app.parameter_status.applied,
|
||
app.parameter_status.unknown_ioa, app.parameter_status.submitted, app.parameter_status.negative_submitted,
|
||
app.parameter_status.rejected, app.parameter_status.waits, app.parameter_status.cancelled,
|
||
app.parameter_status.dropped_requests, app.parameter_status.timeouts);
|
||
}
|
||
if (remote_parameter) {
|
||
Example_Remote_Report_Settings(&app, "exit", app.remote_area);
|
||
/* accepted是合法受理数,submitted是发送层接手数;只有solidified统计真实固化成功。 */
|
||
printf("REMOTE_PARAMETER accepted=%lu executed=%lu applied=%lu solidified=%lu submitted=%lu negative_submitted=%lu rejected=%lu waits=%lu cancelled=%lu dropped_requests=%lu timeouts=%lu reads_completed=%lu reads_aborted=%lu discards=%lu recovery_required=%u faulted=%u\n",
|
||
app.remote_status.accepted, app.remote_status.executed, app.remote_status.applied,
|
||
app.remote_status.solidified, app.remote_status.submitted, app.remote_status.negative_submitted,
|
||
app.remote_status.rejected, app.remote_status.waits, app.remote_status.cancelled,
|
||
app.remote_status.dropped_requests, app.remote_status.timeouts, app.remote_status.reads_completed,
|
||
app.remote_status.reads_aborted, app.remote_status.discards,
|
||
app.remote_status.recovery_required ? 1U : 0U, app.remote_status.faulted ? 1U : 0U);
|
||
}
|
||
if (file_service) {
|
||
/* submitted仅表示交给发送层;writes_committed才统计真实COMMIT成功,仍不是主站已收到。 */
|
||
printf("FILE_SERVICE accepted=%lu directories=%lu directory_frames=%lu reads_opened=%lu reads_completed=%lu reads_aborted=%lu writes_opened=%lu segments_written=%lu writes_committed=%lu writes_failed=%lu busy_returns=%lu stray_segments=%lu submitted=%lu negative_submitted=%lu waits=%lu idle_waits=%lu finishes=%lu timeouts=%lu reply_timeouts=%lu faulted=%u\n",
|
||
app.file_status.accepted, app.file_status.directories, app.file_status.directory_frames,
|
||
app.file_status.reads_opened, app.file_status.reads_completed, app.file_status.reads_aborted,
|
||
app.file_status.writes_opened, app.file_status.segments_written, app.file_status.writes_committed,
|
||
app.file_status.writes_failed, app.file_status.busy_returns, app.file_status.stray_segments,
|
||
app.file_status.submitted, app.file_status.negative_submitted, app.file_status.waits,
|
||
app.file_status.idle_waits, app.file_status.finishes, app.file_status.timeouts,
|
||
app.file_status.reply_timeouts, app.file_status.faulted ? 1U : 0U);
|
||
}
|
||
if (software_upgrade) {
|
||
printf("SOFTWARE_UPGRADE accepted=%lu starts=%lu ends_accepted=%lu ends_rejected=%lu cancels=%lu abandons=%lu restarts_released=%lu submitted=%lu negative_submitted=%lu ack_timeouts=%lu acks_lost=%lu ack_errors=%lu reply_timeouts=%lu faulted=%u activated=%lu activation_failed=%lu version=%lu crc=%lu\n",
|
||
app.upgrade_status.accepted, app.upgrade_status.starts, app.upgrade_status.ends_accepted,
|
||
app.upgrade_status.ends_rejected, app.upgrade_status.cancels, app.upgrade_status.abandons,
|
||
app.upgrade_status.restarts_released, app.upgrade_status.submitted, app.upgrade_status.negative_submitted,
|
||
app.upgrade_status.ack_timeouts, app.upgrade_status.acks_lost, app.upgrade_status.ack_errors,
|
||
app.upgrade_status.reply_timeouts, app.upgrade_status.faulted ? 1U : 0U,
|
||
example_upgrade_device.succeeded, example_upgrade_device.failed,
|
||
(unsigned long)example_image.version, (unsigned long)example_image.crc);
|
||
}
|
||
return exit_code;
|
||
}
|
||
#endif
|