Files
STM32F4-Base/IEC60870-Slave/examples/iec104_slave_example.c
T
STF bdcc8b6500
CI / L0 静态门禁 (pre-commit) (push) Failing after 7m46s
CI / L0.5 主机侧单测 (MSVC) (push) Successful in 21s
添加遥控、参数装载、文件传输等业务
2026-11-16 22:19:17 -08:00

7085 lines
440 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/*
* 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, &current)) {
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, &current)) { 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