/* * 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 #include #include #include #include #ifdef IEC104_EXAMPLE_DTU_PROFILE #include "iec104_dtu_profile.h" #include "iec104_dtu_measurement.h" #include "iec104_dtu_protection.h" #include #endif #ifndef EXAMPLE_EVENT_BUDGET #define EXAMPLE_EVENT_BUDGET 32U #endif #ifndef EXAMPLE_USER_LOG_REPORT_FAULT #define EXAMPLE_USER_LOG_REPORT_FAULT(result) fprintf(stderr, "ULOG persistence failed: %d\n", (int)(result)) #endif #define EXAMPLE_READ_BUDGET 4U #define EXAMPLE_COUNTER_COUNT 8U #define EXAMPLE_SCALED_MIN (-10000) #define EXAMPLE_SCALED_MAX 10000 /* Type5的VTI位置占有符号7位,另一位是暂态标志;本例按此范围拒绝越限升降。 * 两组各8个独立模拟点,点数同时约束命令地址映射与运行值数组。 */ #define EXAMPLE_STEP_MIN (-64) #define EXAMPLE_STEP_MAX 63 #define EXAMPLE_STEP_COUNT 8U #define EXAMPLE_BITSTRING_COUNT 8U /* 主示例的演示工况默认值,不是协议库默认或现场整定值。 * 655是Type110线上有符号整数,比例为655/32768;乘固定幅值10000约为199.89, * 因测量值是整数,归一化与标度门限都在变化量达到200时触发。 * SAMPLE控制输入采样,BACKGROUND控制COT2刷新,两者都不是COT3固定发送周期。 */ #define EXAMPLE_THRESHOLD_SCALED 200 #define EXAMPLE_THRESHOLD_NORMALIZED 655 #define EXAMPLE_SAMPLE_MS 100U #define EXAMPLE_BACKGROUND_MS 30000U #define EXAMPLE_CONFIG_SAVE_MS 500U #define EXAMPLE_CONFIG_RETRY_MS 5000U #define EXAMPLE_CLOCK_REFRESH_MS 60000U #define EXAMPLE_PUBLICATION_CAPACITY 32U #define EXAMPLE_GI_TOTAL_TIMEOUT_MS 120000U #define EXAMPLE_CI_TOTAL_TIMEOUT_MS 120000U #define EXAMPLE_FILE_BYTES 4096U #define EXAMPLE_UPGRADE_BYTES 65536U #define EXAMPLE_UPGRADE_DELAY_MS 20U #define EXAMPLE_FILE_DIRECTORY_ITEMS 2U #ifndef EXAMPLE_COMMAND_ACTION_RESULT #define EXAMPLE_COMMAND_ACTION_RESULT(app) IEC104_COMMAND_ACTION_STARTED #endif #ifndef EXAMPLE_COMMAND_DEVICE_RESULT #define EXAMPLE_COMMAND_DEVICE_RESULT(app) IEC104_COMMAND_RESULT_SUCCEEDED #endif #ifndef EXAMPLE_SYSTEM_COMMAND_REPORT_FAULT /* 测试可把这条预期诊断换成计数;生产仍写stderr,业务是否继续由Step的返回值决定。 */ #define EXAMPLE_SYSTEM_COMMAND_REPORT_FAULT(app) \ ((void)fputs("System command: application events cleared, transport clear failed; negative reply pending.\n", stderr)) #endif /* ============================================================================ * [COMMON/POINTS] 公共点表:总召、读命令、遥控和突发共用的地址与初值 * ============================================================================ */ /* 模拟遥信点表:ioa为24位信息对象地址,value为0/1,quality为SIQ品质位(这里均为0)。 * 表项只保存数据源:总召编码为Type1,变位、读回复和遥控反馈编码为带CP56的Type30。 * 此表提供地址、初值和品质;运行值保存在各ExampleApp中,遥控与总召共用同一数据源。 */ #ifdef IEC104_EXAMPLE_DTU_PROFILE #define example_signals dtu_signals #define example_measurements dtu_measurements #define EXAMPLE_DOUBLE_COUNT 16U #define EXAMPLE_COMMAND_COUNT (DTU_COMMAND_COUNT + EXAMPLE_MEASUREMENT_COUNT + EXAMPLE_STEP_COUNT + EXAMPLE_BITSTRING_COUNT) #define EXAMPLE_MEASUREMENT_TYPE IEC60870_ASDU_M_ME_NC_1 typedef IEC60870_MeasuredValueShort_t ExampleMeasurementObject; #else #define EXAMPLE_DOUBLE_COUNT EXAMPLE_SIGNAL_COUNT #define EXAMPLE_COMMAND_COUNT (2U * EXAMPLE_SIGNAL_COUNT + EXAMPLE_MEASUREMENT_COUNT + EXAMPLE_STEP_COUNT + EXAMPLE_BITSTRING_COUNT) #define EXAMPLE_MEASUREMENT_TYPE IEC60870_ASDU_M_ME_NB_1 typedef IEC60870_MeasuredValueScaled_t ExampleMeasurementObject; static const struct { uint32_t ioa; uint8_t value, quality; } example_signals[] = { {EXAMPLE_IOA_SINGLE_BASE, 0, 0}, {EXAMPLE_IOA_SINGLE_BASE + 1U, 1, 0}, {EXAMPLE_IOA_SINGLE_BASE + 2U, 0, 0}, {EXAMPLE_IOA_SINGLE_BASE + 3U, 1, 0}, {EXAMPLE_IOA_SINGLE_BASE + 4U, 1, 0}, {EXAMPLE_IOA_SINGLE_BASE + 5U, 0, 0}, {EXAMPLE_IOA_SINGLE_BASE + 6U, 1, 0}, {EXAMPLE_IOA_SINGLE_BASE + 7U, 0, 0} }; /* 模拟遥测点表:ioa为信息对象地址,value为原始有符号16位标度值,quality为QDS品质位。 * 编码为不带时标的Type=11;本示例不定义物理单位和倍率,负数也按有符号值传输。 */ static const struct { uint32_t ioa; int16_t value; uint8_t quality; } example_measurements[] = { {EXAMPLE_IOA_MEASUREMENT_BASE, 2300, 0}, {EXAMPLE_IOA_MEASUREMENT_BASE + 1U, 2310, 0}, {EXAMPLE_IOA_MEASUREMENT_BASE + 2U, 2290, 0}, {EXAMPLE_IOA_MEASUREMENT_BASE + 3U, 5000, 0}, {EXAMPLE_IOA_MEASUREMENT_BASE + 4U, -125, 0}, {EXAMPLE_IOA_MEASUREMENT_BASE + 5U, 0, 0}, {EXAMPLE_IOA_MEASUREMENT_BASE + 6U, 1234, 0}, {EXAMPLE_IOA_MEASUREMENT_BASE + 7U, 42, 0} }; #endif /* 点数直接取数组长度;分批游标使用size_t,不另维护可能与点表不一致的手写数量。 */ #define EXAMPLE_SIGNAL_COUNT (sizeof(example_signals) / sizeof(example_signals[0])) #define EXAMPLE_MEASUREMENT_COUNT (sizeof(example_measurements) / sizeof(example_measurements[0])) #define EXAMPLE_SCAN_POINT_COUNT EXAMPLE_MEASUREMENT_COUNT #define EXAMPLE_PARAMETER_COUNT (4U * EXAMPLE_MEASUREMENT_COUNT) /* 应用运行值的地址映射;命令许可和执行方式在Example_Init_Command中逐点明确配置。 * first_ioa是命令地址,ioa-first_ioa是该类运行值下标,不能把命令地址当作监视点地址。 * 基础与带时标类型共用同一物理点;此表仅用于查找运行值,不生成命令点策略。 * 扩展点表时须同步这里的类型/范围、对应运行值及动作/返回/读取分支。 */ static const struct { uint32_t first_ioa; size_t count; uint16_t type_mask; } example_command_groups[] = { #ifndef IEC104_EXAMPLE_DTU_PROFILE {EXAMPLE_IOA_COMMAND_SINGLE_BASE, EXAMPLE_SIGNAL_COUNT, IEC104_COMMAND_TYPE_BIT(45U) | IEC104_COMMAND_TYPE_BIT(58U)}, #endif {EXAMPLE_IOA_COMMAND_DOUBLE_BASE, EXAMPLE_DOUBLE_COUNT, IEC104_COMMAND_TYPE_BIT(46U) | IEC104_COMMAND_TYPE_BIT(59U)}, {EXAMPLE_IOA_COMMAND_STEP_BASE, EXAMPLE_STEP_COUNT, IEC104_COMMAND_TYPE_BIT(47U) | IEC104_COMMAND_TYPE_BIT(60U)}, {EXAMPLE_IOA_COMMAND_SETPOINT_BASE, EXAMPLE_MEASUREMENT_COUNT, IEC104_COMMAND_TYPE_BIT(49U) | IEC104_COMMAND_TYPE_BIT(62U)}, {EXAMPLE_IOA_COMMAND_BITSTRING_BASE, EXAMPLE_BITSTRING_COUNT, IEC104_COMMAND_TYPE_BIT(51U) | IEC104_COMMAND_TYPE_BIT(64U)} }; /* ============================================================================ * [COMMON/STATE] 公共上下文:业务句柄、专属状态及共享运行值 * ============================================================================ */ /* 当前取数站的应用游标;首个NEED_DATA才初始化,协议库不登记或冻结业务IOA列表。 * parameter_index独立于遥测游标,只有站总召且已启用参数时从0开始,其余置末尾跳过。 */ typedef struct { size_t single_index, double_index, scaled_index, parameter_index; } ExampleGiData; /* 应用测量链:原始输入、滤波状态和已提交变化基准分开保存;协议模块不解释这些参数。 */ typedef struct { double filtered; uint64_t updated_ms; int16_t raw, submitted_value; uint8_t quality, submitted_quality; int8_t range, submitted_range; /* -1低于下限,0在范围内,1高于上限。 */ } ExampleMeasurement; /* 补报标记保留应用队列次序直到命令结束;CP56 SOE原文已进入独立发送缓存,标记不再持有补报义务。 * 其他类型仍用此快照生成补报;动作未改变点值时只保留配对标记,不创建虚构SOE。 */ typedef struct { IEC104_SpontaneousChange_t change; uint64_t instance_id, transaction_id; bool placeholder, has_change, accepted; /* accepted仅表示返回信息已被发送层接手;FINISHED才决定补报。 */ bool time_tag_cleared; /* QRP=2清除后,占位解析也不得重新生成CP56形态。 */ int8_t measurement_range; /* 与快照同时固定,参数后来变化不能改写已排队的范围侧。 */ } ExamplePublication; /* 远程参数的应用候选值;*_set 区分“本批未写”与合法零值。 * 点表在整次读取期间保持不变,与标准Parameter的测量参数表不共用地址或运行值。 * 固化在本事件循环同步发布;指定--config时须先成功保存完整配置快照。 */ typedef struct { float deadband, x_time; uint16_t reset_seconds; bool deadband_set, x_time_set, reset_set; } ExampleRemoteValues; /* 当前选用配置的值快照;按区号现取,避免另存一份活动配置后切区/固化遗漏同步。 * 供示例配置展示使用,不连接保护算法或故障指示灯硬件;X时间演示单位为秒。 */ typedef struct { uint16_t area, reset_seconds; float deadband, x_time; } ExampleRemoteSettings; typedef struct { bool active; /* 表示本应用确有暂存;协议COLLECTING/COMPLETE由模块独立管理。 */ IEC104_RemoteParameterRequest_t owner; /* 首帧身份纯值副本;元素借用字段保存时清空。 */ ExampleRemoteValues values; /* 每帧完整校验后才替换,固化成功后统一清空。 */ } ExampleRemoteStage; /* 文件句柄只在本应用内解释;每次成功OPEN分配递增token,旧清理不能误碰新资源。 * owner按值保存来源,name等回调借用指针清零;TEMP区与协议模块的固定数据段环互相独立。 */ typedef struct { bool active; IEC104_FileServiceRequest_t owner; } ExampleFileResource; typedef struct { uint8_t name[IEC104_FILE_SERVICE_MAX_DIRECTORY_NAME]; uint8_t name_length; uint32_t size; IEC60870_CP56Time2a_t time; } ExampleFileDirectoryEntry; typedef struct { ExampleFileResource directory, read, stage; /* 三种资源独立计寿命,不能因协议队列为空就释放。 */ uintptr_t next_handle; /* 协议复位时保留,旧handle永远不能匹配下一次OPEN。 */ ExampleFileDirectoryEntry entries[EXAMPLE_FILE_DIRECTORY_ITEMS]; /* 本次目录打开时复制的稳定清单。 */ size_t entry_count; bool directory_exists, read_temp, present; /* 目录存在性 / 已提交区读锁 / 已有提交文件,三者不互相替代。 */ const uint8_t *read_data; /* ROM或被读锁保护的file_bytes,不指向回调栈。 */ unsigned read_recording; /* 当前读会话的数据源:0=普通文件,1=录波CFG,2=录波DAT;CLOSE_READ清零。 */ bool directory_history, read_history; /* 历史文件快照由独立适配器持有,不借用演示目录的两项数组。 */ ExampleHistoryEntry history_entry; /* list回调返回后协议仍需编码名称,因此不能使用局部数组。 */ bool directory_energy, read_energy; /* FRZ/FLOWREV由独立适配器保存不可变下载副本。 */ ExampleEnergyFreezeEntry energy_entry; bool directory_user_log, read_user_log; /* 日志目录与下载各自持有冻结副本,按原资源身份关闭。 */ ExampleUserLogEntry user_log_entry; /* list返回后名称仍有效,不借用回调栈。 */ uint32_t read_size, stage_size, stage_received, file_size; uint8_t stage_name[IEC104_FILE_SERVICE_MAX_FILE_NAME]; uint8_t file_name[IEC104_FILE_SERVICE_MAX_FILE_NAME]; uint8_t stage_name_length, file_name_length; IEC60870_CP56Time2a_t startup_time, file_time; uint8_t stage_bytes[EXAMPLE_FILE_BYTES]; /* write只写此区;ABORT使其无效,不要求擦除旧字节。 */ uint8_t file_bytes[EXAMPLE_FILE_BYTES]; /* COMMIT发布区;读锁持有期间禁止替换。 */ } ExampleFileStore; /* 应用映像记录只在进程启动初始化;普通105和协议重建不能将其恢复为初值。 */ typedef struct { uint32_t version, crc; } ExampleImage; static ExampleImage example_image = {1U, 0xCBF43926U}; /* VERIFYING预留给有界验证接入;RAM模式累计CRC,持久模式由后端同步读回,COMMIT发布验证结局。 */ typedef enum { EXAMPLE_UPGRADE_EMPTY = 0, EXAMPLE_UPGRADE_RECEIVING, EXAMPLE_UPGRADE_VERIFYING, EXAMPLE_UPGRADE_VERIFIED, EXAMPLE_UPGRADE_INVALID, EXAMPLE_UPGRADE_FROZEN } ExampleUpgradeState; /* 一个示例设备由所有Slave共享;设备owner及候选归属独立于ExampleApp和协议实例。 * 取消仅使候选失效,FileService尚欠最终回调时保留handle和存储,避免迟到写误碰新文件。 * 示例CRC同步完成,无后台线程;生产验证必须另持引用和token后再异步回交结果。 */ typedef struct { void *context; /* 取得owner的ExampleApp;文件和激活任务收尾前其身份必须保持稳定。 */ /* owned跨协议会话存在;invalidated先撤销资格,committed/verified仅描述当前transfer。 * reserved在END接受时固定任务;taken表示授权已领取,候选改由应用激活任务持有。 */ bool owned, invalidated, committed, verified, reserved, taken; bool persistent_handoff; /* Take之后即锁定:授权落盘失败也可能已提交,退出只释放内存归属。 */ /* 前两项全进程单调递增,后两项在OPEN时捕获;不能只靠可重建的协议会话序号匹配。 */ uint64_t owner_token, transfer_token, file_owner_token, file_transfer_token; IEC104_SoftwareUpgradeRequest_t owner; /* START身份值副本,后续END/撤销须匹配原站点及会话。 */ ExampleFileResource file; /* 升级写handle;取消后仍保留到COMMIT/ABORT最终回调。 */ ExampleUpgradeState state; /* size/received包含包头,rolling_crc仅累计负载且尚未最终异或;后两项在COMMIT校验后发布。 */ uint32_t size, received, rolling_crc, target_version, payload_crc; /* END预留的不可变描述,不在Take成功后才分配;taken_ms仅在实际领取时采样。 */ struct { uint64_t owner_token, transfer_token, taken_ms; uint32_t version, crc, size; } activation; unsigned long succeeded, failed; /* 应用激活结局,区别于211确认或ACK已经成功。 */ uint8_t bytes[EXAMPLE_UPGRADE_BYTES]; /* 仅RAM模拟使用;持久模式逐段写盘,不向此区复制。 */ } ExampleUpgradeDevice; static ExampleUpgradeDevice example_upgrade_device; typedef struct { /* [STATE/COMMON] 共享服务和站点身份;所有业务借用 */ IEC104_Slave_t *slave; /* main拥有;本上下文仅借用。 */ IEC104_Station_t station; /* 应用拥有的固定地址站点节点,供各业务共用CA和context。 */ /* [STATE/GI] 总召实例与调度快照 */ IEC104_Interrogation_t *interrogation; /* 库内不透明总召任务对象。 */ IEC104_InterrogationStatus_t gi; /* 只读快照,用于调度等待及统计。 */ /* [STATE/CI] 计数量实例与调度快照 */ IEC104_Interrogation_t *counter; /* 独立计数量实例,与总召共用Slave,不共用任务和广播状态区。 */ IEC104_InterrogationStatus_t ci; /* 计数量调度及统计快照,每次推进后重新查询。 */ /* [STATE/CLOCK] 校时实例与调度快照 */ IEC104_ClockSynchronization_t *clock; /* Type103读/设时共用一个模块,复用Slave及站点表。 */ IEC104_ClockSynchronizationStatus_t cs; /* 读/设时待执行、回复及期限快照;两种回调分别累计次数。 */ /* [STATE/COMMAND_HANDLE] 遥控实例;事务状态见下方COMMAND字段 */ IEC104_Command_t *command; /* CLI启用;仅总召的旧测试可以不创建遥控实例。 */ /* [STATE/READ] 读命令实例与调度快照 */ IEC104_Read_t *read; /* 队首单点读取,共用总召/遥控运行值。 */ IEC104_ReadStatus_t rd; /* [STATE/PERIODIC_SCAN] 可选空闲扫描;模块借用这24行点表至Destroy,不能用初始化函数的栈数组代替。 * 点表只描述地址、类型和归属,创建后不改;实际值仍从下方运行值数组现取。 */ IEC104_PeriodicScan_t *periodic_scan; IEC104_PeriodicScanPoint_t scan_points[EXAMPLE_SCAN_POINT_COUNT]; uint32_t point_period_ms[EXAMPLE_SCAN_POINT_COUNT]; /* 参数启停所需的点级周期;Create后只经扫描setter写。 */ uint8_t point_retry_pending[(EXAMPLE_SCAN_POINT_COUNT + 7U) / 8U]; /* 借给扫描模块独占的重试位图,应用不读写。 */ uint32_t parameter_cyclic_ms; /* 恢复周期;借出的周期数组只经扫描setter修改。 */ /* [STATE/PARAMETER] 点表创建后只读;当前值仅由本事件循环写入,模块和总召只读。 */ IEC104_Parameter_t *parameter; /* main默认创建,只启用标准功能;可显式关闭,运行中不换点表。 */ IEC104_ParameterStatus_t parameter_status; /* 调度与统计快照;排队与当前可执行分别看pending/ready。 */ IEC104_ParameterPoint_t parameter_points[EXAMPLE_PARAMETER_COUNT]; /* 4类各EXAMPLE_MEASUREMENT_COUNT行,按独立IOA升序。 */ IEC104_ParameterValue_t parameter_values[EXAMPLE_PARAMETER_COUNT]; /* 与点表等长;确认/总召共读,写入串行。 */ /* [STATE/REMOTE_PARAMETER] 200–203独立运行值;--config启用时纳入统一配置文件。 */ IEC104_RemoteParameter_t *remote_parameter; /* 通用入口由--remote-parameter开启,DTU入口默认开启。 */ IEC104_RemoteParameterStatus_t remote_status; /* 调度及退出诊断快照,不是暂存或确认送达凭证。 */ uint16_t remote_area, remote_reset_seconds[5]; /* 当前选择与五套已固化值;202按SN读取,不隐式切区。 */ float remote_deadband, remote_x_time[5]; /* 电流死区不分区,X时间定值按SN分区。 */ ExampleRemoteStage remote_stage; /* 每实例唯一暂存;归属有效期间app地址与含义保持不变。 */ #ifdef IEC104_EXAMPLE_DTU_PROFILE DtuSettings dtu_settings; /* 五区已固化值;当前动作区与SN0公共参数由定值适配选择。 */ DtuSettingsStage dtu_stage; /* 唯一预置影子,不作为读参数、采样判据或其他业务保存的来源。 */ DtuSettings *dtu_config_candidate; /* 仅同步保存期间借用提交候选,返回后立即清空;不转移所有权。 */ #endif /* [STATE/FILE_SERVICE] 仅--file-service创建协议对象;静态应用区可经--config保存为文件快照。 */ IEC104_FileService_t *file_service; IEC104_FileServiceStatus_t file_status; ExampleFileStore files; /* TEMP已提交区在STOP/105复位后保留,暂存由COMMIT/ABORT释放。 */ ExampleRecording *recording; /* 可选的主机模拟录波;借用调用者的冻结存储,须存活至文件读会话全部结束。 */ ExampleHistory *history; /* 可选持久历史;协议重建不清空,进程退出且文件会话结束后关闭。 */ ExampleEnergyFreeze *energy; /* energy.store与计量状态在QRP1协议重建时保留。 */ ExampleEnergyMeter *energy_meter; bool energy_failed; bool history_failed; /* 已接收事件保存失败时停止示例,不能静默丢失后继续宣称保存成功。 */ uint64_t history_utc_ms, history_base_ms; /* 启动时独立读取有效墙钟;不把协议未同步状态变成已校时。 */ ExampleUserLog *user_log; /* 独立 ulog.store;协议重建保留,文件会话收尾后关闭。 */ uint64_t user_log_utc_ms, user_log_base_ms; /* 有效墙钟与单调基准;成功校时才替换。 */ bool user_log_failed, user_log_connected, user_log_fault; /* 写失败锁存;后两项按本Slave通信通道去重。 */ /* [STATE/SOFTWARE_UPGRADE] 协议实例按Slave独立,候选及设备owner使用上方共享存储。 */ IEC104_SoftwareUpgrade_t *software_upgrade; IEC104_SoftwareUpgradeStatus_t upgrade_status; /* 只读调度快照,不能用session_active代替owner检查。 */ ExampleUpgrade *upgrade_store; /* 显式持久模式借用;整个进程持有目录锁,不借用RAM候选区。 */ bool upgrade_store_failed; /* 存储故障锁存后退出;已经授权的任务留给下次启动恢复。 */ bool quiescing, restart_quiesced; /* 领取后停普通业务;收尾完成后可有界等待激活延时。 */ /* [STATE/CONFIG] 唯一配置路径借用main的argv至退出;标准参数、远程定值和TEMP共用整份快照,NULL保持纯内存行为。 * dirty只针对32项参数,QPA3启停、测量值和发送状态不入文件;协议复位保留待保存配置。 */ const char *config_path; bool config_dirty, config_failed; uint64_t config_wait_started_ms; /* 首次修改或最近失败的时刻;后续修改不无限推迟保存。 */ uint32_t config_wait_ms; /* 正常合并500ms,失败退避5000ms;与协议确认期限互不替代。 */ /* [STATE/SYSTEM_COMMAND] 系统命令及协议实例复位;ACK后只置请求,主循环外统一收尾。 */ IEC104_SystemCommand_t *system_command; /* 104/105/107请求及70轮次的库内对象,不执行宿主复位。 */ IEC104_SystemCommandStatus_t system_command_status; /* 每次Step/等待前刷新,不能沿用查询失败的旧快照。 */ /* [STATE/STARTUP] 初始化 -> 全部CA真实总召 -> NORMAL/IDLE放行。 * identity区分Slave实例及TCP代次,activation还区分同TCP内STOP/START;两者须来自原ACTIVATED。 * enabled为接入配置,locked为集合借用,initialized/open是当前轮阶段;Reset只保留enabled。 * 逐站完成票据保存在Slave站点元数据,不复制事件缓存;NORMAL原文仍由发送层持有。 */ IEC104_Startup_t startup; /* 统一启动协调;复用原轮次状态,不另存遥信或站点数组。 */ bool restart_requested; /* Take_Reset或Take_Restart已交出授权;离开正常Step后才执行收尾。 */ unsigned long system_command_faults, protocol_restarts; /* 应用侧部分失败数/成功重建协议实例次数。 */ /* [STATE/SPONTANEOUS] 突发模块及应用发布队列 */ IEC104_Spontaneous_t *spontaneous; ExamplePublication publications[EXAMPLE_PUBLICATION_CAPACITY]; size_t publication_count; unsigned long publication_dropped, publication_invalid; bool publication_waiting; uint8_t publication_forms[IEC104_SPONTANEOUS_KIND_COUNT]; /* 与Create时按值复制的形态配置一致。 */ /* [STATE/COMMAND_PUBLICATION] 遥控与突发交界:动作产生的变化与补报状态 */ IEC104_SpontaneousChange_t command_change; bool command_action_called, command_has_change; /* 单个遥控SOE的发送层身份;应用数组中的旧占位仅负责阻挡较晚普通发布。 * serial为0表示动作没有实际变化;覆盖或QRP2清除后仍保留身份直到FINISHED,禁止重建旧事件。 */ IEC104_SoeTicket_t command_soe_ticket; uint64_t command_soe_instance, command_soe_transaction; bool command_soe_active; /* [STATE/SAMPLING] 模拟源与发送策略独立;只由同一应用循环推进,无独立采样任务。 */ uint32_t events_interval_ms; /* 0停模拟;非零为两次采样之间的名义毫秒数。 */ uint64_t events_last_ms; /* 实际采样的单调时刻;延迟后不逐个补跑错过的节拍。 */ size_t events_index; /* field:0..119波形相位;stress:0..7点号,遥信/遥测各采一次才递增。 */ bool events_measurement, events_field; /* 前者仅供stress选择遥测拍;后者选择模拟模式,QRP1也保留。 */ /* [STATE/COMMAND] 遥控点表、工作事件、原站引用及返回信息 */ IEC104_CommandPoint_t command_points[EXAMPLE_COMMAND_COUNT]; /* Create前填完,直到Destroy均只读且地址稳定。 */ IEC104_CommandStatus_t command_status; /* 推进后/等待前刷新;计时、通知和应答状态只供调度及统计。 */ IEC104_CommandEvent_t command_event; /* 工作事件可跨WAIT保留,执行收尾继续使用原EXECUTE身份。 */ IEC104_Station_t *command_station; /* 应用额外引用:首个工作事件先Acquire,再保存context;FINISHED后Release。 */ uint64_t command_instance, command_transaction; /* 保留事务归属;SELECT/EXECUTE共用,FINISHED须先核对再清理。 */ /* pending仅表示工作事件尚待Accept/Reject;waiting表示上次接口WAIT,避免把待重试状态当作可立即推进。 * selected/output是模拟返校及输出的副作用标志,不代替协议阶段;真实设备忙状态应独立维护。 */ bool command_pending, command_waiting, command_selected, command_output; unsigned command_step; /* 0等待事件/终结,1报告设备结果,2返回信息,3关闭返回阶段。 */ IEC60870_Asdu_t command_return; /* 借用下面的固定缓冲;WAIT未接手,必须连同事件保留到OK或STALE。 */ /* 本例默认地址长度下,最大Type30/31返回为6字节头+3字节IOA+1字节状态+7字节时标。 * Submit_Return_Info返回WAIT时仍借用此缓冲,不能复用总召/读命令的存储覆盖原帧。 */ uint8_t command_return_bytes[17]; /* 单帧持久存储,长度按上面的最大返回对象核算。 */ IEC60870_CP56Time2a_t command_action_time; /* 与command_change的动作值配对;返回WAIT期间不重新取时。 */ /* [STATE/POINT_VALUES] 总召、读命令、遥控与突发共享的当前点值 */ /* 总召、分组与读命令共用当前值,FINISHED不重置运行值。通用入口按8点命令组映射; * DTU单点使用稀疏源映射,双点为16个开关反馈,遥控和自动过流工况均可更新相关遥信。 */ uint8_t signal_values[EXAMPLE_SIGNAL_COUNT], double_values[EXAMPLE_DOUBLE_COUNT]; #ifdef IEC104_EXAMPLE_DTU_PROFILE /* 工况/延时用单调时间;pending按表下标占位,每点只保留待发的最新值/时刻。 */ uint64_t dtu_started_ms; uint64_t dtu_signal_pending, dtu_signal_time[EXAMPLE_SIGNAL_COUNT]; uint64_t dtu_energy_last_ms; double dtu_energy_wh[EXAMPLE_COUNTER_COUNT], dtu_energy_frozen_wh[EXAMPLE_COUNTER_COUNT]; DtuMeasurementInput dtu_input; DtuMeasurementFrame dtu_frame; DtuProtection dtu_protection; DtuProtectionOutput dtu_protection_output; uint8_t dtu_digital[DTU_PROTECTION_SIGNAL_COUNT]; /* 原始逻辑;取反只用于监视输出。 */ uint8_t dtu_digital_candidate[DTU_PROTECTION_SIGNAL_COUNT]; uint8_t dtu_digital_output[DTU_PROTECTION_SIGNAL_COUNT]; uint64_t dtu_digital_since[DTU_PROTECTION_SIGNAL_COUNT]; uint64_t dtu_pulse_until[EXAMPLE_DOUBLE_COUNT]; uint64_t dtu_command_due_ms, dtu_activation_since, dtu_activation_day; bool dtu_activation, dtu_activation_scheduled; const char *dtu_input_path, *dtu_recording_directory; uint16_t dtu_recording_sequence; uint32_t dtu_recording_pending; bool dtu_sample_valid; int16_t dtu_submitted[EXAMPLE_MEASUREMENT_COUNT]; double dtu_recording_before[8], dtu_recording_after[8]; IEC60870_CP56Time2a_t dtu_recording_time; uint16_t dtu_recording_before_digital, dtu_recording_after_digital; #endif /* 两组值仅由命令执行修改,供Type102和命令返回读取;未加入总召/周期扫描点表。 * 每个ExampleApp独立持有,普通STOP/重连保留;应用初始化及模拟协议重建时清零。 */ int8_t step_values[EXAMPLE_STEP_COUNT]; /* 0x6021..0x6028控制1201..1208,每次升/降一档,初值0。 */ uint32_t bitstring_values[EXAMPLE_BITSTRING_COUNT]; /* 0x6041..0x6048控制1301..1308,完整替换32位值,初值0。 */ int16_t scaled_values[EXAMPLE_MEASUREMENT_COUNT]; /* 统一处理值;49/62和模拟采样先更新原始输入。 */ ExampleMeasurement measurements[EXAMPLE_MEASUREMENT_COUNT]; /* 参数处理启用时的状态,不增加发布队列容量。 */ /* [STATE/CLOCK_BASE] 校时及带时标业务共用的时间基准 */ bool clock_system, clock_valid, clock_update_pending; /* 仅成功校时置pending,回调外才更新Command基准。 */ uint64_t clock_utc_ms, clock_base_ms; /* UTC毫秒及同一时刻的Net单调基准,不影响协议计时。 */ uint64_t clock_refresh_ms; /* system模式最近一次读时尝试;失败也计时,避免每轮忙刷。 */ /* [STATE/CI_DATA] 计数量专属:冻结值、读取快照、游标与请求身份 */ IEC104_InterrogationEvent_t counter_event; /* WAIT时保留的原业务事件,重试不能换成新身份。 */ bool counter_pending, counter_first; /* 是否持有待应答事件、本轮是否先推进计数量。 */ uint8_t counter_type; /* 15/37保留整数模式;206读取当前值,207读取带冻结时间的副本。 */ float energy_snapshot[EXAMPLE_COUNTER_COUNT]; /* BEGIN固定的kWh/kVarh,不经过int32 BCR。 */ uint8_t energy_quality[EXAMPLE_COUNTER_COUNT]; uint64_t energy_snapshot_instance, energy_snapshot_request; int32_t counter_current[EXAMPLE_COUNTER_COUNT]; /* 模拟整数Wh;浮点模式换算为kWh,不用float长期累加。 */ IEC60870_BinaryCounterReading_t counter_frozen[EXAMPLE_COUNTER_COUNT]; /* 最近冻结值及BCR序号、品质。 */ IEC60870_BinaryCounterReading_t counter_snapshot[EXAMPLE_COUNTER_COUNT]; /* 本轮稳定副本;206只取当前整数值。 */ IEC60870_CP56Time2a_t counter_frozen_time[EXAMPLE_COUNTER_COUNT]; /* 冻结时刻,与值一起发布;未校时则IV=1。 */ IEC60870_CP56Time2a_t counter_snapshot_time[EXAMPLE_COUNTER_COUNT]; /* 重试不改用发送时刻。 */ size_t counter_cursor, counter_end; /* 当前读取区间,只有Submit_Batch成功才推进游标。 */ uint64_t counter_instance, counter_request; /* 快照归属;旧FINISHED不得清理新请求。 */ IEC104_Station_t *counter_station; /* 读取期间额外持有的原站节点,结束后归还引用。 */ unsigned long counter_completed; /* 已消费的COMPLETED通知数,包含读取及冻结/复位。 */ /* [STATE/GI_DATA] 总召专属:取数游标、工作事件与请求身份 */ ExampleGiData gi_data; /* 应用拥有的游标,库内没有session或回调参数。 */ IEC104_Station_t *gi_station; /* 取数期间持有原站,Complete_Data或FINISHED时释放。 */ uint64_t session_instance, session_request; /* 只清理对应请求的遍历状态及业务资源。 */ IEC104_InterrogationEvent_t business_event; /* 纯值,可保存到后续循环应答。 */ bool business_pending; /* [STATE/BATCH] 两种召唤串行共用的批次容器和字节缓冲 */ IEC60870_Asdu_t batch; /* 借用本应用bytes;Submit_Batch(OK)后可复用。 */ uint8_t batch_bytes[IEC104_MAX_ASDU_LEN]; /* [STATE/DISPATCH] 公共通知调度及不支持请求的兜底计数 */ bool events_pending; unsigned long other_submitted, other_rejected, other_cancelled, other_overloads; } ExampleApp; #ifdef IEC104_EXAMPLE_DTU_PROFILE static double dtu_setting(const ExampleApp *app, uint32_t ioa, double fallback); /* 内部int16_t刻度按源地址选取,Type13还原工程值;与XML遥测倍率独立。 */ static float Example_Measurement_Scale(size_t index) { uint16_t source = dtu_measurements[index].source_addr; if (source >= 0x961FU && source <= 0x9625U) { return 1000.0f; } if (source == 0x962AU) { return 10000.0f; } if (source == 0x9627U || source == 0x9628U) { return 10.0f; } if (source == 0x962BU || source == 0x962CU) { return 1.0f; } return 100.0f; } static float Example_Physical_Measurement(const ExampleApp *app, size_t index) { return (float)app->scaled_values[index] / Example_Measurement_Scale(index); } /* 0x002C..0x0031未配置,不能用ioa减基址索引;未找到返回容量哨兵,调用者须先判界。 */ static size_t Example_Dtu_Signal_Index(uint32_t ioa) { size_t index; for (index = 0U; index < EXAMPLE_SIGNAL_COUNT; ++index) { if (dtu_signals[index].ioa == ioa) { return index; } } return EXAMPLE_SIGNAL_COUNT; } /* 总召/Read立即可见新值;Flush前的再次变位覆盖待发时刻,相同值不补报。 */ static void Example_Dtu_Set_Signal(ExampleApp *app, uint32_t ioa, uint8_t value, uint64_t now) { size_t index = Example_Dtu_Signal_Index(ioa); if (index < EXAMPLE_SIGNAL_COUNT && app->signal_values[index] != value) { app->signal_values[index] = value; app->dtu_signal_time[index] = now; app->dtu_signal_pending |= UINT64_C(1) << index; } } static void Example_Dtu_Reset_Process(ExampleApp *app) { size_t index; Dtu_Measurement_Init(&app->dtu_input); Dtu_Protection_Init(&app->dtu_protection); memset(&app->dtu_protection_output, 0, sizeof(app->dtu_protection_output)); memset(app->dtu_digital, 0, sizeof(app->dtu_digital)); for (index = 0U; index < DTU_SIGNAL_COUNT; ++index) { uint16_t source = dtu_signals[index].source_addr; if (source >= 0x9141U && source <= 0x919DU) { app->dtu_digital[source - 0x9140U] = dtu_signals[index].initial; } } memcpy(app->dtu_digital_candidate, app->dtu_digital, sizeof(app->dtu_digital)); memcpy(app->dtu_digital_output, app->dtu_digital, sizeof(app->dtu_digital)); memset(app->dtu_digital_since, 0, sizeof(app->dtu_digital_since)); memset(app->dtu_pulse_until, 0, sizeof(app->dtu_pulse_until)); app->dtu_command_due_ms = 0U; app->dtu_activation = app->dtu_activation_scheduled = false; app->dtu_recording_pending = 0U; app->dtu_sample_valid = false; for (index = 0U; index < DTU_MEASUREMENT_COUNT; ++index) { app->dtu_submitted[index] = Dtu_Measurement_To_Scaled(dtu_measurements[index].initial, Example_Measurement_Scale(index), NULL); } } #endif static uint8_t Example_Initial_Signal(size_t index) { #ifdef IEC104_EXAMPLE_DTU_PROFILE return dtu_signals[index].initial; #else return example_signals[index].value; #endif } static int16_t Example_Initial_Measurement(size_t index) { #ifdef IEC104_EXAMPLE_DTU_PROFILE float value = dtu_measurements[index].initial * Example_Measurement_Scale(index); return (int16_t)(value + (value >= 0.0f ? 0.5f : -0.5f)); #else return example_measurements[index].value; #endif } static IEC60870_AsduResult_t Example_Create_Measurement(ExampleMeasurementObject *point, uint32_t ioa, int16_t value, uint8_t quality) { #ifdef IEC104_EXAMPLE_DTU_PROFILE return IEC60870_MeasuredValueShort_Create(point, ioa, (float)value / Example_Measurement_Scale(ioa - EXAMPLE_IOA_MEASUREMENT_BASE), quality); #else return IEC60870_MeasuredValueScaled_Create(point, ioa, value, quality); #endif } /* ============================================================================ * [MEASUREMENT/PROCESS] 参数驱动的应用测量链;所有读取回调只读处理后的值和品质 * ============================================================================ */ /** * 功能:取得指定遥测点当前应答或上送使用的质量位。 * 输入参数:app——示例应用上下文;index——本次条目、点或逻辑槽的下标。 * 输出参数:无独立输出参数。 * 返回值:该遥测点当前使用的质量位。 * 说明:参数模块存在时读取运行品质,否则使用点表初值;index须为有效遥测下标。 */ static uint8_t Example_Measurement_Quality(const ExampleApp *app, size_t index) { return app->parameter != NULL ? app->measurements[index].quality : 0U; } /** * 功能:将本示例的单调采集时刻映射为历史记录使用的 UTC 毫秒。 * 输入参数:app 持有启动时建立的历史基准;monotonic_ms 与该基准使用同一单调时钟。 * 输出参数:成功写回 utc_ms;基准前时刻或加法溢出返回 false,不重新读取系统时间替代采集时间。 * 历史格式没有CP56的IV字段,示例只用有效墙钟,不输出伪造的2000年占位时间。 * 启动基准来自Clock_Read;成功协议校时后使用同一新基准,并留作协议复位后的历史时钟。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:无。 */ static bool Example_History_Time(ExampleApp *app, uint64_t monotonic_ms, uint64_t *utc_ms) { uint64_t elapsed; if (app->clock_valid) { app->history_utc_ms = app->clock_utc_ms; app->history_base_ms = app->clock_base_ms; } if (monotonic_ms < app->history_base_ms) { return false; } elapsed = monotonic_ms - app->history_base_ms; if (app->history_utc_ms > UINT64_MAX - elapsed) { return false; } *utc_ms = app->history_utc_ms + elapsed; return *utc_ms / 1000U <= IEC60870_TIME_MAX_SECONDS; } /** * 功能:日志失败只能锁存停机,不能把已经完成的参数/升级操作改判拒绝或重做。 * 输入参数:app——示例应用上下文;result——待判定的处理结果。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:无。 * 说明:本函数不退出业务回调、不触碰协议资源;主循环在本次提交与收尾完成后检查失败标志。 */ static void Example_User_Log_Result(ExampleApp *app, IEC60870_UserLogResult_t result) { if (result == IEC60870_USER_LOG_OK) { return; } if (!app->user_log_failed) { EXAMPLE_USER_LOG_REPORT_FAULT(result); } app->user_log_failed = true; } /** * 功能:将已发生事实追加为一条持久用户日志。 * 输入参数:app——示例应用上下文;type——信息对象或日志类型标识;value——本次待处理的数值;occurred_ms——事实发生时的单调毫秒;text——文本或格式化缓冲。 * 输出参数:无独立输出参数。 * 返回值:无。 * 说明:输入为真实事实发生的单调时刻;事件FIFO的延迟交付不得改用当前时间。 * 启动与成功校时提供有效基准;回拨允许保留,记录顺序由持久序号决定。 * 调用者须使用同一单调时钟;早于当前基准的输入直接锁存失败,不以现读墙钟代替发生时间。 * 文本仅在同步Append期间借用;未启用或已经失败时不再访问介质,也不重试可能已经提交的记录。 */ static void Example_User_Log_Append(ExampleApp *app, uint8_t type, uint8_t value, uint64_t occurred_ms, const char *text) { uint64_t elapsed; if (app->user_log == NULL || app->user_log_failed) { return; } if (occurred_ms < app->user_log_base_ms) { Example_User_Log_Result(app, IEC60870_USER_LOG_INVALID); return; } elapsed = occurred_ms - app->user_log_base_ms; if (app->user_log_utc_ms > UINT64_MAX - elapsed) { Example_User_Log_Result(app, IEC60870_USER_LOG_INVALID); return; } Example_User_Log_Result(app, IEC60870_UserLog_Append(&app->user_log->core, type, app->user_log_utc_ms + elapsed, value, text)); } /** * 功能:每个实际变化的参数一条,不记录预置、相同值、TEST或确认发送重试。 * 输入参数:app——示例应用上下文;scope——日志中的参数领域名称;object——日志对象编号;area——远程参数区号;before——修改前的数值;after——修改后的数值。 * 输出参数:无独立输出参数。 * 返回值:无。 * 说明:调用者负责先完成真实修改,TEST/拒绝分支不能进入本函数;这里只再过滤同值。 * old/new采用有界ASCII表示,文本超限视为日志失败,不能静默截断对象身份。 */ static void Example_User_Log_Parameter(ExampleApp *app, const char *scope, uint32_t object, unsigned area, double before, double after) { char text[IEC60870_USER_LOG_TEXT_MAX + 1U]; int length; if (app->user_log == NULL || before == after) { return; } length = snprintf(text, sizeof(text), "PARAM %s object=%lu area=%u old=%.9g new=%.9g", scope, (unsigned long)object, area, before, after); if (length <= 0 || (size_t)length >= sizeof(text)) { Example_User_Log_Result(app, IEC60870_USER_LOG_INVALID); return; } Example_User_Log_Append(app, 10U, 1U, IEC104_Net_Now_Ms(), text); } /** * 功能:独立启用日志,先验证启动墙钟再恢复介质;不伪造硬件复位原因。 * 输入参数:app——示例应用上下文;log——日志持久适配实例;directory——持久存储目录。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:01记录本宿主示例进程启动,后续协议模拟重建另带SIMULATED标记。 * log由调用者持有并首次清零,须活到文件回调结束;directory只在打开期间借用。 * Open成功即把所有权登记到app,随后恢复状态或写启动记录失败也由Destroy统一关闭。 * 本入口不改变实时协议的校时有效性;只有完整恢复并保存启动事实才返回true。 */ static bool Example_Init_User_Log(ExampleApp *app, ExampleUserLog *log, const char *directory) { IEC60870_ClockValue_t value; IEC60870_CP56Time2a_t time; uint32_t seconds; uint64_t base_ms; size_t index; if (app->user_log != NULL || log == NULL || directory == NULL || !IEC60870_Clock_Read(&value) || value.is_invalid != 0U) { return false; } base_ms = IEC104_Net_Now_Ms(); memset(&time, 0, sizeof(time)); time.time = value.time; if (!IEC60870_Time_CP56_To_Seconds(&time, IEC60870_LOCAL_UTC_OFFSET_MINUTES, &seconds) || !Example_User_Log_Open(log, directory, "IEC104-EXAMPLE")) { return false; } app->user_log = log; app->user_log_utc_ms = (uint64_t)seconds * 1000U + value.time.ms; app->user_log_base_ms = base_ms; app->user_log_failed = app->user_log_connected = app->user_log_fault = false; /* 本存储只属于一个服务通道;恢复最近异常状态,进程重启后CONNECTED仍可形成恢复沿。 * 只搜索仍保留的1024条,找不到03便保留默认无异常,不推断已覆盖的旧事实。 * 不恢复connected标志,也不补造断电期间未知的断开时刻。 */ for (index = IEC60870_UserLog_Count(&log->core); index != 0U; --index) { IEC60870_UserLogRecord_t record; IEC60870_UserLogResult_t result = IEC60870_UserLog_Get(&log->core, index - 1U, &record); if (result != IEC60870_USER_LOG_OK) { Example_User_Log_Result(app, result); return false; } if (record.type == 3U) { app->user_log_fault = record.value != 0U; break; } } Example_User_Log_Append(app, 1U, 1U, base_ms, "HOST_PROCESS_START"); return !app->user_log_failed; } /** * 功能:根据连接事件记录TCP连通变化和通道故障恢复。 * 输入参数:app——示例应用上下文;event——本轮借用的协议事件。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:无。 * 说明:02只描述TCP连通;START/STOP不冒充建连/断线。03来源是本Slave服务通道, * 首次故障快照记发生,随后CONNECTED记恢复;同代次的启停/断线快照不重复记故障。 * 无故障的普通断开仅记02。日志错误不短路后续生命周期分派和资源清理。 * 建连1/断开0是本应用的02极性约定;03恢复只代表服务通道重连,不代表所有通信硬件恢复。 * 状态位用于顺序事件去重,不能证明日志已持久化;失败后仍更新内存边沿并交由主循环停机。 */ static void Example_User_Log_Connection(ExampleApp *app, const IEC104_SlaveEvent_t *event) { const IEC104_TcpConnectionEvent_t *connection = &event->transport.data.connection; IEC104_TcpEventType_t type = event->transport.type; char text[IEC60870_USER_LOG_TEXT_MAX + 1U]; int length; if (app->user_log == NULL || (type != IEC104_TCP_EVENT_CONNECTED && type != IEC104_TCP_EVENT_DISCONNECTED && type != IEC104_TCP_EVENT_ACTIVATED && type != IEC104_TCP_EVENT_DEACTIVATED)) { return; } length = snprintf(text, sizeof(text), "IEC104 ca=%u peer=%.15s:%u gen=%llu fault=%u socket=%d", (unsigned)IEC104_Station_Get_Common_Address(&app->station), connection->peer.address, (unsigned)connection->peer.port, (unsigned long long)event->transport.generation, connection->status_valid ? (unsigned)connection->status.fault : 0U, connection->socket_error); if (length <= 0 || (size_t)length >= sizeof(text)) { Example_User_Log_Result(app, IEC60870_USER_LOG_INVALID); return; } if (type == IEC104_TCP_EVENT_CONNECTED) { if (!app->user_log_connected) { Example_User_Log_Append(app, 2U, 1U, connection->occurred_ms, text); } app->user_log_connected = true; if (app->user_log_fault) { Example_User_Log_Append(app, 3U, 0U, connection->occurred_ms, text); } app->user_log_fault = false; } if (connection->status_valid && connection->status.fault != IEC104_TCP_FAULT_NONE && !app->user_log_fault) { Example_User_Log_Append(app, 3U, 1U, connection->occurred_ms, text); app->user_log_fault = true; } if (type == IEC104_TCP_EVENT_DISCONNECTED) { if (app->user_log_connected) { Example_User_Log_Append(app, 2U, 0U, connection->occurred_ms, text); } app->user_log_connected = false; } } /** * 功能:统一传播历史写入结果;首次失败输出原因并锁存 history_failed,主循环随后停止服务。 * 输入参数:app——示例应用上下文;result——待判定的处理结果。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:不在这里重试提交:同步失败可能已经落盘,恢复之前不能把同一事件再次追加。 */ static bool Example_History_Result(ExampleApp *app, IEC60870_HistoryResult_t result) { if (result == IEC60870_HISTORY_OK) { return true; } if (!app->history_failed) { fprintf(stderr, "HISTORY persistence failed: %d\n", (int)result); } app->history_failed = true; return false; } /** * 功能:同一次源变位在这里持久化一次,与发送FIFO、ACK、重试和QRP2清除完全独立。 * 输入参数:app——示例应用上下文;change——本次源变位或待冻结的变化副本。 * 输出参数:无独立输出参数。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:change 在本示例中携带单调采集时刻;只接入单点/双点遥信,其他发布类型保持原流程。 * 未启用历史直接成功;时间映射或提交失败必须传回调用者,不能继续假称该事件已保存。 */ static bool Example_History_Change(ExampleApp *app, const IEC104_SpontaneousChange_t *change) { uint64_t utc_ms; uint8_t value; if (app->history == NULL) { return true; } if (change->kind == IEC104_SPONTANEOUS_SINGLE) { value = change->value.single; } else if (change->kind == IEC104_SPONTANEOUS_DOUBLE) { value = change->value.double_point; } else { return true; } if (!Example_History_Time(app, change->time_ms, &utc_ms)) { return Example_History_Result(app, IEC60870_HISTORY_INVALID); } return Example_History_Result(app, IEC60870_History_Append_Soe(&app->history->core, change->ioa, value, change->quality, utc_ms, true)); } /** * 功能:示例的CO白名单是开关控制点;升降、位串、遥调不冒充附录B的分合操作记录。 * 输入参数:app——示例应用上下文;request——仅在当前回调期间借用的协议请求;command——已发生的控制操作阶段;monotonic_ms——事实发生时的单调毫秒。 * 输出参数:无独立输出参数。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:command 表示已交付应用的操作阶段,utc_ms 取该阶段的事件时间;不由确认发送结果倒推动作成功。 */ static bool Example_History_Command(ExampleApp *app, const IEC104_CommandRequest_t *request, IEC60870_HistoryCommand_t command, uint64_t monotonic_ms) { uint64_t utc_ms; uint8_t type = request->type_id; if (app->history == NULL || (type != 45U && type != 46U && type != 58U && type != 59U)) { return true; } if (!Example_History_Time(app, monotonic_ms, &utc_ms)) { return Example_History_Result(app, IEC60870_HISTORY_INVALID); } return Example_History_Result(app, IEC60870_History_Append_Control(&app->history->core, request->ioa, command, request->state, utc_ms, true)); } /** * 功能:取本轮处理后的遥测值与品质,交给核心持续更新极值并判断是否处于定点冻结窗口。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:一次调用包含整张遥测表,输入不经过发送变化门限筛选;调度未运行期间仍可能缺测。 * 时间回拨只暂停本次观测,其他错误锁存并结束示例;缺失的十五分钟窗口不补造。 */ static bool Example_History_Observe(ExampleApp *app) { float values[EXAMPLE_MEASUREMENT_COUNT]; uint8_t quality[EXAMPLE_MEASUREMENT_COUNT]; uint64_t utc_ms; size_t index; IEC60870_HistoryResult_t result; if (app->history == NULL) { return true; } if (app->history_failed) { return false; } if (!Example_History_Time(app, IEC104_Net_Now_Ms(), &utc_ms)) { return Example_History_Result(app, IEC60870_HISTORY_INVALID); } for (index = 0U; index < EXAMPLE_MEASUREMENT_COUNT; ++index) { #ifdef IEC104_EXAMPLE_DTU_PROFILE values[index] = Example_Physical_Measurement(app, index); #else values[index] = (float)app->scaled_values[index]; #endif quality[index] = Example_Measurement_Quality(app, index); } result = IEC60870_History_Observe(&app->history->core, utc_ms, values, quality, EXAMPLE_MEASUREMENT_COUNT); /* 校时回拨期间不覆盖已归档日槽、不重造过去样本;时间追上后自然恢复。 */ return result == IEC60870_HISTORY_TIME_REVERSED || Example_History_Result(app, result); } /** * 功能:本示例固定点表生成历史白名单,静态数组存活至所有历史实例关闭。 * 输入参数:app——示例应用上下文;history——历史持久适配实例;directory——持久存储目录。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:16个单/双遥信及对应开关控制、8个遥测;增加现场点时必须同时更新实际运行点表。 * command_points 须已初始化;先取得有效墙钟,再打开并恢复存储,最后发布 app->history。 * 此处只建立历史基准,不把实时上报模块标记为已经完成主站校时。 */ static bool Example_Init_History(ExampleApp *app, ExampleHistory *history, const char *directory) { static uint32_t soe_ioas[EXAMPLE_SIGNAL_COUNT + EXAMPLE_DOUBLE_COUNT]; #ifdef IEC104_EXAMPLE_DTU_PROFILE static uint32_t co_ioas[DTU_COMMAND_COUNT]; #else static uint32_t co_ioas[2U * EXAMPLE_SIGNAL_COUNT]; #endif static uint32_t analog_ioas[EXAMPLE_MEASUREMENT_COUNT]; IEC60870_HistoryConfig_t config; IEC60870_ClockValue_t value; IEC60870_CP56Time2a_t time; uint32_t seconds; uint64_t base_ms; size_t index; if (app->history != NULL || history == NULL || directory == NULL) { return false; } if (!IEC60870_Clock_Read(&value) || value.is_invalid != 0U) { return false; } base_ms = IEC104_Net_Now_Ms(); memset(&time, 0, sizeof(time)); time.time = value.time; if (!IEC60870_Time_CP56_To_Seconds(&time, IEC60870_LOCAL_UTC_OFFSET_MINUTES, &seconds)) { return false; } for (index = 0U; index < EXAMPLE_SIGNAL_COUNT; ++index) { soe_ioas[index] = example_signals[index].ioa; } for (index = 0U; index < EXAMPLE_DOUBLE_COUNT; ++index) { soe_ioas[EXAMPLE_SIGNAL_COUNT + index] = (uint32_t)(EXAMPLE_IOA_DOUBLE_BASE + index); } #ifdef IEC104_EXAMPLE_DTU_PROFILE for (index = 0U; index < DTU_COMMAND_COUNT; ++index) { co_ioas[index] = dtu_commands[index].ioa; } #else for (index = 0U; index < EXAMPLE_SIGNAL_COUNT; ++index) { co_ioas[index] = app->command_points[index].ioa; co_ioas[EXAMPLE_SIGNAL_COUNT + index] = app->command_points[EXAMPLE_SIGNAL_COUNT + index].ioa; } #endif for (index = 0U; index < EXAMPLE_MEASUREMENT_COUNT; ++index) { analog_ioas[index] = example_measurements[index].ioa; } memset(&config, 0, sizeof(config)); config.soe_ioas = soe_ioas; config.soe_count = sizeof(soe_ioas) / sizeof(soe_ioas[0]); config.co_ioas = co_ioas; config.co_count = sizeof(co_ioas) / sizeof(co_ioas[0]); config.analog_ioas = analog_ioas; config.analog_count = EXAMPLE_MEASUREMENT_COUNT; config.freeze_grace_ms = 1000U; #ifdef IEC104_EXAMPLE_DTU_PROFILE if (!Example_History_Open(history, directory, &config, "DTU 100V1A example")) { return false; } #else if (!Example_History_Open(history, directory, &config, "IEC104 slave example")) { return false; } #endif app->history = history; app->history_utc_ms = (uint64_t)seconds * 1000U + value.time.ms; app->history_base_ms = base_ms; app->history_failed = false; return true; } /** * 功能:附录F第一回路:冻结地址仅作为文件点标识,不经206/207发送。 * 输入参数:app——示例应用上下文;energy——冻结电能持久适配实例;meter——示例整数电能源实例;directory——持久存储目录;period_ms——功率方波周期,单位毫秒。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:在监听前同时完成介质核对、整数寄存器恢复及墙钟分段初始化。 */ static bool Example_Init_Energy(ExampleApp *app, ExampleEnergyFreeze *energy, ExampleEnergyMeter *meter, const char *directory, uint32_t period_ms) { static uint32_t interval_ioas[EXAMPLE_COUNTER_COUNT], day_ioas[EXAMPLE_COUNTER_COUNT]; static uint32_t flow_ioas[EXAMPLE_COUNTER_COUNT]; static const char *const units[EXAMPLE_COUNTER_COUNT] = { #ifdef IEC104_EXAMPLE_DTU_PROFILE "kWh", "kVarh", "kWh", "kVarh", "kVarh", "kVarh", "kVarh", "kVarh" #else "kWh", "kVarh", "kVarh", "kVarh", "kWh", "kVarh", "kVarh", "kVarh" #endif }; IEC60870_EnergyFreezeConfig_t config; IEC60870_ClockValue_t value; IEC60870_CP56Time2a_t time; uint32_t seconds; uint64_t mono, utc; size_t index; if (app->energy != NULL || !IEC60870_Clock_Read(&value) || value.is_invalid != 0U) { return false; } mono = IEC104_Net_Now_Ms(); memset(&time, 0, sizeof(time)); time.time = value.time; if (!IEC60870_Time_CP56_To_Seconds(&time, IEC60870_LOCAL_UTC_OFFSET_MINUTES, &seconds)) { return false; } utc = (uint64_t)seconds * 1000U + value.time.ms; IEC60870_EnergyFreeze_Config_Default(&config); for (index = 0U; index < EXAMPLE_COUNTER_COUNT; ++index) { interval_ioas[index] = EXAMPLE_IOA_ENERGY_INTERVAL_BASE + (uint32_t)index; day_ioas[index] = EXAMPLE_IOA_ENERGY_DAY_BASE + (uint32_t)index; flow_ioas[index] = EXAMPLE_IOA_ENERGY_FLOWREV_BASE + (uint32_t)index; } config.interval_ioas = interval_ioas; config.day_ioas = day_ioas; config.point_count = EXAMPLE_COUNTER_COUNT; config.flowrev_ioas = flow_ioas; config.flowrev_count = EXAMPLE_COUNTER_COUNT; config.value_semantics = 1U; #ifdef IEC104_EXAMPLE_DTU_PROFILE if (!Example_Energy_Freeze_Open(energy, directory, &config, "DTU 100V1A example", units)) { return false; } #else if (!Example_Energy_Freeze_Open(energy, directory, &config, "IEC104 slave example", units)) { return false; } #endif if (!Example_Energy_Meter_Init(meter, period_ms, mono, utc) || !Example_Energy_Meter_Restore(meter, &energy->core)) { Example_Energy_Freeze_Close(energy); return false; } app->energy = energy; app->energy_meter = meter; app->energy_failed = false; return true; } /** * 功能:两类来源时刻互不干扰:墙钟回拨只暂停定时冻结,FLOWREV仍按单调游标补算。 * 输入参数:app——示例应用上下文。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。 * 说明:提交失败后锁存退出,不能在同一faulted核心上原样重试。 */ #ifdef IEC104_EXAMPLE_DTU_PROFILE static bool Example_Dtu_Energy_Settings(ExampleApp *app, const DtuSettings *settings, uint64_t now, bool apply) { double common_gain, active, reactive, energy; bool reverse; if (app->energy_meter == NULL) { return true; } common_gain = Dtu_Settings_Get(settings, 0x8025U, 100.0) / 100.0 * Dtu_Settings_Get(settings, 0x8041U, 1.0) * Dtu_Settings_Get(settings, 0x8026U, 1.0) * Dtu_Settings_Get(settings, 0x8042U, 1.0) * Dtu_Settings_Get(settings, 0x8054U, 1.0); active = common_gain * Dtu_Settings_Get(settings, 0xA2E7U, 1.0); reactive = common_gain * Dtu_Settings_Get(settings, 0xA2E8U, 1.0); energy = Dtu_Measurement_Energy_Factor(settings); reverse = Dtu_Settings_Get(settings, 0x8056U, 0.0) != 0.0; return apply ? Example_Energy_Meter_Set_Gains_At(app->energy_meter, now, active, reactive, energy, reverse) : Example_Energy_Meter_Can_Set_Gains_At(app->energy_meter, now, active, reactive, energy, reverse); } #endif static bool Example_Energy_Step(ExampleApp *app) { if (app->energy == NULL) { return true; } if (app->energy_failed) { return false; } if (!Example_Energy_Meter_Step(app->energy_meter, &app->energy->core, IEC104_Net_Now_Ms())) { app->energy_failed = true; fprintf(stderr, "ENERGY_FREEZE failed: %d\n", (int)app->energy_meter->last_result); return false; } return true; } /** * 功能:配置上下限在本示例中定义有效量程,超出时保留数值并置OV;它不是通用越限告警点表。 * 输入参数:app——示例应用上下文;index——本次条目、点或逻辑槽的下标;now——本轮共用的单调毫秒时刻。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:无。 * 说明:后向Euler一阶滤波保存小数,按每点实际单调时差推进;同刻重复调用不重复滤波。 * 输出按正负对称规则取整后再判量程,等于上下限仍有效;内部小数保留以便缓变继续积累。 * range单独记录越限方向:从下越限跳到上越限时OV仍为1,也须识别为量程方向变化。 */ static void Example_Update_Measurement(ExampleApp *app, size_t index, uint64_t now) { ExampleMeasurement *state = &app->measurements[index]; double tau_ms = 1000.0 * app->parameter_values[3U * EXAMPLE_MEASUREMENT_COUNT + index].short_float; double elapsed = now >= state->updated_ms ? (double)(now - state->updated_ms) : 0.0; int16_t low = app->parameter_values[EXAMPLE_MEASUREMENT_COUNT + index].scaled; int16_t high = app->parameter_values[2U * EXAMPLE_MEASUREMENT_COUNT + index].scaled; if (tau_ms == 0.0) { state->filtered = state->raw; } else if (elapsed > 0.0) { state->filtered += elapsed / (tau_ms + elapsed) * ((double)state->raw - state->filtered); } state->updated_ms = now; /* 时钟倒退只重设时基,不构造巨大的无符号时差。 */ app->scaled_values[index] = (int16_t)(state->filtered + (state->filtered < 0.0 ? -0.5 : 0.5)); state->range = app->scaled_values[index] < low ? -1 : app->scaled_values[index] > high ? 1 : 0; state->quality = (uint8_t)(0U | (state->range != 0 ? IEC60870_ASDU_QUALITY_OV : 0U)); } /** * 功能:参数模块就绪后,以同一个单调时刻推进全部遥测的滤波值、量程状态和质量位。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:无。 * 说明:未启用参数模块时直接返回,保持示例原始遥测值。 */ static void Example_Update_Measurements(ExampleApp *app) { size_t index; uint64_t now; if (app->parameter == NULL) { return; } /* 一轮共用同一时刻,避免8点因函数执行先后产生不同的滤波时差。 */ now = IEC104_Net_Now_Ms(); for (index = 0U; index < EXAMPLE_MEASUREMENT_COUNT; ++index) { Example_Update_Measurement(app, index, now); } } /** * 功能:新输入到达前先推进旧输入,避免把新值追溯应用到此前的时间段。tau=0立即直通。 * 输入参数:app——示例应用上下文;index——本次条目、点或逻辑槽的下标;raw——新的原始标度值。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:无。 * 说明:第二次更新使用同一now:tau>0时保持滤波连续,新输入留待后续时差生效;tau=0时立即取新值。 */ static void Example_Set_Measurement(ExampleApp *app, size_t index, int16_t raw) { if (app->parameter != NULL) { uint64_t now = IEC104_Net_Now_Ms(); Example_Update_Measurement(app, index, now); app->measurements[index].raw = raw; Example_Update_Measurement(app, index, now); } else { app->scaled_values[index] = raw; } } /** * 功能:初始化或QRP1恢复时,以当时运行值建立输入、滤波和上送基准,避免把启动本身当成数值变位。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:无。 * 说明:调用前须先准备参数和scaled_values;QRP2仅重设发布基准,不应调用此函数重置滤波状态。 */ static void Example_Reset_Measurements(ExampleApp *app) { size_t index; uint64_t now = IEC104_Net_Now_Ms(); for (index = 0U; index < EXAMPLE_MEASUREMENT_COUNT; ++index) { ExampleMeasurement *state = &app->measurements[index]; memset(state, 0, sizeof(*state)); state->raw = state->submitted_value = app->scaled_values[index]; state->filtered = state->raw; state->updated_ms = now; Example_Update_Measurement(app, index, now); state->submitted_quality = state->quality; state->submitted_range = state->range; } } /** * 功能:基准只表示完整交给发送队列,或命令FINISHED确认返校已交付;不冒充主站ACK。 * 输入参数:app——示例应用上下文;entry——应用发布记录。 * 输出参数:无独立输出参数。 * 返回值:无。 * 说明:time_tag_cleared还标记QRP2之前留下的快照:它可以继续发布,但不能把新建基准退回旧值。 */ static void Example_Submitted_Measurement(ExampleApp *app, const ExamplePublication *entry) { size_t index = entry->change.ioa - EXAMPLE_IOA_MEASUREMENT_BASE; #ifdef IEC104_EXAMPLE_DTU_PROFILE if (!entry->time_tag_cleared && entry->change.kind == IEC104_SPONTANEOUS_SCALED && entry->change.station_id == IEC104_Station_Get_Id(&app->station) && index < EXAMPLE_MEASUREMENT_COUNT) { app->dtu_submitted[index] = entry->change.value.scaled; } #endif if (app->parameter != NULL && !entry->time_tag_cleared && entry->change.kind == IEC104_SPONTANEOUS_SCALED && entry->change.station_id == IEC104_Station_Get_Id(&app->station) && index < EXAMPLE_MEASUREMENT_COUNT) { ExampleMeasurement *state = &app->measurements[index]; state->submitted_value = entry->change.value.scaled; state->submitted_quality = entry->change.quality; state->submitted_range = entry->measurement_range; } } /* ============================================================================ * [SPONTANEOUS/QUEUE] 突发上送:应用变化队列、遥控补报占位与周期采样 * ============================================================================ */ /** * 功能:从应用待发布数组移除指定条目并压紧后续元素。 * 输入参数:app——示例应用上下文;index——本次条目、点或逻辑槽的下标。 * 输出参数:无独立输出参数。 * 返回值:无。 * 说明:仅用于应用待发布数组,调用方保证index有效;压紧后不得继续使用先前取得的条目指针。 * 发送层已经接手的NORMAL条目独立持有副本,不受这里移除或移动元素影响。 */ static void Example_Remove_Publication(ExampleApp *app, size_t index) { if (index + 1U < app->publication_count) { memmove(&app->publications[index], &app->publications[index + 1U], (app->publication_count - index - 1U) * sizeof(app->publications[0])); } --app->publication_count; } /** * 功能:QRP=2只处理已有变化的发布形态,不修改点的当前值或采样时间。 * 输入参数:app——示例应用上下文;entry——应用发布记录。 * 输出参数:entry——应用发布记录。 * 返回值:清除CP56后仍有合法发布形态时返回true;否则返回false,调用方须删除该条目。 * 说明:forms=0是“继承配置”,不是“不发送”;清除CP56前须先展开,剩余形态须写成显式值。 * 默认单/双点只有CP56,清除后须删除事件,不能改发PLAIN;显式兼容双报才可能留下PLAIN。 * false表示无合法形态可发布,调用方必须删除条目,不能把0留给后续Publish再次继承。 */ static bool Example_Clear_Publication_Time(ExampleApp *app, ExamplePublication *entry) { unsigned kind = (unsigned)entry->change.kind; uint8_t forms = entry->change.forms; if (kind == 0U || kind > IEC104_SPONTANEOUS_KIND_COUNT) { return false; } if (forms == 0U) { forms = app->publication_forms[kind - 1U]; } entry->change.forms = (uint8_t)(forms & (uint8_t)~IEC104_SPONTANEOUS_FORM_CP56); return entry->change.forms != 0U; } /** * 功能:把指定采样单调时刻映射为监视信息使用的本地CP56快照。 * 输入参数:app/time均非NULL;sampled_ms与Net_Now_Ms、clock_base_ms属于同一单调时钟。 * 输出参数:覆盖*time,不修改应用时钟或同步状态;无返回值。 * 返回值:无。 * 说明:先给出2000-01-01的可编码占位并置时间IV;基准缺失、采样早于基准、 * 整数溢出或超出CP56年份范围时保留该占位,不伪造有效时间。 * 能换算日历但未同步时保留近似日历及IV=1;只有发布器确认同步才清时间IV。 * 时间IV与SIQ/DIQ数据品质独立,本函数不会把时钟失效改写成遥信值无效。 */ static void Example_Monitor_Time(const ExampleApp *app, uint64_t sampled_ms, IEC60870_CP56Time2a_t *time) { IEC104_SpontaneousStatus_t status; IEC60870_WallTime_t local; uint64_t elapsed, utc_ms; memset(time, 0, sizeof(*time)); time->time.year = 2000U; time->time.month = 1U; time->time.day = 1U; time->is_invalid = 1U; time->has_weekday = 1U; if (!app->clock_valid || sampled_ms < app->clock_base_ms) { return; } elapsed = sampled_ms - app->clock_base_ms; if (app->clock_utc_ms > UINT64_MAX - elapsed) { return; } utc_ms = app->clock_utc_ms + elapsed; if (utc_ms / 1000U > IEC60870_TIME_MAX_SECONDS || !IEC60870_Time_Seconds_To_Local((uint32_t)(utc_ms / 1000U), (uint16_t)(utc_ms % 1000U), &local) || local.year < 2000U || local.year > 2099U) { return; } time->time = local; if (IEC104_Spontaneous_Get_Status(app->spontaneous, &status) && status.time_synchronized) { time->is_invalid = 0U; } } /** * 功能:在应用入队时把单/双点的单调采样时间冻结为UTC毫秒及其时间品质。 * 输入参数:app/change均非NULL,change是即将保存的队列副本。 * 输出参数:仅处理单/双点的MONOTONIC输入;已为UTC或其他类型的条目保持原样,无返回值。 * 返回值:无。 * 说明:用入队时的基准换算一次;后续Publish的WAIT、断线补报或再次校时都沿用 * 保存的UTC和time_invalid,不能重新映射历史事件。原始采样对象不在此修改。 * CP56只作为中间日历;秒数换算后再加毫秒余数,不能把毫秒重复计入。 */ static void Example_Freeze_Signal_Time(const ExampleApp *app, IEC104_SpontaneousChange_t *change) { IEC60870_CP56Time2a_t time; uint32_t seconds; if ((change->kind != IEC104_SPONTANEOUS_SINGLE && change->kind != IEC104_SPONTANEOUS_DOUBLE) || change->time_kind != IEC104_SPONTANEOUS_TIME_MONOTONIC) { return; } Example_Monitor_Time(app, change->time_ms, &time); change->time_invalid = time.is_invalid != 0U; time.is_invalid = 0U; /* 仅让日历参与数值换算;真实时间IV已单独保存,不因此获得有效授时。 */ if (!IEC60870_Time_CP56_To_Seconds(&time, IEC60870_LOCAL_UTC_OFFSET_MINUTES, &seconds)) { /* UTC零值超出CP56年份范围,发布器会使用无效占位;不能保留旧的单调毫秒冒充UTC。 */ change->time_ms = 0U; change->time_invalid = true; } else { change->time_ms = (uint64_t)seconds * 1000U + time.time.ms; } change->time_kind = IEC104_SPONTANEOUS_TIME_UTC; } /** * 功能:判断单、双点变化是否使用独立CP56 SOE缓存。 * 输入参数:app——示例应用;change——采集变化。 * 输出参数:无。 * 返回值:单、双点且COT为3、有效形态仅CP56时返回true,其他变化返回false。 * 说明:零cause及forms分别采用突发原因和配置默认值;PLAIN或双报仍使用普通发布流程。 */ static bool Example_Is_Compact_Soe(const ExampleApp *app, const IEC104_SpontaneousChange_t *change) { uint8_t forms; if (change->kind != IEC104_SPONTANEOUS_SINGLE && change->kind != IEC104_SPONTANEOUS_DOUBLE) { return false; } forms = change->forms != 0U ? change->forms : app->publication_forms[change->kind - 1U]; return (change->cause == 0U || change->cause == IEC60870_ASDU_COT_SPONTANEOUS) && forms == IEC104_SPONTANEOUS_FORM_CP56; } /** * 功能:在新SOE分配序号前交接已有普通发布前缀,保持应用采集先后顺序。 * 输入参数:app——示例应用及至多32条待发布记录。 * 输出参数:app——出队记录、提交基准及publication_waiting状态。 * 返回值:前缀已处理或遇占位/WAIT时返回true,服务故障返回false。 * 说明:仅交接缓存,不推进网络;调用者区分WAIT与未决标记,后者不阻止继续采集SOE。 */ static bool Example_Drain_Publications(ExampleApp *app); /** * 功能:采集SOE直接进入独立缓存;其余变化保存在普通发布数组,给唯一遥控事务保留保序标记。 * 输入参数:app——示例应用上下文;entry——应用发布记录。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:按应用过载策略处理完毕时返回true,可能淘汰旧条目;无法处理时返回false。 * 说明:true表示按应用过载策略处理完毕,可能伴随丢旧计数,不表示已经发布或已送达主站。 * SOE占位原文由发送层持有,可被第257条覆盖;应用标记只阻挡较晚普通发布,不能阻止后续SOE采集。 * 普通变化过载时淘汰最旧普通条目,不能淘汰未决标记;采样快照与读取当前运行值的用途不同。 * 先按值复制再冻结队列时间,调用方及历史记录路径仍可使用原始MONOTONIC采样时间。 */ static bool Example_Queue_Publication(ExampleApp *app, const ExamplePublication *entry) { size_t index, ordinary = 0U; bool compact = Example_Is_Compact_Soe(app, &entry->change); IEC104_SpontaneousPublishInfo_t info; /* 先交接此前普通记录再分配SOE序号;marker仍保留位置,但不能堵住后续SOE采集。 * WAIT尚未交接完前缀,本次SOE也不接手,调用方不能把false当成已保存。 */ if (compact && (!Example_Drain_Publications(app) || app->publication_waiting)) { return false; } if (compact && !entry->placeholder) { IEC104_SpontaneousChange_t change = entry->change; IEC104_SpontaneousPublishResult_t result; Example_Freeze_Signal_Time(app, &change); result = IEC104_Spontaneous_Publish(app->spontaneous, &change, 1U, &info); if (result == IEC104_SPONTANEOUS_PUBLISH_ERROR && info.error == IEC104_SPONTANEOUS_ERROR_INPUT) { ++app->publication_invalid; return true; } return result == IEC104_SPONTANEOUS_PUBLISH_OK; } for (index = 0U; index < app->publication_count; ++index) { if (!app->publications[index].placeholder) { ++ordinary; } else if (entry->placeholder) { return false; } } while (app->publication_count == EXAMPLE_PUBLICATION_CAPACITY || (!entry->placeholder && ordinary >= EXAMPLE_PUBLICATION_CAPACITY - 1U)) { for (index = 0U; index < app->publication_count; ++index) { if (!app->publications[index].placeholder) { break; } } if (index == app->publication_count) { if (entry->placeholder) { return false; } ++app->publication_dropped; return true; } Example_Remove_Publication(app, index); --ordinary; ++app->publication_dropped; } app->publications[app->publication_count] = *entry; Example_Freeze_Signal_Time(app, &app->publications[app->publication_count].change); if (compact && entry->placeholder) { IEC104_SoeTicket_t ticket; memset(&ticket, 0, sizeof(ticket)); if (entry->has_change && IEC104_Spontaneous_Defer_Soe(app->spontaneous, &app->publications[app->publication_count].change, &ticket, &info) != IEC104_SPONTANEOUS_PUBLISH_OK) { return false; } app->command_soe_ticket = ticket; app->command_soe_instance = entry->instance_id; app->command_soe_transaction = entry->transaction_id; app->command_soe_active = true; } ++app->publication_count; return true; } /** * 功能:根据FINISHED的最终凭证取消或放行原SOE占位,其他类型仍按原流程决定普通COT=3补报。 * 输入参数:app——示例应用上下文;instance_id——业务模块实例身份;transaction_id——本次业务事务身份;undelivered——返回信息是否未完成交付。 * 输出参数:无独立输出参数。 * 返回值:占位处理完成或无匹配占位时返回true;运行中的SOE身份解析失败返回false。 * 说明:accepted只表示返回信息曾被接手,必须结合undelivered判断;没有变化时无需补报。 * 同时匹配实例与事务编号,避免较早事务的结束通知处理后来事务的占位。 */ static bool Example_Resolve_Publication(ExampleApp *app, uint64_t instance_id, uint64_t transaction_id, bool undelivered) { size_t index; for (index = 0U; index < app->publication_count; ++index) { ExamplePublication *entry = &app->publications[index]; if (entry->placeholder && entry->instance_id == instance_id && entry->transaction_id == transaction_id) { if (app->command_soe_active && app->command_soe_instance == instance_id && app->command_soe_transaction == transaction_id) { if (app->command_soe_ticket.serial != 0U && IEC104_Slave_Resolve_Soe(app->slave, &app->command_soe_ticket, !(entry->accepted && !undelivered)) != IEC104_TCP_OK) { IEC104_TcpServerStatus_t status; /* 正常清理在Close前完成;Close期间才交付的FINISHED只清应用标记, * 已关闭实例的队列已销毁,不能把失效票据当作新事件重新入队。 */ if (IEC104_Slave_Get_Status(app->slave, &status, NULL) != IEC104_TCP_OK || status.listening) { return false; } } app->command_soe_active = false; app->command_soe_instance = app->command_soe_transaction = 0U; memset(&app->command_soe_ticket, 0, sizeof(app->command_soe_ticket)); Example_Remove_Publication(app, index); return true; } if ((entry->accepted && !undelivered) || !entry->has_change || (entry->time_tag_cleared && !Example_Clear_Publication_Time(app, entry))) { if (entry->accepted && !undelivered) { Example_Submitted_Measurement(app, entry); } Example_Remove_Publication(app, index); } else { entry->placeholder = false; entry->change.cause = IEC60870_ASDU_COT_SPONTANEOUS; } return true; } } return true; } /** * 功能:返回信息提交OK后先标记accepted,等FINISHED冻结凭证状态再决定是否需要补报。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:找到本次命令对应占位并标记已接手时返回true,没有匹配占位时返回false。 * 说明:应用标记阻挡较晚普通发布;独立SOE占位同时约束后续SOE发送次序, * 两者均不阻塞遥控应答或总召/读命令,后续真实SOE仍可继续采集入库。 */ static bool Example_Accept_Publication(ExampleApp *app) { size_t index; for (index = 0U; index < app->publication_count; ++index) { ExamplePublication *entry = &app->publications[index]; if (entry->placeholder && entry->instance_id == app->command_instance && entry->transaction_id == app->command_transaction) { entry->accepted = true; return true; } } return false; } /** * 功能:每轮至多采一次当前值,错过周期不补造历史变位;条目时刻取实际采样的单调时间。 * 输入参数:app——示例应用上下文。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。 * 说明:通用field以微扰、负载变化及阶跃增量更新raw,保留遥调工作点,遥信由遥控改变。 * DTU field按单调毫秒推进30秒工况,每拍从配置初值重建遥测并计算三段过流遥信; * 因而下一拍会覆盖遥调工作点,--events改变采样密度但不缩放30秒工况。stress轮转压力输入。 * 先更新共用运行值,再排入变化快照,因此即使发布等待,总召和读命令也能读取新值。 * --events 0停止模拟采样和普通DTU电量积分;DTU已待发遥信仍Flush,主循环仍推进 * 滤波、命令、背景扫描及可选冻结电量服务的独立计量节拍。 * true表示本拍完成或尚未到期,不表示产生了报文;发布失败返回false交主循环收尾。 */ #ifdef IEC104_EXAMPLE_DTU_PROFILE #include "iec104_dtu_runtime.inc" #endif static bool Example_Collect_Events(ExampleApp *app) { ExamplePublication entry; uint64_t now; size_t index = app->events_index; #ifdef IEC104_EXAMPLE_DTU_PROFILE now = IEC104_Net_Now_Ms(); Example_Dtu_Update_Digital(app, now); if (!Example_Dtu_Flush_Signals(app)) { return false; } #endif if (app->events_interval_ms == 0U) { return true; } now = IEC104_Net_Now_Ms(); /* 单调读数倒退时立即采一拍并重设时间基准,避免无符号减法制造巨大补采次数。 */ if (now >= app->events_last_ms && now - app->events_last_ms < app->events_interval_ms) { return true; } app->events_last_ms = now; #ifdef IEC104_EXAMPLE_DTU_PROFILE Example_Dtu_Accumulate_Energy(app, now); #endif memset(&entry, 0, sizeof(entry)); entry.has_change = true; entry.change.common_address = IEC104_Station_Get_Common_Address(&app->station); entry.change.station_id = IEC104_Station_Get_Id(&app->station); entry.change.time_kind = IEC104_SPONTANEOUS_TIME_MONOTONIC; entry.change.time_ms = now; if (app->events_field) { #ifdef IEC104_EXAMPLE_DTU_PROFILE return Example_Dtu_Field(app, now); #else /* 相位按实际执行的采样拍数计,不是毫秒数;调整--events会缩放整轮持续时间。 * 相邻两拍的+1/-1微扰相抵;10..29累加100,40另加250,60..79减回100,100另减250。 * 默认参数且无外部干预时,门限200过滤前40拍的小变化,相位40(第41次采样)的阶跃 * 触发上送;修改门限或平滑时间后未必在该拍触发,品质变化另行判定。 * 无遥调介入且未触及饱和边界时,120拍净增量为0;默认间隔下约12秒一轮。 */ int32_t delta = index % 2U == 0U ? 1 : -1; if (index >= 10U && index < 30U) { delta += 5; } else if (index >= 60U && index < 80U) { delta -= 5; } if (index == 40U) { delta += 250; } else if (index == 100U) { delta -= 250; } for (index = 0U; index < EXAMPLE_MEASUREMENT_COUNT; ++index) { /* 必须在当前原始值上加增量,不能用初始点表重建绝对值,也不能在滤波值上叠加。 * 这样遥调建立的新工作点继续有效;输入经Example_Set_Measurement进入测量链,主循环继续推进平滑。 */ int16_t previous = app->parameter != NULL ? app->measurements[index].raw : app->scaled_values[index]; int32_t raw = (int32_t)previous + delta; if (raw < EXAMPLE_SCALED_MIN) { raw = EXAMPLE_SCALED_MIN; } else if (raw > EXAMPLE_SCALED_MAX) { raw = EXAMPLE_SCALED_MAX; } Example_Set_Measurement(app, index, (int16_t)raw); /* 参数启用时只更新输入,随后由统一测量链按处理值、品质及门限生成COT3。 * 显式禁用参数才直接排变化;饱和后的同值不再制造重复事件。 */ if (app->parameter == NULL && raw != previous) { entry.change.kind = IEC104_SPONTANEOUS_SCALED; entry.change.ioa = example_measurements[index].ioa; entry.change.value.scaled = app->scaled_values[index]; entry.change.quality = Example_Measurement_Quality(app, index); if (!Example_Queue_Publication(app, &entry)) { return false; } } } app->events_index = (app->events_index + 1U) % 120U; return true; #endif } /* stress故意持续翻转遥信、递增遥测,并在上边界回绕,用于积压/重连压力测试。 * 每点两拍,8点轮转一圈共16拍;这不是field的“每拍更新全部遥测”。 */ if (!app->events_measurement) { app->signal_values[index] ^= 1U; entry.change.kind = IEC104_SPONTANEOUS_SINGLE; entry.change.ioa = example_signals[index].ioa; entry.change.value.single = app->signal_values[index]; entry.change.quality = 0U; } else { size_t signal_index = index; index %= EXAMPLE_MEASUREMENT_COUNT; int16_t raw = app->parameter != NULL ? app->measurements[index].raw : app->scaled_values[index]; Example_Set_Measurement(app, index, raw == EXAMPLE_SCALED_MAX ? EXAMPLE_SCALED_MIN : (int16_t)(raw + 1)); entry.change.kind = IEC104_SPONTANEOUS_SCALED; entry.change.ioa = example_measurements[index].ioa; entry.change.value.scaled = app->scaled_values[index]; entry.change.quality = Example_Measurement_Quality(app, index); app->events_index = (signal_index + 1U) % EXAMPLE_SIGNAL_COUNT; } app->events_measurement = !app->events_measurement; /* 参数模式由统一处理链按门限产生变化;遥信仍按原规则发布。 */ if (app->parameter != NULL && entry.change.kind == IEC104_SPONTANEOUS_SCALED) { return true; } /* 源变位先独立保存一次,再进入可因背压/覆盖而变化的实时发布队列。 */ if (!Example_History_Change(app, &entry.change)) { return false; } return Example_Queue_Publication(app, &entry); } /** * 功能:按参数门限收集需要普通COT3上送的遥测变化。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。 * 说明:仅过滤普通COT3。总召、读命令、周期/背景和遥调返校均不受门限抑制。 * 比较对象是上次已交接的变化/返校基准,不是上一采样值;小步缓变才能累计越过门限。 * COT1/2、总召和Read仅取当前快照,不推进此基准;品质和量程侧变化不受数值门限阻挡。 * 同点已有快照/命令占位时等待它出队;出队后重新比较最新值,WAIT和淘汰都不提前推进基准。 */ static bool Example_Collect_Measurement_Changes(ExampleApp *app) { size_t index; if (app->parameter == NULL) { return true; } for (index = 0U; index < EXAMPLE_MEASUREMENT_COUNT; ++index) { ExampleMeasurement *state = &app->measurements[index]; ExamplePublication entry; int32_t difference = (int32_t)app->scaled_values[index] - state->submitted_value; uint32_t delta = (uint32_t)(difference < 0 ? -difference : difference); bool changed = state->quality != state->submitted_quality || state->range != state->submitted_range; size_t pending; /* 门限0表示任意非零数值变化可报,不表示每次扫描都报;品质/量程侧变化已单独判定。 */ if (app->parameter_points[index].type_id == IEC60870_ASDU_P_ME_NA_1) { /* 固定满量程幅值10000;交叉乘保留归一化门限的精确边界,不随上下限改变。 */ changed = changed || (delta != 0U && delta * 32768U >= (uint32_t)app->parameter_values[index].normalized * (uint32_t)EXAMPLE_SCALED_MAX); } else { changed = changed || (delta != 0U && delta >= (uint32_t)app->parameter_values[index].scaled); } #ifdef IEC104_EXAMPLE_DTU_PROFILE /* XML绝对死区与标准变化门限共同约束数值变化;品质/越限变化始终放行。 */ if (state->quality == state->submitted_quality && state->range == state->submitted_range) { changed = changed && Dtu_Measurement_Changed(Example_Physical_Measurement(app, index), (double)state->submitted_value / Example_Measurement_Scale(index), Dtu_Measurement_Deadband(&app->dtu_settings, dtu_measurements[index].source_addr)); } #endif if (!changed) { continue; } for (pending = 0U; pending < app->publication_count; ++pending) { if (app->publications[pending].change.kind == IEC104_SPONTANEOUS_SCALED && app->publications[pending].change.ioa == example_measurements[index].ioa && app->publications[pending].change.station_id == IEC104_Station_Get_Id(&app->station)) { break; } } if (pending < app->publication_count) { continue; } memset(&entry, 0, sizeof(entry)); entry.has_change = true; entry.measurement_range = state->range; entry.change.kind = IEC104_SPONTANEOUS_SCALED; entry.change.common_address = IEC104_Station_Get_Common_Address(&app->station); entry.change.station_id = IEC104_Station_Get_Id(&app->station); entry.change.ioa = example_measurements[index].ioa; entry.change.value.scaled = app->scaled_values[index]; entry.change.quality = state->quality; entry.change.time_kind = IEC104_SPONTANEOUS_TIME_MONOTONIC; entry.change.time_ms = state->updated_ms; if (!Example_Queue_Publication(app, &entry)) { return false; } } return true; } /** * 功能:按应用数组顺序发布;published表示被模块接手的条目数,移除它不等于主站已经收到。 * 输入参数:app——示例应用上下文。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。 * 说明:WAIT保留未接手的队首并让出网络;占位等待FINISHED解析,不自行猜测返回信息结果。 * 单条输入错误可丢弃后继续,服务/队列/提交故障则返回false交主循环统一收尾。 */ static bool Example_Drain_Publications(ExampleApp *app) { app->publication_waiting = false; while (app->publication_count != 0U) { IEC104_SpontaneousPublishInfo_t info; IEC104_SpontaneousPublishResult_t result; if (app->publications[0].placeholder) { break; } #ifdef IEC104_EXAMPLE_DTU_PROFILE { IEC104_SpontaneousChange_t wire = app->publications[0].change; if (wire.kind == IEC104_SPONTANEOUS_SCALED) { float value = (float)wire.value.scaled / Example_Measurement_Scale(wire.ioa - EXAMPLE_IOA_MEASUREMENT_BASE); wire.kind = IEC104_SPONTANEOUS_FLOAT; wire.value.short_float = value; } result = IEC104_Spontaneous_Publish(app->spontaneous, &wire, 1U, &info); } #else result = IEC104_Spontaneous_Publish(app->spontaneous, &app->publications[0].change, 1U, &info); #endif if (info.published != 0U) { Example_Submitted_Measurement(app, &app->publications[0]); Example_Remove_Publication(app, 0U); } if (result == IEC104_SPONTANEOUS_PUBLISH_OK) { continue; } if (result == IEC104_SPONTANEOUS_PUBLISH_WAIT) { app->publication_waiting = true; return true; } if (info.error == IEC104_SPONTANEOUS_ERROR_INPUT && info.failed_index == 0U) { Example_Remove_Publication(app, 0U); ++app->publication_invalid; continue; } return false; /* STATE/QUEUE/SUBMIT: main stops and closes the service. */ } return true; } /* ============================================================================ * [GI/DATA] 总召业务 Type100:分组取值、批次提交与数据游标 * ============================================================================ */ /** * 功能:为总召监视数据追加一个点:SQ=1遇到同类型地址断号时,以FULL结束当前连续段。 * 输入参数:asdu——待组装的ASDU;point——本次加入的信息对象。 * 输出参数:asdu——待组装的ASDU。 * 返回值:沿用信息对象编码或ASDU追加结果:OK表示成功,FULL表示容量不足,ERROR等错误表示对象、类型或编码条件不满足。 * 说明:FULL不消费这个点,提交成功后下一批仍从该点开始;不能把缺失地址补成虚构数据。 * 断号时先验证已有帧,再以零容量编码仅验证新点,合法非空载荷返回FULL且不写缓冲。 * 这样非法IOA/品质/对象身份仍返回错误,不会被当作正常分帧;连续点沿用公共Add检查。 * 参数批次不经过此入口;Type100控制及Type110..112参数继续使用SQ=0。 */ static IEC60870_AsduResult_t Example_Gi_Add_Point(IEC60870_Asdu_t *asdu, const IEC60870_InformationObject_t *point) { if (asdu != NULL && point != NULL && asdu->is_sequence != 0U && asdu->object_count != 0U && point->type_id == asdu->type_id && point->ioa != asdu->first_ioa + asdu->object_count) { const uint8_t *bytes; uint16_t length; if (IEC60870_Asdu_Get_Data(asdu, &bytes, &length) != IEC60870_ASDU_OK) { return IEC60870_ASDU_ERROR; } return IEC60870_InformationObject_Encode(point, asdu->parameters, 1, asdu->buffer, 0U, &length); } return IEC60870_Asdu_Add_InformationObject(asdu, point); } /** * 功能:普通应用函数,只由下面的事件分支直接调用,不注册到库中。 * 输入参数:app——示例应用上下文;request——仅在当前回调期间借用的协议请求。 * 输出参数:app->batch及app->batch_bytes——本次构造的总召批次;业务游标由提交成功路径另行推进。 * 返回值:1表示已构造非空批次,0表示所选数据已读完,-1表示身份校验或构造失败。 * 说明:应用自行选择本批IOA、类型及分组成员;为NEED_DATA构造一种类型的一批。 * 细则要求总召遥信/遥测按SQ=1发送;--sequence仅控制周期/背景扫描,不影响这里。 * 真实取值应放在下列逐点组包处,值与品质的读取一致性由数据源保证;不预读整轮数据。 * 连续段结束或FULL均不跳过当前点;本函数不推进持久游标,Submit_Batch(OK)后才推进。 * WAIT仅保留事件,每次重试重读当前值。点值更新/突发发布与本次组包/提交须串行协调。 * 逐批取值不保证整轮同一采样时刻。 */ static int Example_Build_Batch(ExampleApp *app, const IEC104_InterrogationRequest_t *request) { ExampleGiData *data = &app->gi_data; IEC60870_Asdu_t *asdu = &app->batch; IEC60870_AsduHeader_t header; bool monitoring = data->single_index < EXAMPLE_SIGNAL_COUNT || data->double_index < EXAMPLE_DOUBLE_COUNT || data->scaled_index < EXAMPLE_MEASUREMENT_COUNT; IEC104_Station_t *station = request->station_id != 0U ? IEC104_Slave_Get_Station_By_Id(app->slave, request->station_id) : IEC104_Slave_Get_Station(app->slave, request->common_address); if (IEC104_Station_Get_Context(station) != app) { return -1; } memset(&header, 0, sizeof(header)); header.cause_of_transmission = request->qualifier; /* 站总召20,分组总召21..36。 */ header.common_address = request->common_address; header.originator_address = request->originator_address; header.is_test = request->is_test; if (IEC60870_Asdu_Create(asdu, IEC104_Slave_Get_Application_Layer_Parameters(app->slave), app->batch_bytes, sizeof(app->batch_bytes), &header, monitoring ? 1 : 0) != IEC60870_ASDU_OK) { return -1; } if (data->single_index < EXAMPLE_SIGNAL_COUNT) { size_t index = data->single_index; while (index < EXAMPLE_SIGNAL_COUNT && asdu->object_count < request->max_objects_per_asdu) { IEC60870_SinglePointInformation_t point; IEC60870_AsduResult_t added; if (IEC60870_SinglePointInformation_Create(&point, example_signals[index].ioa, app->signal_values[index], 0U) != IEC60870_ASDU_OK) { return -1; } added = Example_Gi_Add_Point(asdu, &point.object); if (added == IEC60870_ASDU_FULL) { break; } if (added != IEC60870_ASDU_OK) { return -1; } ++index; } } else if (data->double_index < EXAMPLE_DOUBLE_COUNT) { size_t index = data->double_index; while (index < EXAMPLE_DOUBLE_COUNT && asdu->object_count < request->max_objects_per_asdu) { IEC60870_DoublePointInformation_t point; IEC60870_AsduResult_t added; if (IEC60870_DoublePointInformation_Create(&point, (uint32_t)(EXAMPLE_IOA_DOUBLE_BASE + index), app->double_values[index], 0U) != IEC60870_ASDU_OK) { return -1; } added = Example_Gi_Add_Point(asdu, &point.object); if (added == IEC60870_ASDU_FULL) { break; } if (added != IEC60870_ASDU_OK) { return -1; } ++index; } } else if (data->scaled_index < EXAMPLE_MEASUREMENT_COUNT) { size_t index = data->scaled_index; while (index < EXAMPLE_MEASUREMENT_COUNT && asdu->object_count < request->max_objects_per_asdu) { ExampleMeasurementObject point; IEC60870_AsduResult_t added; if (Example_Create_Measurement(&point, example_measurements[index].ioa, app->scaled_values[index], Example_Measurement_Quality(app, index)) != IEC60870_ASDU_OK) { return -1; } added = Example_Gi_Add_Point(asdu, &point.object); if (added == IEC60870_ASDU_FULL) { break; } if (added != IEC60870_ASDU_OK) { return -1; } ++index; } } else if (data->parameter_index < EXAMPLE_PARAMETER_COUNT) { const IEC104_ParameterPoint_t *point = &app->parameter_points[data->parameter_index]; const IEC104_ParameterValue_t *value = &app->parameter_values[data->parameter_index]; /* 参数每帧一个对象;不能跨类型尝试Add直到FULL,类型变化首先返回ERROR。 * 直接读取与模块确认共用的运行值,QPM只填KPA,LPC/POP为0;112有限值由应用保证。 * 本批不推进游标,WAIT后仍重组这一行;已固定的装载确认不会随这里的读值刷新。 */ if (point->type_id == IEC60870_ASDU_P_ME_NA_1) { IEC60870_ParameterNormalizedValue_t object; if (IEC60870_ParameterNormalizedValue_Create(&object, point->ioa, value->normalized, point->kind) != IEC60870_ASDU_OK || IEC60870_Asdu_Add_InformationObject(asdu, &object.object) != IEC60870_ASDU_OK) { return -1; } } else if (point->type_id == IEC60870_ASDU_P_ME_NB_1) { IEC60870_ParameterScaledValue_t object; if (IEC60870_ParameterScaledValue_Create(&object, point->ioa, value->scaled, point->kind) != IEC60870_ASDU_OK || IEC60870_Asdu_Add_InformationObject(asdu, &object.object) != IEC60870_ASDU_OK) { return -1; } } else { IEC60870_ParameterFloatValue_t object; if (IEC60870_ParameterFloatValue_Create(&object, point->ioa, value->short_float, point->kind) != IEC60870_ASDU_OK || IEC60870_Asdu_Add_InformationObject(asdu, &object.object) != IEC60870_ASDU_OK) { return -1; } } } else { return 0; } return asdu->object_count != 0U ? 1 : -1; } /** * 功能:释放应用为当前取数持有的节点引用并清空游标,库的广播状态区仍独立保存协议进度。 * 输入参数:app——示例应用上下文。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:Complete_Data成功即可调用,让下一站复用游标;不需要等本轮所有站的FINISHED。 * 撤销时匹配的FINISHED也走此处,只归还应用额外Acquire的引用;库仍可持有原节点发送COT=9。 */ static bool Example_End_Data(ExampleApp *app) { if (app->gi_station != NULL && IEC104_Slave_Release_Station(app->slave, app->gi_station) != IEC104_STATION_OK) { return false; } app->gi_station = NULL; memset(&app->gi_data, 0, sizeof(app->gi_data)); app->session_instance = app->session_request = 0U; return true; } /** * 功能:启用示例的应用协调,与SlaveConfig.startup_event_gate=1配套,须早于SystemCommand创建及首次接入。 * 输入参数:app——示例应用上下文。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:这里只登记策略,不操作发送器或创建模块;main还须创建SystemCommand并登记初始化COI。 * 单独暂停突发Publish无效:离线NORMAL可能已在库中,必须由发送层门禁同时约束旧缓存和IDLE。 */ static bool Example_Init_Startup(ExampleApp *app) { if (app == NULL || app->slave == NULL) { return false; } IEC104_Startup_Init(&app->startup); return true; } /** * 功能:STOP/断线/退出解除应用的站表锁和取数引用,原协议FINISHED仍由业务模块独立交付。 * 输入参数:app——示例应用上下文。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:仅结束本轮应用关联,不调用Release_Startup、不清NORMAL、也不取消其他模块的协议任务。 * 清掉持有的GI交互前已归还应用读取资源;后续迟到FINISHED继续按原请求清理,不能再记启动成功。 * enabled保留,使下一次实际ACTIVATED重新闭锁同步;false表示资源归还失败,应进入故障收尾。 */ static bool Example_Startup_Reset(ExampleApp *app) { if (!IEC104_Startup_Reset(&app->startup, app->slave)) { return false; } if (app->startup.enabled && !Example_End_Data(app)) { return false; } if (app->startup.enabled) { app->business_pending = false; } return true; } /** * 功能:发送器在受理START时、继续发送之前已经关闸;这里只为收到的原ACTIVATED建立应用关联。 * 输入参数:app——示例应用上下文;event——本轮借用的协议事件。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:重复START不产生新ACTIVATED,因此不会清掉当前进度;STOP/重连后的实际激活则另有轮次。 * Lock_Stations固定本轮必须完成的CA集合,不冻结点值;放行、STOP、断线和退出均须配对归还。 */ static bool Example_Startup_Handle_Event(ExampleApp *app, const IEC104_SlaveEvent_t *event) { bool reset_data, result; result = IEC104_Startup_Handle_Event(&app->startup, app->slave, event, &reset_data); if (reset_data) { if (!Example_End_Data(app)) { return false; } app->business_pending = false; } return result; } /** * 功能:推进启动同步:Type70整轮已HANDED后才批准总召,所有站TERM也须HANDED后才开放NORMAL/IDLE。 * 输入参数:app——示例应用上下文。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:true包括阶段未就绪及发送WAIT,调用方继续网络/业务循环;false表示查询、身份或资源失败。 * 不等待总召ACK、不清NORMAL;新事件仍照常入队,实际选帧由发送层的独立门禁控制。 * 主站未发合格全站总召时持续等待,不因等待较久或缓存满自动放行;缓存仍执行原容量策略。 */ static bool Example_Startup_Step(ExampleApp *app) { return IEC104_Startup_Process(&app->startup, app->slave, app->system_command, &app->system_command_status); } /** * 功能:第二条事件流:应用主动取业务事件,再显式应答;没有库调用应用函数的路径。 * 输入参数:app——示例应用上下文。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。 * 说明:常量点表立即就绪;异步数据源可在NEED_DATA保留business_event,完成采样后再Submit。 * WAIT先处理Slave通知并推进网络,下次重取数据;STALE表示交互已失效,不重试过期事件。 * 广播撤销可能使尚未BEGIN的站直接结束,应用不能按广播站数等待等量BEGIN或FINISHED。 * 只清理实际已交付的业务交互;否定ACT_CON及各站撤销确认的保存和发送均由模块负责。 */ static bool Example_Drain_Business(ExampleApp *app) { unsigned count; for (count = 0U; count < EXAMPLE_EVENT_BUDGET; ++count) { IEC104_InterrogationEvent_t *event = &app->business_event; IEC104_InterrogationReplyResult_t reply; if (!app->business_pending) { IEC104_InterrogationNextResult_t next = IEC104_Interrogation_NextEvent(app->interrogation, event); if (next == IEC104_INTERROGATION_NEXT_EMPTY) { return true; } if (next != IEC104_INTERROGATION_NEXT_READY) { return false; } app->business_pending = true; } switch (event->type) { case IEC104_INTERROGATION_BEGIN: { bool accept = event->request.qualifier <= 22U; /* 示例仅定义组1=单点及双点遥信、组2=遥测;拒绝未配置的组。协议库支持全部16组。 * 正常广播先逐站完成BEGIN准入;这里只作决定,不占用唯一取数游标。 * 某站拒绝不代表整轮结束,后续站是否继续或被主站撤销,由模块按原目标状态处理。 */ if (accept) { /* 先登记尝试,再应答BEGIN;Reply_Begin的WAIT/STALE不会产生成功证据。 * 只有之后同一请求的COMPLETED会记录票据,所以不能在此把站标为已同步。 */ IEC104_TcpSubmitResult_t recorded = IEC104_Startup_Observe_General( &app->startup, app->slave, event, accept); if (recorded == IEC104_TCP_SUBMIT_WAIT) { return true; } if (recorded != IEC104_TCP_SUBMIT_OK) { return false; } } reply = IEC104_Interrogation_Reply_Begin(app->interrogation, event, accept); break; } case IEC104_INTERROGATION_NEED_DATA: { /* -1构造失败、0取数结束、1有批次;WAIT重试会按当前点值重新构造,故不跨轮保存。 */ int batch_result; /* 总召读取当前点值,无须等待独立的突发发布队列排空。 */ /* 广播逐站取数,因此首个NEED_DATA才建立游标;用注册编号取得原站,避免同CA替换串站。 * 应用单独Acquire,确保库交付FINISHED并归还自己的引用时,应用清理仍有有效节点。 */ if (event->request_id != app->session_request || event->instance_id != app->session_instance) { if (app->session_request != 0U) { return false; } if (event->request.station_id != 0U) { app->gi_station = IEC104_Slave_Get_Station_By_Id(app->slave, event->request.station_id); if (app->gi_station == NULL || IEC104_Slave_Acquire_Station(app->slave, app->gi_station) != IEC104_STATION_OK) { return false; } } memset(&app->gi_data, 0, sizeof(app->gi_data)); /* 参数只随站总召上送;分组总召和未启用参数时用末尾游标跳过整个参数分支。 */ if (app->parameter == NULL || event->request.qualifier != 20U) { app->gi_data.parameter_index = EXAMPLE_PARAMETER_COUNT; } if (event->request.qualifier == 21U) { app->gi_data.scaled_index = EXAMPLE_MEASUREMENT_COUNT; } if (event->request.qualifier == 22U) { app->gi_data.single_index = EXAMPLE_SIGNAL_COUNT; app->gi_data.double_index = EXAMPLE_DOUBLE_COUNT; } app->session_instance = event->instance_id; app->session_request = event->request_id; } batch_result = Example_Build_Batch(app, &event->request); if (batch_result < 0) { reply = IEC104_Interrogation_Fail_Request(app->interrogation, event); } else if (batch_result == 0) { reply = IEC104_Interrogation_Complete_Data(app->interrogation, event); } else { reply = IEC104_Interrogation_Submit_Batch(app->interrogation, event, &app->batch); } /* 仅提交成功推进本批所属游标;遥测到末尾后必须推进参数游标,不能重复发首个参数。 */ if (reply == IEC104_INTERROGATION_REPLY_OK && batch_result > 0) { if (app->gi_data.single_index < EXAMPLE_SIGNAL_COUNT) { app->gi_data.single_index += app->batch.object_count; } else if (app->gi_data.double_index < EXAMPLE_DOUBLE_COUNT) { app->gi_data.double_index += app->batch.object_count; } else if (app->gi_data.scaled_index < EXAMPLE_MEASUREMENT_COUNT) { app->gi_data.scaled_index += app->batch.object_count; } else { app->gi_data.parameter_index += app->batch.object_count; } } else if (reply == IEC104_INTERROGATION_REPLY_OK && batch_result == 0) { /* 其他站的数据随后才开始;无需等到所有站的ACT_TERM才复用游标。 */ if (!Example_End_Data(app)) { return false; } } break; } case IEC104_INTERROGATION_FINISHED: /* 完成、本地取消、主站撤销、超时、断线和失败统一清理。 * 真实异步采样还需在这里停止对应任务;迟到的旧FINISHED不清理新请求资源。 * 广播各站的通知可能晚于下一站开始取数,须比较instance_id/request_id,不能仅按CA清理。 * 先前被拒绝的站仍报告原REJECTED;其他站被撤销,不会把这个原因改成DEACTIVATED。 * FINISHED只表示业务已结束,否定ACT_CON或COT=9仍可能因发送WAIT尚未交接。 */ if (event->instance_id == app->session_instance && event->request_id == app->session_request) { if (!Example_End_Data(app)) { return false; } } if (event->reason == IEC104_INTERROGATION_FINISH_COMPLETED) { /* COMPLETED只说明ACT_TERM已提交,可能还排在HIGH中;保存票据交Startup_Step等HANDED。 * WAIT保留本条FINISHED,下轮先分派Slave通知;清理读取引用可在此前独立完成。 */ IEC104_TcpSubmitResult_t recorded = IEC104_Startup_Observe_General( &app->startup, app->slave, event, false); if (recorded == IEC104_TCP_SUBMIT_WAIT) { return true; } /* ERROR不计进度:同TCP旧FINISHED或已同步站后续总召都可能不匹配原BEGIN。 * 继续消费终结通知,不改用新身份重试;发送队列故障FATAL才转全局失败。 */ if (recorded == IEC104_TCP_SUBMIT_FATAL) { return false; } } reply = IEC104_INTERROGATION_REPLY_OK; /* 终结通知无需调用任何应答接口。 */ break; default: return false; } /* WAIT保留business_event且游标不动;下轮重新Build_Batch,不重发缓存的旧点值。 * 若等待期间收到撤销,旧NEED_DATA重试会返回STALE:放弃该交互并继续读FINISHED, * 不把STALE当成提交成功推进游标,也不在这里误清其他请求的资源。 */ if (reply == IEC104_INTERROGATION_REPLY_WAIT) { return true; } if (reply != IEC104_INTERROGATION_REPLY_OK && reply != IEC104_INTERROGATION_REPLY_STALE) { return false; } app->business_pending = false; } return true; } /* ============================================================================ * [GI/STEP] 总召步进:协议推进、事件消费与状态刷新 * ============================================================================ */ /** * 功能:两种业务各自推进协议、消费业务事件并刷新状态,供外层轮换调用次序。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。 * 说明:总召FINISHED即使已读完,模块仍可能欠原否定ACT_CON或逐站COT=9;不能以应用游标为空为由 * 停止调用Process,也不在这里等待ACK。最后刷新状态,让外层按发送背压决定何时继续。 */ static bool Example_Step_General(ExampleApp *app) { if (!IEC104_Interrogation_Process(app->interrogation)) { return false; } /* 继续转换期限及处理取消;初始化未完成时不领取新BEGIN,避免提前批准或占用应用游标。 * 未领取工作事件到期不会欠FINISHED;旧轮资源已在生命周期Reset中归还。 */ if (IEC104_Startup_Can_Consume_General(&app->startup) && !Example_Drain_Business(app)) { return false; } return IEC104_Interrogation_Get_Status(app->interrogation, &app->gi); } /* ============================================================================ * [CI/INIT] 计数量初始化:独立实例、广播状态区与模拟计数器 * ============================================================================ */ /** * 功能:把本应用已有的UTC毫秒基准和当前单调时差换算为一次本地时间快照。 * 输入参数:app——非空示例上下文,clock_*由成功校时或system模式刷新维护。 * 输出参数:time——非空输出;采用本地标准时间、SU=0,编码时携带星期。 * 返回值:无;始终写入完整快照,不修改app,也不重新读取系统/RTC。 * 说明:未校时、单调时间早于保存的base、加法溢出或日期越界时,保持2000-01-01及IV=1; * 占位日期只保证编码合法,不表示实际故障/冻结日期。此函数不改变电能的品质IV。 * clock_valid是基准可用标记,base_ms=0也可合法;IV=0不单独证明已获外部授时。 * 新接受的校时可以调整墙钟,已经保存的冻结时刻不会随之改写。 * 供计数量冻结和模拟时钟读取共用;两个业务的发送重试都使用各自保存的快照。 */ static void Example_Clock_Snapshot(const ExampleApp *app, IEC60870_CP56Time2a_t *time) { IEC60870_WallTime_t local; uint64_t now = IEC104_Net_Now_Ms(), utc_ms, elapsed; /* 先提供可编码的无效日历;所有失败分支都保留该占位,不使用全零CP56日历。 */ memset(time, 0, sizeof(*time)); time->time.year = 2000U; time->time.month = 1U; time->time.day = 1U; time->is_invalid = 1U; time->has_weekday = 1U; if (!app->clock_valid || now < app->clock_base_ms) { return; } elapsed = now - app->clock_base_ms; /* 先在64位域检查加法和秒数上界,再窄化;本站UTC+8越界由日历转换继续拒绝。 */ if (app->clock_utc_ms > UINT64_MAX - elapsed) { return; } utc_ms = app->clock_utc_ms + elapsed; if (utc_ms / 1000U > IEC60870_TIME_MAX_SECONDS || !IEC60870_Time_Seconds_To_Local((uint32_t)(utc_ms / 1000U), (uint16_t)(utc_ms % 1000U), &local) || local.year < 2000U || local.year > 2099U) { return; } time->time = local; time->is_invalid = 0U; } /** * 功能:计数量只在初始化、复位初始化及冻结动作中取时,组帧不改写原冻结时标。 * 输入参数:app——示例应用上下文;time——CP56日历时标回写位置。 * 输出参数:time——CP56日历时标回写位置。 * 返回值:无。 * 说明:无。 */ static void Example_Counter_Time(const ExampleApp *app, IEC60870_CP56Time2a_t *time) { Example_Clock_Snapshot(app, time); } /** * 功能:计数量实例可选,独立提供广播状态区;不共享总召的数组或取数游标。 * 输入参数:app——示例应用上下文;broadcast_states——调用方长期持有的广播站点工作区;broadcast_capacity——广播站点工作区容量;total_timeout_ms——整轮业务期限,单位毫秒。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:CLI仅注册一站。测试可给多个CA注册同一app,它们会指向同一组模拟计数器; * 真实多站应用应让各站context分别拥有计数器数据,尤其不要逐站复位同一物理源。 */ static bool Example_Init_Counters(ExampleApp *app, IEC104_InterrogationStationState_t *broadcast_states, size_t broadcast_capacity, uint32_t total_timeout_ms) { #ifdef IEC104_EXAMPLE_DTU_PROFILE static const int32_t initial[EXAMPLE_COUNTER_COUNT] = {0}; #else static const int32_t initial[EXAMPLE_COUNTER_COUNT] = {120000, 345600, 7890, 0, 1, 65535, INT32_MAX, 42}; #endif IEC104_InterrogationConfig_t config; IEC60870_CP56Time2a_t initial_time; size_t index; if (app->counter != NULL) { return false; } IEC104_Startup_Config_Default(NULL, NULL, NULL, &config, NULL); config.broadcast_states = broadcast_states; config.broadcast_capacity = broadcast_capacity; config.max_objects_per_asdu = 4U; config.total_timeout_ms = total_timeout_ms; app->counter = IEC104_CounterInterrogation_Create(app->slave, &config); if (app->counter == NULL) { return false; } /* 默认206面向主站返回当前示值;CLI可在初始化完成后选择其他类型。 * 初始冻结副本供37/207演示读取;尚未建立有效时钟基准时,其时间会明确标为无效。 */ app->counter_type = IEC60870_ASDU_M_IT_NB_1; Example_Counter_Time(app, &initial_time); for (index = 0U; index < EXAMPLE_COUNTER_COUNT; ++index) { app->counter_current[index] = initial[index]; app->counter_frozen[index].value = initial[index]; app->counter_frozen_time[index] = initial_time; } return true; } /* ============================================================================ * [CI/DATA] 计数量业务 Type101:冻结复位、读取快照与批次提交 * ============================================================================ */ /** * 功能:同步模拟计数器动作:执行入口先验证事件,WAIT/STALE及合法TEST不调用本函数。 * 输入参数:context——调用方注册的回调上下文;request——仅在当前回调期间借用的协议请求。 * 输出参数:无独立输出参数。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:FRZ=1保存当前值,FRZ=2先保存再清当前值,FRZ=3只清当前值并保留旧冻结值和时间。 * 选中组在同一事件循环内完成,所有新冻结点共用一次时刻采样;不调用网络或重入引擎。 * BCR序号供15/37整数模式使用,206/207不发送该序号。false必须发生在修改任何点之前。 * 实际外部电表命令需要独立的执行结果和重复请求策略,不能套用此同步函数。 */ static bool Example_Counter_Action(void *context, const IEC104_InterrogationRequest_t *request) { ExampleApp *app = (ExampleApp *)context; IEC60870_CP56Time2a_t freeze_time; size_t first, end, index; if (app->energy != NULL || request->is_test || (request->qualifier != 1U && request->qualifier != 2U && request->qualifier != 5U) || request->freeze == 0U || request->freeze > 3U) { return false; } first = request->qualifier == 2U ? 4U : 0U; end = request->qualifier == 1U ? 4U : EXAMPLE_COUNTER_COUNT; Example_Counter_Time(app, &freeze_time); #ifdef IEC104_EXAMPLE_DTU_PROFILE Example_Dtu_Accumulate_Energy(app, IEC104_Net_Now_Ms()); #endif for (index = first; index < end; ++index) { if (request->freeze != 3U) { #ifdef IEC104_EXAMPLE_DTU_PROFILE app->dtu_energy_frozen_wh[index] = app->dtu_energy_wh[index]; #endif app->counter_frozen[index].value = app->counter_current[index]; app->counter_frozen[index].sequence_number = (uint8_t)((app->counter_frozen[index].sequence_number + 1U) & 31U); app->counter_frozen_time[index] = freeze_time; } if (request->freeze >= 2U) { app->counter_current[index] = 0; #ifdef IEC104_EXAMPLE_DTU_PROFILE app->dtu_energy_wh[index] = 0.0; #endif } } return true; } /** * 功能:释放当前读取的节点引用和快照归属;快照字节无需清零,下次读取会整体覆盖。 * 输入参数:app——示例应用上下文。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:Complete_Data成功或匹配的FINISHED都可收尾,冻结动作本身不占用读取游标。 */ static bool Example_End_Counter(ExampleApp *app) { if (app->counter_station != NULL && IEC104_Slave_Release_Station(app->slave, app->counter_station) != IEC104_STATION_OK) { return false; } app->counter_station = NULL; app->counter_instance = app->counter_request = 0U; app->counter_cursor = app->counter_end = 0U; return true; } /** * 功能:从本轮固定快照构造批次;206/207用连续地址SQ=1,15/37保留SQ=0。 * 输入参数:app——示例应用上下文;request——仅在当前回调期间借用的协议请求。 * 输出参数:app->batch及app->batch_bytes——由冻结快照构造的计数量批次;本函数不推进快照游标。 * 返回值:1表示已构造非空批次,0表示所选组已读完,-1表示构造失败。 * 说明:整数与浮点共用0x6401..0x6408点表;浮点单位kWh。 * 共用ASDU缓冲但不推进游标,时标取冻结快照,不在这里读取当前时钟。 * 返回1表示非空批次,0表示所选组已读完,-1表示构造失败;WAIT后仍取同一快照重组。 */ static int Example_Build_Counter_Batch(ExampleApp *app, const IEC104_InterrogationRequest_t *request) { IEC60870_AsduHeader_t header; bool floating = app->counter_type == IEC60870_ASDU_M_IT_NB_1 || app->counter_type == IEC60870_ASDU_M_IT_TC_1; size_t index; if (app->counter_cursor == app->counter_end) { return 0; } memset(&header, 0, sizeof(header)); header.cause_of_transmission = request->data_cause; header.common_address = request->common_address; header.originator_address = request->originator_address; header.is_test = request->is_test; if (IEC60870_Asdu_Create(&app->batch, IEC104_Slave_Get_Application_Layer_Parameters(app->slave), app->batch_bytes, sizeof(app->batch_bytes), &header, floating ? 1 : 0) != IEC60870_ASDU_OK) { return -1; } for (index = app->counter_cursor; index < app->counter_end && app->batch.object_count < request->max_objects_per_asdu; ++index) { /* 每轮只构造一种对象;Add_InformationObject会复制编码字节,批次不借用此局部联合体。 */ union { IEC60870_IntegratedTotals_t integer; IEC60870_IntegratedTotalsWithCP56Time2a_t integer_time; IEC60870_IntegratedTotalsShort_t floating; IEC60870_IntegratedTotalsShortWithCP56Time2a_t floating_time; } point; IEC60870_InformationObject_t *object; IEC60870_AsduResult_t result; uint32_t ioa = (uint32_t)(EXAMPLE_IOA_COUNTER_BASE + index); /* 先用double把整数Wh换算为kWh,最后舍入到线上float32,避免在单位换算前先丢精度。 * 这里只映射数据无效位;BCR的序号/CY/CA不对应QDS,不可把整个BCR状态字当品质发送。 */ #ifdef IEC104_EXAMPLE_DTU_PROFILE float value = app->energy_snapshot[index]; #else float value = app->energy != NULL ? app->energy_snapshot[index] : (float)((double)app->counter_snapshot[index].value / 1000.0); #endif uint8_t quality = app->energy != NULL ? app->energy_quality[index] : (app->counter_snapshot[index].is_invalid ? 0x80U : 0U); switch (app->counter_type) { case IEC60870_ASDU_M_IT_NA_1: result = IEC60870_IntegratedTotals_Create(&point.integer, ioa, &app->counter_snapshot[index]); object = &point.integer.object; break; case IEC60870_ASDU_M_IT_TB_1: result = IEC60870_IntegratedTotalsWithCP56Time2a_Create(&point.integer_time, ioa, &app->counter_snapshot[index], &app->counter_snapshot_time[index]); object = &point.integer_time.base.object; break; case IEC60870_ASDU_M_IT_NB_1: result = IEC60870_IntegratedTotalsShort_Create(&point.floating, ioa, value, quality); object = &point.floating.object; break; case IEC60870_ASDU_M_IT_TC_1: result = IEC60870_IntegratedTotalsShortWithCP56Time2a_Create(&point.floating_time, ioa, value, quality, &app->counter_snapshot_time[index]); object = &point.floating_time.base.object; break; default: return -1; } if (result != IEC60870_ASDU_OK) { return -1; } result = IEC60870_Asdu_Add_InformationObject(&app->batch, object); if (result == IEC60870_ASDU_FULL) { break; } if (result != IEC60870_ASDU_OK) { return -1; } } return app->batch.object_count != 0U ? 1 : -1; } /** * 功能:首个NEED_DATA固定本轮快照:206取当前示值,其余取冻结值及原冻结时间。 * 输入参数:app——示例应用上下文。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。 * 说明:WAIT重建报文也使用同一份值、品质和时标。 * 模拟点值属于本应用;真实共享数据源应在其锁内取得快照后再进行网络提交。 */ static bool Example_Drain_Counter(ExampleApp *app) { unsigned count; if (app->counter == NULL) { return true; } for (count = 0U; count < EXAMPLE_EVENT_BUDGET; ++count) { IEC104_InterrogationEvent_t *event = &app->counter_event; IEC104_InterrogationReplyResult_t reply; if (!app->counter_pending) { IEC104_InterrogationNextResult_t next = IEC104_Interrogation_NextEvent(app->counter, event); if (next == IEC104_INTERROGATION_NEXT_EMPTY) { return true; } if (next != IEC104_INTERROGATION_NEXT_READY) { return false; } app->counter_pending = true; } switch (event->type) { case IEC104_INTERROGATION_BEGIN: { IEC104_Station_t *station = IEC104_Slave_Get_Station_By_Id(app->slave, event->request.station_id); /* 浮点模式仅演示国网总请求;在BEGIN同时拒绝分组读取和分组FRZ动作, * 避免先修改计数器,再到数据阶段才发现206/207不接受COT=38..41。 */ bool accept = IEC104_Station_Get_Context(station) == app && (event->request.qualifier == 5U || ((app->counter_type == IEC60870_ASDU_M_IT_NA_1 || app->counter_type == IEC60870_ASDU_M_IT_TB_1) && (event->request.qualifier == 1U || event->request.qualifier == 2U))); if (app->energy != NULL) { accept = accept && app->counter_type == IEC60870_ASDU_M_IT_NB_1 && event->request.qualifier == 5U && event->request.freeze == 0U; /* BEGIN的确认可能WAIT;按请求身份仅采一次,后续NEED_DATA不重采。 */ if (accept && (app->energy_snapshot_instance != event->instance_id || app->energy_snapshot_request != event->request_id)) { if (!Example_Energy_Meter_Snapshot(app->energy_meter, IEC104_Net_Now_Ms(), app->energy_snapshot, app->energy_quality)) { return false; } app->energy_snapshot_instance = event->instance_id; app->energy_snapshot_request = event->request_id; } } if (accept && event->request.freeze != 0U) { /* TEST同样走协议入口,由引擎短路action;不能先修改冻结值、序号或锁。 */ reply = IEC104_CounterInterrogation_Execute_Begin(app->counter, event, Example_Counter_Action, app); } else { reply = IEC104_Interrogation_Reply_Begin(app->counter, event, accept && event->request.freeze == 0U); } break; } case IEC104_INTERROGATION_NEED_DATA: { int built; /* 一个instance/request只取一次快照;后续批次和WAIT继续使用它, * 即使当前值已变化或另有冻结动作,也不把两代数据混进同一次召唤。 */ if (event->instance_id != app->counter_instance || event->request_id != app->counter_request) { IEC104_Station_t *station; if (app->counter_request != 0U) { return false; } station = IEC104_Slave_Get_Station_By_Id(app->slave, event->request.station_id); if (station == NULL || IEC104_Station_Get_Context(station) != app || IEC104_Slave_Acquire_Station(app->slave, station) != IEC104_STATION_OK) { return false; } app->counter_station = station; if (app->energy == NULL) { #ifdef IEC104_EXAMPLE_DTU_PROFILE size_t index; Example_Dtu_Accumulate_Energy(app, IEC104_Net_Now_Ms()); for (index = 0U; index < EXAMPLE_COUNTER_COUNT; ++index) { double wh = app->counter_type == IEC60870_ASDU_M_IT_NB_1 ? app->dtu_energy_wh[index] : app->dtu_energy_frozen_wh[index]; app->energy_snapshot[index] = (float)(wh / 1000.0); } #endif memcpy(app->counter_snapshot, app->counter_frozen, sizeof(app->counter_snapshot)); memcpy(app->counter_snapshot_time, app->counter_frozen_time, sizeof(app->counter_snapshot_time)); } if (app->energy == NULL && app->counter_type == IEC60870_ASDU_M_IT_NB_1) { size_t index; /* 206取实时Wh源;复用BCR存储槽前清除旧冻结品质/序号,实际编码仍是float+QDS。 * 当前模拟源只有有效整数值;真实设备接入时应一并采集实时品质。 */ memset(app->counter_snapshot, 0, sizeof(app->counter_snapshot)); for (index = 0U; index < EXAMPLE_COUNTER_COUNT; ++index) { app->counter_snapshot[index].value = app->counter_current[index]; } } app->counter_cursor = event->request.qualifier == 2U ? 4U : 0U; app->counter_end = event->request.qualifier == 1U ? 4U : EXAMPLE_COUNTER_COUNT; app->counter_instance = event->instance_id; app->counter_request = event->request_id; } built = Example_Build_Counter_Batch(app, &event->request); if (built < 0) { reply = IEC104_Interrogation_Fail_Request(app->counter, event); } else if (built == 0) { reply = IEC104_Interrogation_Complete_Data(app->counter, event); } else { reply = IEC104_Interrogation_Submit_Batch(app->counter, event, &app->batch); } if (reply == IEC104_INTERROGATION_REPLY_OK) { /* 发送层接手后才推进;WAIT保持事件和游标,下一轮可从同一快照重建相同批次。 */ if (built > 0) { app->counter_cursor += app->batch.object_count; } else if (built == 0 && !Example_End_Counter(app)) { return false; } } break; } case IEC104_INTERROGATION_FINISHED: if (event->reason == IEC104_INTERROGATION_FINISH_COMPLETED) { ++app->counter_completed; } if (event->instance_id == app->counter_instance && event->request_id == app->counter_request && !Example_End_Counter(app)) { return false; } reply = IEC104_INTERROGATION_REPLY_OK; break; default: return false; } if (reply == IEC104_INTERROGATION_REPLY_WAIT) { return true; } if (reply != IEC104_INTERROGATION_REPLY_OK && reply != IEC104_INTERROGATION_REPLY_STALE) { return false; } app->counter_pending = false; } return true; } /* ============================================================================ * [CI/STEP] 计数量步进:协议推进、事件消费与状态刷新 * ============================================================================ */ /** * 功能:推进本轮计数量召唤处理。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。 * 说明:仅总召测试不创建计数量实例,此时直接完成本轮;已创建时采用相同推进顺序。 */ static bool Example_Step_Counter(ExampleApp *app) { return app->counter == NULL || (IEC104_Interrogation_Process(app->counter) && Example_Drain_Counter(app) && IEC104_Interrogation_Get_Status(app->counter, &app->ci)); } /* ============================================================================ * [CLOCK/INIT] 校时初始化:配置复制与实例绑定 * ============================================================================ */ /** * 功能:config可为NULL采用默认值;创建须早于消费Slave通知,实例独占自身请求和确认状态。 * 输入参数:app——示例应用上下文;config——初始化配置。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:无。 */ static bool Example_Init_Clock(ExampleApp *app, const IEC104_ClockSynchronizationConfig_t *config) { IEC104_ClockSynchronizationConfig_t defaults; if (app->clock != NULL) { return false; } if (config == NULL) { IEC104_ClockSynchronization_Config_Default(&defaults); config = &defaults; } app->clock = IEC104_ClockSynchronization_Create(app->slave, config); return app->clock != NULL; } /* ============================================================================ * [CLOCK/ACTION] Type103:时间基准、设时/读时动作与应答推进 * ============================================================================ */ /** * 功能:system模式启动时及每60秒刷新。Clock_Read给出固定UTC+8标准日历,不能使用主站时区或SU。 * 输入参数:app——示例应用上下文;force——是否强制刷新或提交。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:无。 * 说明:读时失败、IV或换算失败立即清除基准;此处只读系统时钟,不触发设时。 * 在分派新命令前调用,已有事务仍按Command的受理时效契约推进。 */ static void Example_Refresh_System_Clock(ExampleApp *app, bool force) { IEC60870_ClockValue_t value; IEC60870_CP56Time2a_t time; uint32_t seconds; uint64_t now, base_ms, utc_ms; if (!app->clock_system) { return; } now = IEC104_Net_Now_Ms(); if (!force && now >= app->clock_refresh_ms && now - app->clock_refresh_ms < EXAMPLE_CLOCK_REFRESH_MS) { return; } app->clock_refresh_ms = now; app->clock_update_pending = false; if (IEC60870_Clock_Read(&value) != 0 && value.is_invalid == 0U) { base_ms = IEC104_Net_Now_Ms(); memset(&time, 0, sizeof(time)); time.time = value.time; if (IEC60870_Time_CP56_To_Seconds(&time, IEC60870_LOCAL_UTC_OFFSET_MINUTES, &seconds)) { utc_ms = (uint64_t)seconds * 1000U + value.time.ms; if (app->command == NULL || IEC104_Command_Set_Time_Base(app->command, utc_ms, base_ms)) { app->clock_utc_ms = utc_ms; app->clock_base_ms = base_ms; app->clock_valid = true; if (force) { (void)IEC104_Spontaneous_Set_Time_Base(app->spontaneous, utc_ms, base_ms, false); } return; } } } app->clock_valid = false; if (app->command != NULL) { IEC104_Command_Clear_Time_Base(app->command); } if (force) { IEC104_Spontaneous_Clear_Time_Base(app->spontaneous); } } /** * 功能:执行已授权的真实校时动作并更新示例时钟状态。 * 输入参数:context——调用方注册的回调上下文;request——仅在当前回调期间借用的协议请求。 * 输出参数:无独立输出参数。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:仅COT6真实设时会进入本回调,COT5读取及COT6 TEST均不借此产生成功校时状态。 * 执行检查已完成时区换算和滞留补偿;动作不重复补偿,也不推进网络事件循环。 * system设时失败时不置pending;执行入口的OK只表示回调返回,不单独证明设时成功。 */ static bool Example_Clock_Action(void *context, const IEC104_ClockSynchronizationRequest_t *request) { ExampleApp *app = (ExampleApp *)context; if (app->clock_system && IEC60870_Clock_Set(&request->local_time) == 0) { return false; } app->clock_utc_ms = request->utc_ms; app->clock_base_ms = request->base_ms; app->clock_valid = true; app->clock_update_pending = true; app->clock_refresh_ms = request->base_ms; /* 日志与协议校时共享成功事实,协议模拟复位后仍保留此持久时基。 */ if (app->user_log != NULL) { app->user_log_utc_ms = request->utc_ms; app->user_log_base_ms = request->base_ms; } return true; } /** * 功能:为Type103/COT5提供一次只读本地时间,READ/SET的调用顺序由校时模块维护。 * 输入参数:context——非空本应用;request——当前只读请求身份及TEST,仅在回调期间有效。 * 输出参数:time——非空、本地UTC+8标准时间、毫秒及IV;协议层补齐星期并要求SU=0。 * 返回值:true提供了快照(可以IV=1),仍须通过协议层日期/字段校验;false表示后端读时失败, * 不改time,协议层回COT5否定。合法IV=1输出可获肯定回复,读取成功不等于时间可信。 * 说明:simulated模式用已有基准推算,无基准时给合法2000-01-01占位且IV=1; * system模式每个新请求直接读Clock后端,不使用60秒刷新的旧缓存。 * Clock_Read返回的是本地标准日历,不再叠加UTC+8或主站配置时区;年份若不足2000, * 虽可能是Clock后端合法日历,仍由协议层按CP56范围拒绝,不伪造当前年份。 * 此示例各逻辑站共用设备时钟,所以不按CA取不同源;TEST也可调用同一安全只读后端。 * 不调用Clock_Set,不更新clock_valid/pending或Command/Spontaneous基准;WAIT不再调用。 */ static bool Example_Clock_Read(void *context, const IEC104_ClockSynchronizationReadRequest_t *request, IEC60870_CP56Time2a_t *time) { const ExampleApp *app = (const ExampleApp *)context; IEC60870_ClockValue_t value; (void)request; if (!app->clock_system) { /* 未取得基准仍返回合法IV占位;这是读到了未同步状态,与后端调用失败分开表达。 */ Example_Clock_Snapshot(app, time); return true; } /* 先在局部变量取得完整日历和品质;失败不能改变调用方输出或已有应用时基。 */ if (IEC60870_Clock_Read(&value) == 0) { return false; } memset(time, 0, sizeof(*time)); time->time = value.time; time->is_invalid = value.is_invalid; time->has_weekday = 1U; return true; } /** * 功能:按同一FIFO显式执行读/设时操作,并在成功设时回调返回后发布新的业务时间基准。 * 输入参数:app——已初始化的应用;clock为空表示未启用该可选业务。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本轮推进或正常让出,不保证待回复已发送;false交主循环按故障收尾。 * 说明:每轮最多调用执行入口EXAMPLE_EVENT_BUDGET次,READ和SET共用预算,让出主循环推进其他业务。 * WAIT先交回Slave消费通知,EMPTY可能仍有REPLY等待Process提交;两者都不重放回调。 * OK也可能是读取失败或设时失败,只有设时回调置clock_update_pending才更新其他模块。 * 读取只产生回复快照,不因成功读取、IV变化或旧clock_valid恢复/刷新授时状态。 */ static bool Example_Drain_Clock(ExampleApp *app) { unsigned count; if (app->clock == NULL) { return true; } for (count = 0U; count < EXAMPLE_EVENT_BUDGET; ++count) { IEC104_ClockSynchronizationExecuteResult_t result = IEC104_ClockSynchronization_Execute_Next_With_Read(app->clock, Example_Clock_Action, Example_Clock_Read, app); /* 不在回调内跨模块调用。READ不会置pending;确认WAIT或丢失也不撤销已成功SET的基准。 * setter失败交上层清理,不重新设时,也不能用执行返回OK或旧valid替代这个标志。 */ if (app->clock_update_pending) { if (app->energy != NULL && !Example_Energy_Meter_Set_Epoch(app->energy_meter, app->clock_base_ms, app->clock_utc_ms)) { return false; } if (app->command != NULL && !IEC104_Command_Set_Time_Base(app->command, app->clock_utc_ms, app->clock_base_ms)) { return false; } if (!IEC104_Spontaneous_Set_Time_Base(app->spontaneous, app->clock_utc_ms, app->clock_base_ms, true)) { return false; } app->clock_update_pending = false; } if (result == IEC104_CLOCK_SYNCHRONIZATION_EXECUTE_EMPTY || result == IEC104_CLOCK_SYNCHRONIZATION_EXECUTE_WAIT) { return true; } if (result != IEC104_CLOCK_SYNCHRONIZATION_EXECUTE_OK) { return false; } } return true; } /* ============================================================================ * [CLOCK/STEP] 校时步进:确认提交、动作执行与状态刷新 * ============================================================================ */ /** * 功能:先重试旧确认,再执行本轮允许的新动作;执行结果与提交状态由末尾快照统一反映。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。 * 说明:已取样的读回复同样由Process重试;read_pending变false不表示该回复已被HIGH接手。 * 此包装不等待网络ACK,也不以其他业务是否排空作为执行条件。 */ static bool Example_Step_Clock(ExampleApp *app) { return app->clock == NULL || (IEC104_ClockSynchronization_Process(app->clock) && Example_Drain_Clock(app) && IEC104_ClockSynchronization_Get_Status(app->clock, &app->cs)); } /* ============================================================================ * [COMMAND/POINTS] 遥控配置:逐点类型、直接执行与选择执行策略 * ============================================================================ */ /** * 功能:为命令行示例创建遥控实例,与仅总召的初始化入口分开。 * 输入参数:app——非NULL,Slave句柄和站点已创建,尚未开始消费Slave通知。 * extensions——仅控制是否追加无S/E字段的51/64位串演示,不改变其他点的选择执行策略。 * 输出参数:成功后保存app->command;失败不创建可用实例。 * 返回值:true为创建成功;false为重复初始化、配置/归属错误或静态池没有空位。 * 说明:默认启用45/46/47/49及对应时标类型的32个选择执行点;extensions另启用8个51/64位串点。 * 点表归app所有,只在Create前填充,Destroy之前禁止移动app、修改或释放点表。 * 每Slave只能绑定一个Command。main在Slave_Init前创建亦可,但必须早于首条生命周期通知。 */ static bool Example_Init_Command_Mode(ExampleApp *app, bool extensions) { IEC104_CommandConfig_t config; uint16_t common_address = IEC104_Station_Get_Common_Address(&app->station); #ifdef IEC104_EXAMPLE_DTU_PROFILE IEC104_CommandPoint_t points[EXAMPLE_COMMAND_COUNT]; size_t cursor, group, index; for (cursor = 0U; cursor < DTU_COMMAND_COUNT; ++cursor) { IEC104_CommandPoint_t *point = &points[cursor]; bool dual = cursor >= 1U && cursor <= 16U; point->common_address = common_address; point->ioa = dtu_commands[cursor].ioa; point->type_mask = dual ? IEC104_COMMAND_TYPE_BIT(46U) | IEC104_COMMAND_TYPE_BIT(59U) : IEC104_COMMAND_TYPE_BIT(45U) | IEC104_COMMAND_TYPE_BIT(58U); point->mode = IEC104_COMMAND_MODE_SELECT_EXECUTE; } for (group = 1U; group < sizeof(example_command_groups) / sizeof(example_command_groups[0]); ++group) { for (index = 0U; index < example_command_groups[group].count; ++index) { IEC104_CommandPoint_t *point = &points[cursor++]; point->common_address = common_address; point->ioa = example_command_groups[group].first_ioa + (uint32_t)index; point->type_mask = example_command_groups[group].type_mask; point->mode = group == 3U ? IEC104_COMMAND_MODE_DIRECT : IEC104_COMMAND_MODE_SELECT_EXECUTE; } } #else /* 每行独立指定策略;默认32个带S/E点均要求选择成功后执行或撤销。 * 使用实际站点CA以保留--ca;局部表只用于初始化,Create借用app中的持久副本。 */ const IEC104_CommandPoint_t points[] = { /* CA IOA 允许类型 执行方式 */ {common_address, EXAMPLE_IOA_COMMAND_SINGLE_BASE, IEC104_COMMAND_TYPE_BIT(45U) | IEC104_COMMAND_TYPE_BIT(58U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_SINGLE_BASE + 1U), IEC104_COMMAND_TYPE_BIT(45U) | IEC104_COMMAND_TYPE_BIT(58U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_SINGLE_BASE + 2U), IEC104_COMMAND_TYPE_BIT(45U) | IEC104_COMMAND_TYPE_BIT(58U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_SINGLE_BASE + 3U), IEC104_COMMAND_TYPE_BIT(45U) | IEC104_COMMAND_TYPE_BIT(58U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_SINGLE_BASE + 4U), IEC104_COMMAND_TYPE_BIT(45U) | IEC104_COMMAND_TYPE_BIT(58U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_SINGLE_BASE + 5U), IEC104_COMMAND_TYPE_BIT(45U) | IEC104_COMMAND_TYPE_BIT(58U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_SINGLE_BASE + 6U), IEC104_COMMAND_TYPE_BIT(45U) | IEC104_COMMAND_TYPE_BIT(58U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_SINGLE_BASE + 7U), IEC104_COMMAND_TYPE_BIT(45U) | IEC104_COMMAND_TYPE_BIT(58U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, EXAMPLE_IOA_COMMAND_DOUBLE_BASE, IEC104_COMMAND_TYPE_BIT(46U) | IEC104_COMMAND_TYPE_BIT(59U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_DOUBLE_BASE + 1U), IEC104_COMMAND_TYPE_BIT(46U) | IEC104_COMMAND_TYPE_BIT(59U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_DOUBLE_BASE + 2U), IEC104_COMMAND_TYPE_BIT(46U) | IEC104_COMMAND_TYPE_BIT(59U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_DOUBLE_BASE + 3U), IEC104_COMMAND_TYPE_BIT(46U) | IEC104_COMMAND_TYPE_BIT(59U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_DOUBLE_BASE + 4U), IEC104_COMMAND_TYPE_BIT(46U) | IEC104_COMMAND_TYPE_BIT(59U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_DOUBLE_BASE + 5U), IEC104_COMMAND_TYPE_BIT(46U) | IEC104_COMMAND_TYPE_BIT(59U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_DOUBLE_BASE + 6U), IEC104_COMMAND_TYPE_BIT(46U) | IEC104_COMMAND_TYPE_BIT(59U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_DOUBLE_BASE + 7U), IEC104_COMMAND_TYPE_BIT(46U) | IEC104_COMMAND_TYPE_BIT(59U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, /* 升降:全部点先选择后执行;47与60共用当前位置和执行模式。 * 选择只保留操作意图,真正升降发生在EXECUTE,限位检查不能只做在选择阶段。 */ {common_address, EXAMPLE_IOA_COMMAND_STEP_BASE, IEC104_COMMAND_TYPE_BIT(47U) | IEC104_COMMAND_TYPE_BIT(60U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_STEP_BASE + 1U), IEC104_COMMAND_TYPE_BIT(47U) | IEC104_COMMAND_TYPE_BIT(60U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_STEP_BASE + 2U), IEC104_COMMAND_TYPE_BIT(47U) | IEC104_COMMAND_TYPE_BIT(60U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_STEP_BASE + 3U), IEC104_COMMAND_TYPE_BIT(47U) | IEC104_COMMAND_TYPE_BIT(60U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_STEP_BASE + 4U), IEC104_COMMAND_TYPE_BIT(47U) | IEC104_COMMAND_TYPE_BIT(60U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_STEP_BASE + 5U), IEC104_COMMAND_TYPE_BIT(47U) | IEC104_COMMAND_TYPE_BIT(60U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_STEP_BASE + 6U), IEC104_COMMAND_TYPE_BIT(47U) | IEC104_COMMAND_TYPE_BIT(60U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_STEP_BASE + 7U), IEC104_COMMAND_TYPE_BIT(47U) | IEC104_COMMAND_TYPE_BIT(60U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, EXAMPLE_IOA_COMMAND_SETPOINT_BASE, IEC104_COMMAND_TYPE_BIT(49U) | IEC104_COMMAND_TYPE_BIT(62U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_SETPOINT_BASE + 1U), IEC104_COMMAND_TYPE_BIT(49U) | IEC104_COMMAND_TYPE_BIT(62U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_SETPOINT_BASE + 2U), IEC104_COMMAND_TYPE_BIT(49U) | IEC104_COMMAND_TYPE_BIT(62U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_SETPOINT_BASE + 3U), IEC104_COMMAND_TYPE_BIT(49U) | IEC104_COMMAND_TYPE_BIT(62U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_SETPOINT_BASE + 4U), IEC104_COMMAND_TYPE_BIT(49U) | IEC104_COMMAND_TYPE_BIT(62U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_SETPOINT_BASE + 5U), IEC104_COMMAND_TYPE_BIT(49U) | IEC104_COMMAND_TYPE_BIT(62U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_SETPOINT_BASE + 6U), IEC104_COMMAND_TYPE_BIT(49U) | IEC104_COMMAND_TYPE_BIT(62U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, {common_address, (EXAMPLE_IOA_COMMAND_SETPOINT_BASE + 7U), IEC104_COMMAND_TYPE_BIT(49U) | IEC104_COMMAND_TYPE_BIT(62U), IEC104_COMMAND_MODE_SELECT_EXECUTE}, /* 位串:51/64的载荷没有S/E字段,所有点必须DIRECT;不能配置为先选择后执行。 * 每个IOA表示一个完整32位值,不拆成32个单点命令。 */ {common_address, EXAMPLE_IOA_COMMAND_BITSTRING_BASE, IEC104_COMMAND_TYPE_BIT(51U) | IEC104_COMMAND_TYPE_BIT(64U), IEC104_COMMAND_MODE_DIRECT}, {common_address, (EXAMPLE_IOA_COMMAND_BITSTRING_BASE + 1U), IEC104_COMMAND_TYPE_BIT(51U) | IEC104_COMMAND_TYPE_BIT(64U), IEC104_COMMAND_MODE_DIRECT}, {common_address, (EXAMPLE_IOA_COMMAND_BITSTRING_BASE + 2U), IEC104_COMMAND_TYPE_BIT(51U) | IEC104_COMMAND_TYPE_BIT(64U), IEC104_COMMAND_MODE_DIRECT}, {common_address, (EXAMPLE_IOA_COMMAND_BITSTRING_BASE + 3U), IEC104_COMMAND_TYPE_BIT(51U) | IEC104_COMMAND_TYPE_BIT(64U), IEC104_COMMAND_MODE_DIRECT}, {common_address, (EXAMPLE_IOA_COMMAND_BITSTRING_BASE + 4U), IEC104_COMMAND_TYPE_BIT(51U) | IEC104_COMMAND_TYPE_BIT(64U), IEC104_COMMAND_MODE_DIRECT}, {common_address, (EXAMPLE_IOA_COMMAND_BITSTRING_BASE + 5U), IEC104_COMMAND_TYPE_BIT(51U) | IEC104_COMMAND_TYPE_BIT(64U), IEC104_COMMAND_MODE_DIRECT}, {common_address, (EXAMPLE_IOA_COMMAND_BITSTRING_BASE + 6U), IEC104_COMMAND_TYPE_BIT(51U) | IEC104_COMMAND_TYPE_BIT(64U), IEC104_COMMAND_MODE_DIRECT}, {common_address, (EXAMPLE_IOA_COMMAND_BITSTRING_BASE + 7U), IEC104_COMMAND_TYPE_BIT(51U) | IEC104_COMMAND_TYPE_BIT(64U), IEC104_COMMAND_MODE_DIRECT} }; _Static_assert(sizeof(points) == sizeof(app->command_points), "Command point table size mismatch"); #endif if (app->command != NULL) { return false; } IEC104_Command_Config_Default(&config); /* 本例对收到即过期、等待决定后过期的命令都安排否定COT49,便于主站明确结束请求。 * 保留动作前时标复查;决定期限15s不保证时标窗口10s内受理的命令始终可执行。 * 与库默认策略一致;实际设备须与主站约定迟到否定及重试的处理方式。 */ config.negative_on_expired = true; /* 执行收尾固定:成功/失败都先Report_Result再Complete,分别产生肯定/否定TERM。 * 未报告结果即执行超时则由模块安排否定TERM,不关闭TCP,也不再等待应用Complete。 * 超时只表示命令服务未确认成功,设备结果仍未知;真实设备须自行维护忙状态,不能重做动作。 */ /* 本例按实施细则将选择有效期设为60000ms。 * 主站自动选择后紧接执行时,可在此设置config.select_timeout_ms = 10000U, * 最终值须覆盖主站操作间隔与确认发送/通信/调度余量,并与主站约定。 * 此期限由所有选择执行点共用,匹配执行到达即可进入下一阶段,不必等满; * 等待期间占唯一事务槽。它与time_tag_max_delay_ms的时标校验窗口独立。 */ /* 全局掩码决定Command接管哪些类型,逐点掩码再限制该IOA允许的类型,二者取交集。 * Config_Default默认全部启用,这里用赋值裁剪;只增点表而漏掉全局位仍会走44兜底。 */ config.type_mask = IEC104_COMMAND_TYPE_BIT(45U) | IEC104_COMMAND_TYPE_BIT(46U) | IEC104_COMMAND_TYPE_BIT(47U) | IEC104_COMMAND_TYPE_BIT(49U) | IEC104_COMMAND_TYPE_BIT(51U) | IEC104_COMMAND_TYPE_BIT(58U) | IEC104_COMMAND_TYPE_BIT(59U) | IEC104_COMMAND_TYPE_BIT(60U) | IEC104_COMMAND_TYPE_BIT(62U) | IEC104_COMMAND_TYPE_BIT(64U); memcpy(app->command_points, points, sizeof(points)); config.points = app->command_points; config.point_count = sizeof(points) / sizeof(points[0]); config.select_timeout_ms = 60000U; if (!extensions) { /* 位串块必须保持在点表末尾;同时裁剪类型许可和可见点数,避免只关类型却留下扩展点。 * 仅缩短Create借用的范围,不移动app内点表;重排分组时须同步检查这里的尾部裁剪。 */ config.type_mask &= (uint16_t)~(IEC104_COMMAND_TYPE_BIT(51U) | IEC104_COMMAND_TYPE_BIT(64U)); config.point_count -= EXAMPLE_BITSTRING_COUNT; } app->command = IEC104_Command_Create(app->slave, &config); return app->command != NULL; } /** * 功能:默认入口只注册选择执行点;CLI显式选择扩展时才调用上面的Mode入口启用51/64。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:无。 */ static bool Example_Init_Command(ExampleApp *app) { return Example_Init_Command_Mode(app, false); } /* ============================================================================ * [COMMAND/ACTION] 遥控与遥调:点号映射、动作结果及返回信息 * ============================================================================ */ /** * 功能:将带时标命令类型映射为对应的基础命令类型。 * 输入参数:type——信息对象或日志类型标识。 * 输出参数:无独立输出参数。 * 返回值:去除时标差异后的基础命令类型。 * 说明:58..64与45..51逐项相差13,折回基础类型仅用于应用动作及监视类型分派。 * 时标解析/时效检查由Command完成;原请求type_id和CP56仍由库保存并用于确认回显。 */ static uint8_t Example_Command_Base_Type(uint8_t type) { return type >= 58U && type <= 64U ? (uint8_t)(type - 13U) : type; } /** * 功能:把示例支持的遥控命令地址映射为对应运行值数组的下标。 * 输入参数:request——非NULL的已解码45/46/47/49/51或对应带时标工作请求,仅借用。 * 输出参数:index——非NULL,仅true时可用;DTU单点映射失败可能写入容量哨兵。 * 返回值:true表示当前配置点表中存在该类型命令的应用映射。 * 说明:库已按应用提供的点表校验CA/IOA/类型/模式,此处仍核对应用映射,避免动作写错运行值。 * 通用入口按8点组映射。DTU单点映射见本函数,16个开关及扩展控制按命令组表映射; * 业务IOA与源XML参数地址不同,不能把0x98xx点表参数地址直接交给遥控。 */ static bool Example_Command_Point(const IEC104_CommandRequest_t *request, size_t *index) { size_t group; #ifdef IEC104_EXAMPLE_DTU_PROFILE if (Example_Command_Base_Type(request->type_id) == 45U) { uint32_t ioa = request->ioa == 0x6001U ? 0x0009U : (request->ioa == 0x6012U ? 0x0018U : (request->ioa == 0x6013U ? 0x0026U : 0U)); *index = Example_Dtu_Signal_Index(ioa); return *index < EXAMPLE_SIGNAL_COUNT; } #endif for (group = 0U; group < sizeof(example_command_groups) / sizeof(example_command_groups[0]); ++group) { uint32_t first = example_command_groups[group].first_ioa; /* 先检查类型及下界,再做无符号差值检查,避免未知地址下溢后被当作数组下标。 */ if ((example_command_groups[group].type_mask & IEC104_COMMAND_TYPE_BIT(request->type_id)) != 0U && request->ioa >= first && request->ioa - first < example_command_groups[group].count) { *index = (size_t)(request->ioa - first); return true; } } return false; } /** * 功能:检查已解码命令的限定词是否属于本例实现的设备动作,仅读取request。 * 输入参数:request——非NULL,来自Command工作事件或动作回调,基础/时标类型采用相同策略。 * 输出参数:无独立输出参数。 * 返回值:true允许进入后续值检查;false由调用方拒绝,函数本身不应答、不改设备值。 * 说明:单/双点只模拟持续输出QU=0/3;升降QU=0约定每次执行一步,拒绝QU=1/2/3。 * 设定值只支持QL=0;位串没有限定词或S/E,库只交付直接执行。 * TEST不生成应用工作事件,不经过本检查;测试肯定只说明协议流程受理。 */ static bool Example_Command_Qualifier_Allowed(const IEC104_CommandRequest_t *request) { uint8_t type = Example_Command_Base_Type(request->type_id); if (type == 45U || type == 46U) { return request->qualifier == 0U || request->qualifier == 3U; } return type == 51U || ((type == 47U || type == 49U) && request->qualifier == 0U); } /** * 功能:按当前设备值检查本次操作是否在示例允许范围内,不计算或写回最终值。 * 输入参数:app/request——非NULL;index——已由Example_Command_Point校验的同类运行值下标。 * 输出参数:无独立输出参数。 * 返回值:true为可执行;false为升降方向非法、已到该方向限位或标度设定值越限。 * 说明:升降state=1降一档、2升一档;使用当前位置检查下一步,不把state当作目标档位。 * SELECT、EXECUTE及动作入口均检查,选择成功后的位置变化不能绕过执行时限位。 * 位串使用uint32_t完整值域,无额外数值限幅;这些检查不是设备闭锁或现场保护判据。 */ static bool Example_Command_Value_Allowed(const ExampleApp *app, const IEC104_CommandRequest_t *request, size_t index) { #ifdef IEC104_EXAMPLE_DTU_PROFILE /* 软压板只约束开关分合命令。 */ if (Example_Command_Base_Type(request->type_id) == 46U) { if (app->dtu_digital[0x4AU] == 0U || app->dtu_digital[0x24U] != 0U || app->dtu_pulse_until[index] > IEC104_Net_Now_Ms()) { return false; } if (index == 0U && request->state == 2U && (app->dtu_protection_output.close_blocked || app->dtu_digital[0x22U] != 0U || app->dtu_digital[0x23U] != 0U || app->dtu_digital[0x5CU] != 0U)) { return false; } } #endif if (Example_Command_Base_Type(request->type_id) == 47U) { return (request->state == 1U && app->step_values[index] > EXAMPLE_STEP_MIN) || (request->state == 2U && app->step_values[index] < EXAMPLE_STEP_MAX); } return Example_Command_Base_Type(request->type_id) != 49U || (request->value.scaled >= EXAMPLE_SCALED_MIN && request->value.scaled <= EXAMPLE_SCALED_MAX); } /** * 功能:执行已通过Accept校验并消费的选择/执行动作,仅修改模拟设备状态。 * 输入参数:context——当前ExampleApp;request——库仅在本次回调期间借出的工作请求,不得保存指针。 * 输出参数:选择置返校标志;执行置输出标志并更新对应运行值,供返回信息和监视量读取。 * 返回值:NOT_STARTED表示动作未开始,STARTED表示已接受执行;测试构建可由EXAMPLE_COMMAND_ACTION_RESULT注入动作结果。 * 说明:STARTED表示选择生效或输出启动,不代替Report_Result。真实异步驱动应在设备完成后报告结果。 * 不在动作中发布任何上报、推进Slave或重入修改Command;库不保存本函数或context。 */ static IEC104_CommandActionResult_t Example_Command_Action(void *context, const IEC104_CommandRequest_t *request) { ExampleApp *app = (ExampleApp *)context; size_t index; uint8_t type = Example_Command_Base_Type(request->type_id); /* 决定阶段先拒绝不支持的操作;动作入口再次守卫,确保任何副作用之前范围仍有效。 */ if (!Example_Command_Point(request, &index) || !Example_Command_Qualifier_Allowed(request) || !Example_Command_Value_Allowed(app, request, index)) { return IEC104_COMMAND_ACTION_NOT_STARTED; } if (request->is_select) { app->command_selected = true; } else { IEC104_SpontaneousChange_t *change = &app->command_change; app->command_output = true; memset(change, 0, sizeof(*change)); change->common_address = request->common_address; change->station_id = request->station_id; change->time_kind = IEC104_SPONTANEOUS_TIME_MONOTONIC; change->time_ms = IEC104_Net_Now_Ms(); /* 同步模拟动作的值与时刻在本回调内配对保存;COT11不借用主站命令中的时标。 * 接入异步设备时,应由实际反馈快照给出动作值及采集时刻,不能用排队或重试时刻替代。 */ Example_Monitor_Time(app, change->time_ms, &app->command_action_time); app->command_action_called = true; if (type == 45U) { uint8_t state = request->state; #ifdef IEC104_EXAMPLE_DTU_PROFILE if (request->ioa == 0x6012U) { state = 0U; } #endif change->ioa = example_signals[index].ioa; change->kind = IEC104_SPONTANEOUS_SINGLE; change->value.single = state; app->command_has_change = app->signal_values[index] != state; #ifndef IEC104_EXAMPLE_DTU_PROFILE app->signal_values[index] = state; #endif #ifdef IEC104_EXAMPLE_DTU_PROFILE if (request->ioa == 0x6001U) { app->dtu_activation = request->state != 0U; app->dtu_activation_since = change->time_ms; if (app->dtu_activation) { app->dtu_activation_scheduled = false; } app->dtu_digital[2U] = app->dtu_activation; } if (request->ioa == 0x6013U) { app->dtu_digital[0x4AU] = state; } /* 复归整个保护状态;仍存在的故障在后续采样重新计时。 */ if (request->ioa == 0x6012U && request->state != 0U) { size_t source; Dtu_Protection_Reset(&app->dtu_protection); /* 保留上一有效采样的合闸许可,复归不绕过仍存在的闭锁条件。 */ for (source = 1U; source < DTU_PROTECTION_SIGNAL_COUNT; ++source) { if (Dtu_Protection_Indicator_Source((uint16_t)(0x9140U + source)) || source == 0x4BU || source == 0x4CU) { app->dtu_digital[source] = 0U; } } app->signal_values[index] = 0U; change->value.single = 0U; } Example_Dtu_Update_Digital(app, change->time_ms); { uint16_t source = dtu_signals[index].source_addr; change->value.single = state ^ (dtu_setting(app, source + 0xCC0U, 0.0) != 0.0); app->command_has_change = app->signal_values[index] != change->value.single; app->dtu_command_due_ms = change->time_ms + (uint64_t)(dtu_setting(app, 0x802BU, 0.02) * 1000.0 + 0.5); } #endif } else if (type == 46U) { change->ioa = (uint32_t)(EXAMPLE_IOA_DOUBLE_BASE + index); change->kind = IEC104_SPONTANEOUS_DOUBLE; change->value.double_point = request->state; app->command_has_change = app->double_values[index] != request->state; app->double_values[index] = request->state; #ifdef IEC104_EXAMPLE_DTU_PROFILE app->dtu_pulse_until[index] = change->time_ms + (uint64_t)(dtu_setting(app, request->state == 2U ? 0x802DU : 0x802CU, 0.15) * 1000.0 + 0.5); app->dtu_command_due_ms = app->dtu_pulse_until[index]; /* 仅00开关另有分/合单点反馈;电流及P/Q在下一次field采样随分闸归零。 */ if (index == 0U) { app->dtu_digital[0x1FU] = request->state == 2U; app->dtu_digital[0x20U] = request->state == 1U; if (request->state == 1U) { Dtu_Protection_Cancel_Reclose(&app->dtu_protection, change->time_ms); } Example_Dtu_Update_Digital(app, change->time_ms); } #endif } else if (type == 47U) { /* 通过限位检查后只移动一档;同步模拟完成,change清零留下transient=false及好品质。 * 网络WAIT只重试协议应答,不得通过重调动作来推进档位。 */ change->ioa = (uint32_t)(EXAMPLE_IOA_STEP_BASE + index); change->kind = IEC104_SPONTANEOUS_STEP; app->step_values[index] = (int8_t)(app->step_values[index] + (request->state == 1U ? -1 : 1)); change->value.step.value = app->step_values[index]; app->command_has_change = true; } else if (type == 51U) { /* 整字替换而非按位OR,写0必须清掉旧位;使用无符号类型保留bit31。 * 相同值仍完成命令/返回,但has_change=false防止取消或断连后补报虚构变化。 */ change->ioa = (uint32_t)(EXAMPLE_IOA_BITSTRING_BASE + index); change->kind = IEC104_SPONTANEOUS_BITSTRING; change->value.bitstring = request->value.bitstring; app->command_has_change = app->bitstring_values[index] != request->value.bitstring; app->bitstring_values[index] = request->value.bitstring; } else { int16_t previous = app->scaled_values[index]; uint8_t quality = Example_Measurement_Quality(app, index); Example_Set_Measurement(app, index, request->value.scaled); change->ioa = example_measurements[index].ioa; change->kind = IEC104_SPONTANEOUS_SCALED; change->value.scaled = app->scaled_values[index]; change->quality = Example_Measurement_Quality(app, index); app->command_has_change = previous != change->value.scaled || quality != change->quality; } return EXAMPLE_COMMAND_ACTION_RESULT(app); } return IEC104_COMMAND_ACTION_STARTED; } /** * 功能:为已启动的当前EXECUTE构造一帧COT=11的模拟位置返回信息,此处只组包,不提交。 * 输入参数:app——非NULL,command_event保留当前EXECUTE身份,运行值已由动作更新。 * 输出参数:app->command_return及其固定17字节缓冲,CA/OA沿用工作请求,IOA映射到对应监视量。 * 返回值:true为Type30/31/5/7/11单对象ASDU构造成功;false为点表或编解码失败,此时不可提交该ASDU。 * 说明:TEST命令由协议层模拟且不交付应用动作,本入口只处理真实命令,TEST=0。 * 遥测使用当时的处理值和量程品质;测试确认不构造假的设备位置变化。 * 47/60返回Type5的当前档位,51/64返回Type7的完整位串;监视IOA与命令IOA分开。 * 单/双点返回使用动作时冻结的值与CP56;命令原CP56仅随确认/终止回显。 * 即使当前点值随后变化,COT11仍反馈这次动作快照;查询最新状态应走Read或总召。 * 局部信息对象由ASDU编码复制,离开函数不借用局部变量;ASDU仍借用app内固定字节缓冲。 * 成功后冻结这一帧,Submit_Return_Info的WAIT不重新组包;只有OK才可推进,避免同一变位重复上报。 */ static bool Example_Build_Command_Return(ExampleApp *app) { const IEC104_CommandRequest_t *request = &app->command_event.request; IEC60870_AsduHeader_t header; size_t index; uint8_t type = Example_Command_Base_Type(request->type_id); if (!Example_Command_Point(request, &index)) { return false; } memset(&header, 0, sizeof(header)); header.cause_of_transmission = IEC60870_ASDU_COT_RETURN_INFO_REMOTE; header.common_address = request->common_address; header.originator_address = request->originator_address; if (IEC60870_Asdu_Create(&app->command_return, IEC104_Slave_Get_Application_Layer_Parameters(app->slave), app->command_return_bytes, sizeof(app->command_return_bytes), &header, 0) != IEC60870_ASDU_OK) { return false; } if (type == 45U) { IEC60870_SinglePointWithCP56Time2a_t point; return IEC60870_SinglePointWithCP56Time2a_Create(&point, example_signals[index].ioa, app->command_change.value.single, 0U, &app->command_action_time) == IEC60870_ASDU_OK && IEC60870_Asdu_Add_InformationObject(&app->command_return, &point.base.object) == IEC60870_ASDU_OK; } else if (type == 46U) { IEC60870_DoublePointWithCP56Time2a_t point; return IEC60870_DoublePointWithCP56Time2a_Create(&point, (uint32_t)(EXAMPLE_IOA_DOUBLE_BASE + index), app->command_change.value.double_point, 0U, &app->command_action_time) == IEC60870_ASDU_OK && IEC60870_Asdu_Add_InformationObject(&app->command_return, &point.base.object) == IEC60870_ASDU_OK; } else if (type == 47U) { IEC60870_StepPositionInformation_t point; /* VTI由公共编码器按有符号7位编码;同步到位,暂态和QDS均为0。 */ return IEC60870_StepPositionInformation_Create(&point, (uint32_t)(EXAMPLE_IOA_STEP_BASE + index), app->step_values[index], 0U, 0U) == IEC60870_ASDU_OK && IEC60870_Asdu_Add_InformationObject(&app->command_return, &point.object) == IEC60870_ASDU_OK; } else if (type == 51U) { IEC60870_BitString32_t point; /* 公共编码器负责BSI小端字节序;监视对象比命令的4字节位串多1字节QDS。 */ return IEC60870_BitString32_Create(&point, (uint32_t)(EXAMPLE_IOA_BITSTRING_BASE + index), app->bitstring_values[index], 0U) == IEC60870_ASDU_OK && IEC60870_Asdu_Add_InformationObject(&app->command_return, &point.object) == IEC60870_ASDU_OK; } else { ExampleMeasurementObject point; return Example_Create_Measurement(&point, example_measurements[index].ioa, app->scaled_values[index], Example_Measurement_Quality(app, index)) == IEC60870_ASDU_OK && IEC60870_Asdu_Add_InformationObject(&app->command_return, &point.object) == IEC60870_ASDU_OK; } } /** * 功能:消费遥控业务事件、处理应用决定,并推进结果报告/返回信息/Complete的持久化步骤。 * 输入参数:app——非NULL,所属Slave通知须先按FIFO分派;command可为NULL以兼容仅总召测试。 * 输出参数:更新应用持有事件、站点引用、模拟标志和重试步骤;不替代Command_Process提交协议应答。 * 返回值:true为本轮处理完成或遇到正常WAIT/STALE;false为事件身份、引用或接口/组包错误。 * 说明:先读取业务事件再重试旧交互,使STOP、断线、撤销产生的FINISHED能先清理过期步骤。 * 一个事务可能交付SELECT后再交付EXECUTE,但只持有一个应用站点引用,最后恰好按FINISHED清理。 * FINISHED不回滚设备值;本例动作同步完成,可直接清除模拟标志并Release。真实输出未结束时, * 应用须另存设备操作及站点引用,保持设备忙状态,不能照搬本例的立即释放。 */ static bool Example_Drain_Command(ExampleApp *app) { unsigned count; if (app->command == NULL) { return true; } for (count = 0U; count < EXAMPLE_EVENT_BUDGET; ++count) { IEC104_CommandEvent_t event; IEC104_CommandNextResult_t next = IEC104_Command_NextEvent(app->command, &event); if (next == IEC104_COMMAND_NEXT_EMPTY) { break; } if (next != IEC104_COMMAND_NEXT_READY) { return false; } if (event.type == IEC104_COMMAND_FINISHED) { /* 撤销以实际交付的停用终结事件记一次;超时、断线等其他终结原因不冒充撤销操作。 */ if (event.reason == IEC104_COMMAND_FINISH_DEACTIVATED && !Example_History_Command(app, &event.request, IEC60870_HISTORY_CANCEL, IEC104_Net_Now_Ms())) { return false; } /* 只清理当前应用持有的事务,不能让旧实例/旧事务的终结通知释放另一次输出资源。 * 执行超时的FINISHED可先于否定TERM交接,清理应用步骤后仍须继续推进Command_Process。 * 模块槽可能仍因最后应答WAIT而占用;应用读到FINISHED也不能据此强行发起新动作。 */ if (event.instance_id != app->command_instance || event.transaction_id != app->command_transaction) { return false; } if (!Example_Resolve_Publication(app, event.instance_id, event.transaction_id, event.return_info_undelivered)) { return false; } if (event.select_effect) { app->command_selected = false; } if (event.execute_effect) { app->command_output = false; } if (app->command_station != NULL && IEC104_Slave_Release_Station(app->slave, app->command_station) != IEC104_STATION_OK) { return false; } app->command_station = NULL; app->command_instance = app->command_transaction = 0U; app->command_pending = app->command_waiting = false; app->command_step = 0U; #ifdef IEC104_EXAMPLE_DTU_PROFILE app->dtu_command_due_ms = 0U; #endif } else { /* 选择与执行在业务事件首次取出时保存,后续动作/应答 WAIT 重试不再次记操作。 */ if (!Example_History_Command(app, &event.request, event.type == IEC104_COMMAND_SELECT ? IEC60870_HISTORY_SELECT : IEC60870_HISTORY_OPER, event.request.accepted_ms)) { return false; } if (app->command_transaction == 0U) { /* 先按注册编号找到原站并Acquire,再保存引用及事务身份;同CA重新注册不能替代原站。 * 模块自身的引用可能在FINISHED出队时释放,不能借它维持应用context的生命周期。 */ IEC104_Station_t *station = IEC104_Slave_Get_Station_By_Id(app->slave, event.request.station_id); if (station == NULL || IEC104_Slave_Acquire_Station(app->slave, station) != IEC104_STATION_OK) { return false; } app->command_station = station; app->command_instance = event.instance_id; app->command_transaction = event.transaction_id; } else if (app->command_instance != event.instance_id || app->command_transaction != event.transaction_id || app->command_pending) { return false; } /* 按值保存,不持有NextEvent局部变量的地址;匹配执行覆盖工作事件,继续保留同一站点引用。 */ app->command_event = event; app->command_pending = true; app->command_waiting = false; } } if (app->command_pending) { IEC104_CommandReplyResult_t reply; size_t index; app->command_action_called = app->command_has_change = false; /* 库已查命令点表;应用仍核对原站context和运行值映射,不借用另一个站点的设备状态。 */ if (IEC104_Station_Get_Context(app->command_station) != app || !Example_Command_Point(&app->command_event.request, &index)) { reply = IEC104_Command_Reject(app->command, &app->command_event, IEC104_COMMAND_REJECT_UNKNOWN_IOA); } else if (!Example_Command_Qualifier_Allowed(&app->command_event.request) || !Example_Command_Value_Allowed(app, &app->command_event.request, index)) { reply = IEC104_Command_Reject(app->command, &app->command_event, IEC104_COMMAND_REJECT_NEGATIVE); } else { reply = IEC104_Command_Accept(app->command, &app->command_event, Example_Command_Action, app); } /* Accept may finish a failed action or observe a disconnection after * the callback. Preserve its actual side effect before inspecting state. */ if (app->command_action_called) { ExamplePublication entry; memset(&entry, 0, sizeof(entry)); entry.change = app->command_change; if (app->parameter != NULL && entry.change.kind == IEC104_SPONTANEOUS_SCALED) { entry.measurement_range = app->measurements[entry.change.ioa - EXAMPLE_IOA_MEASUREMENT_BASE].range; } entry.instance_id = app->command_instance; entry.transaction_id = app->command_transaction; entry.placeholder = true; entry.has_change = app->command_has_change; /* 实际发生的返回点变位在首次动作后保存;占位解锁和补报重试只处理发送,不重复落历史。 */ if (entry.has_change && !Example_History_Change(app, &entry.change)) { return false; } if (!Example_Queue_Publication(app, &entry)) { return false; } } app->command_waiting = reply == IEC104_COMMAND_REPLY_WAIT; /* WAIT未消费工作事件、未调用动作;保留身份,下轮先处理Slave通知再重试。 * STALE不再重交动作,只保留事务归属等待FINISHED;OK也仅表示事件被消费。 */ if (app->command_waiting) { return true; } if (reply != IEC104_COMMAND_REPLY_OK && reply != IEC104_COMMAND_REPLY_STALE) { return false; } app->command_pending = false; if (reply == IEC104_COMMAND_REPLY_OK && app->command_event.type == IEC104_COMMAND_EXECUTE) { IEC104_CommandTransactionInfo_t info; /* Reject和动作NOT_STARTED/FAILED也可能返回OK,必须确认仍为EXECUTING才能报告设备结果。 * 返回信息此时可先构造;Submit_Return_Info须等肯定执行确认被接手,HIGH FIFO保持事务帧序。 */ if (IEC104_Command_Get_Transaction(app->command, &app->command_event, &info) && info.active && info.phase == IEC104_COMMAND_PHASE_EXECUTING) { if (!Example_Build_Command_Return(app)) { return false; } app->command_step = 1U; } } } /* 模拟动作已经完成,先报告结果停止执行计时;确认是否已交接不影响本次报告。 * Report_Result只记录结果:成功可先交接返校,明确失败跳过返校,两者都由Complete封口。 * 每轮至多推进三个步骤。每步仅OK后递增;返回信息OK已经固定帧序,不能因Complete等待而重发。 */ for (count = 0U; count < 3U && app->command_step != 0U; ++count) { IEC104_CommandReplyResult_t reply; if (app->command_step == 1U) { #ifdef IEC104_EXAMPLE_DTU_PROFILE if (app->dtu_command_due_ms > IEC104_Net_Now_Ms()) { app->command_waiting = true; return true; } app->dtu_command_due_ms = 0U; #endif IEC104_CommandResult_t device_result = EXAMPLE_COMMAND_DEVICE_RESULT(app); reply = IEC104_Command_Report_Result(app->command, &app->command_event, device_result); if (reply == IEC104_COMMAND_REPLY_OK && device_result == IEC104_COMMAND_RESULT_FAILED) { app->command_step = 3U; continue; /* 已知失败仍须Complete,随后等待否定TERM交接及FINISHED。 */ } } else if (app->command_step == 2U) { reply = IEC104_Command_Submit_Return_Info(app->command, &app->command_event, &app->command_return); if (reply == IEC104_COMMAND_REPLY_OK) { if (!Example_Accept_Publication(app)) { return false; } } } else { reply = IEC104_Command_Complete(app->command, &app->command_event); } app->command_waiting = reply == IEC104_COMMAND_REPLY_WAIT; /* WAIT保持当前步骤及完整ASDU;STALE停止后续提交,引用与模拟标志交给FINISHED统一清理。 * Complete的OK只关闭返回信息阶段,ACT_TERM交接及FINISHED仍由后续Process/NextEvent推进。 */ if (app->command_waiting) { return true; } if (reply == IEC104_COMMAND_REPLY_STALE) { app->command_step = 0U; return true; } if (reply != IEC104_COMMAND_REPLY_OK) { return false; } app->command_step = app->command_step == 3U ? 0U : app->command_step + 1U; } return true; } /* ============================================================================ * [READ/LOOKUP] 读命令 Type102:同步查点与有界执行 * ============================================================================ */ /** * 功能:按受理时station_id找到原节点,读取总召/遥控共用的模拟运行值并Add一个对象。 * 输入参数:context为本ExampleApp;request/response均由Read借出,仅本次调用有效。 * 输出参数:response——单对象读取应答缓冲。 * 返回值:FOUND表示对象已加入应答,UNKNOWN表示地址不在示例点表内,ERROR表示身份、品质准备或编码失败。 * 说明:无。 */ static IEC104_ReadLookupResult_t Example_Read_Point(void *context, const IEC104_ReadRequest_t *request, IEC60870_Asdu_t *response) { ExampleApp *app = context; IEC104_Station_t *station = IEC104_Slave_Get_Station_By_Id(app->slave, request->station_id); size_t index; IEC60870_CP56Time2a_t sampled_time; if (IEC104_Station_Get_Context(station) != app) { return IEC104_READ_LOOKUP_ERROR; } Example_Monitor_Time(app, IEC104_Net_Now_Ms(), &sampled_time); #ifdef IEC104_EXAMPLE_DTU_PROFILE /* 源地址诊断别名让全部41倍率和93取反都可观察;不补造XML三遥映射。 */ if (Dtu_Measurement_Source_Valid(request->ioa)) { IEC60870_MeasuredValueShort_t point; return IEC60870_MeasuredValueShort_Create(&point, request->ioa, (float)app->dtu_frame.primary[Dtu_Measurement_Index(request->ioa)], app->dtu_sample_valid ? 0U : 0x80U) == IEC60870_ASDU_OK && IEC60870_Asdu_Add_InformationObject(response, &point.object) == IEC60870_ASDU_OK ? IEC104_READ_LOOKUP_FOUND : IEC104_READ_LOOKUP_ERROR; } if ((request->ioa >= 0x9141U && request->ioa <= 0x919DU) || (request->ioa >= 0xB100U && request->ioa < 0xB100U + EXAMPLE_DOUBLE_COUNT)) { IEC60870_SinglePointWithCP56Time2a_t point; uint8_t value = request->ioa < 0xB100U ? app->dtu_digital_output[request->ioa - 0x9140U] : app->dtu_pulse_until[request->ioa - 0xB100U] > IEC104_Net_Now_Ms(); return IEC60870_SinglePointWithCP56Time2a_Create(&point, request->ioa, value, 0U, &sampled_time) == IEC60870_ASDU_OK && IEC60870_Asdu_Add_InformationObject(response, &point.base.object) == IEC60870_ASDU_OK ? IEC104_READ_LOOKUP_FOUND : IEC104_READ_LOOKUP_ERROR; } #endif for (index = 0U; index < EXAMPLE_SIGNAL_COUNT; ++index) { if (request->ioa == example_signals[index].ioa) { IEC60870_SinglePointWithCP56Time2a_t point; return IEC60870_SinglePointWithCP56Time2a_Create(&point, request->ioa, app->signal_values[index], 0U, &sampled_time) == IEC60870_ASDU_OK && IEC60870_Asdu_Add_InformationObject(response, &point.base.object) == IEC60870_ASDU_OK ? IEC104_READ_LOOKUP_FOUND : IEC104_READ_LOOKUP_ERROR; } if (index < EXAMPLE_DOUBLE_COUNT && request->ioa == EXAMPLE_IOA_DOUBLE_BASE + index) { IEC60870_DoublePointWithCP56Time2a_t point; return IEC60870_DoublePointWithCP56Time2a_Create(&point, request->ioa, app->double_values[index], 0U, &sampled_time) == IEC60870_ASDU_OK && IEC60870_Asdu_Add_InformationObject(response, &point.base.object) == IEC60870_ASDU_OK ? IEC104_READ_LOOKUP_FOUND : IEC104_READ_LOOKUP_ERROR; } } for (index = 0U; index < EXAMPLE_STEP_COUNT; ++index) { if (request->ioa == EXAMPLE_IOA_STEP_BASE + index) { IEC60870_StepPositionInformation_t point; return IEC60870_StepPositionInformation_Create(&point, request->ioa, app->step_values[index], 0U, 0U) == IEC60870_ASDU_OK && IEC60870_Asdu_Add_InformationObject(response, &point.object) == IEC60870_ASDU_OK ? IEC104_READ_LOOKUP_FOUND : IEC104_READ_LOOKUP_ERROR; } } for (index = 0U; index < EXAMPLE_BITSTRING_COUNT; ++index) { if (request->ioa == EXAMPLE_IOA_BITSTRING_BASE + index) { IEC60870_BitString32_t point; return IEC60870_BitString32_Create(&point, request->ioa, app->bitstring_values[index], 0U) == IEC60870_ASDU_OK && IEC60870_Asdu_Add_InformationObject(response, &point.object) == IEC60870_ASDU_OK ? IEC104_READ_LOOKUP_FOUND : IEC104_READ_LOOKUP_ERROR; } } for (index = 0U; index < EXAMPLE_MEASUREMENT_COUNT; ++index) { if (request->ioa == example_measurements[index].ioa) { ExampleMeasurementObject point; return Example_Create_Measurement(&point, request->ioa, app->scaled_values[index], Example_Measurement_Quality(app, index)) == IEC60870_ASDU_OK && IEC60870_Asdu_Add_InformationObject(response, &point.object) == IEC60870_ASDU_OK ? IEC104_READ_LOOKUP_FOUND : IEC104_READ_LOOKUP_ERROR; } } /* 只有不在可读监视表的地址才走UNKNOWN,计数量和命令地址也在此列。 * 已知点的数据无效在上面的点分支按IV应答;无法构造应答或组包失败才返回ERROR。 */ return IEC104_READ_LOOKUP_UNKNOWN; } /** * 功能:每轮读空网络通知后有界推进Read,保留其他业务的运行机会。 * Process负责已有REPLY;Execute_Next的OK只代表原READ已结束或转回复,不能当作发送成功。 * OK后再Process及时发送UNKNOWN转出的47;WAIT/EMPTY结束循环,下一轮网络推进后再试。 * 返回false交主循环清理;末尾刷新rd供Example_Wait_Time合并事件、发送背压和期限。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:true表示指定范围的数据已完整读出;false表示范围非法、读取失败或短读。 * 说明:无。 */ static bool Example_Step_Read(ExampleApp *app) { unsigned step; if (app->read == NULL) { return true; } if (!IEC104_Read_Process(app->read)) { return false; } for (step = 0U; step < EXAMPLE_READ_BUDGET; ++step) { IEC104_ReadExecuteResult_t result = IEC104_Read_Execute_Next(app->read, Example_Read_Point, app); if (result == IEC104_READ_EXECUTE_ERROR) { return false; } if (result != IEC104_READ_EXECUTE_OK) { break; } if (!IEC104_Read_Process(app->read)) { return false; } } return IEC104_Read_Get_Status(app->read, &app->rd); } /* ============================================================================ * [PARAMETER/INIT] 参数点表和运行值;独立IOA,默认扩展全部关闭 * ============================================================================ */ /** * 功能:首次Create前,或纯内存模式协议复位已取消旧任务后,恢复运行初值;调用始终在所属事件循环。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:无。 * 说明:默认标度门限200,归一化原始655使整数差达到200时上送;平滑0,下/上限使用设定值范围。 * 这些是演示工况值,不是现场标定值;借用数组地址、点表归属和采样配置均不变。 * 同时恢复滤波和变化基准;本函数不读写配置文件,也不改扫描模块借用的周期数组与重试位图。 */ static void Example_Reset_Parameter_Values(ExampleApp *app) { size_t index; for (index = 0U; index < EXAMPLE_PARAMETER_COUNT; ++index) { const IEC104_ParameterPoint_t *point = &app->parameter_points[index]; IEC104_ParameterValue_t *value = &app->parameter_values[index]; memset(value, 0, sizeof(*value)); if (point->kind == IEC60870_ASDU_KPA_THRESHOLD) { if (point->type_id == IEC60870_ASDU_P_ME_NA_1) { value->normalized = EXAMPLE_THRESHOLD_NORMALIZED; } else { value->scaled = EXAMPLE_THRESHOLD_SCALED; } } else if (point->kind == IEC60870_ASDU_KPA_LOW_LIMIT) { value->scaled = EXAMPLE_SCALED_MIN; } else if (point->kind == IEC60870_ASDU_KPA_HIGH_LIMIT) { value->scaled = EXAMPLE_SCALED_MAX; } } Example_Reset_Measurements(app); } /** * 功能:每个遥测对应四行:门限0x8601..0x8608、下限0x8611..0x8618、上限0x8621..0x8628、平滑0x8631..0x8638。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:无。 * 说明:地址使用独立的十六进制分区常量,按(CA, IOA)升序;index % 8关联同一遥测,group决定参数种类。 * 门限前四行和上下限用111,门限后四行用110比例值,平滑时间常数用112秒值。 * 在Slave消费首条通知前创建;点表与运行值均借用app固定存储,默认extensions保持0。 */ static void Example_Prepare_Parameter_Values(ExampleApp *app) { size_t index; static const uint8_t kinds[4] = {IEC60870_ASDU_KPA_THRESHOLD, IEC60870_ASDU_KPA_LOW_LIMIT, IEC60870_ASDU_KPA_HIGH_LIMIT, IEC60870_ASDU_KPA_SMOOTHING}; for (index = 0U; index < EXAMPLE_PARAMETER_COUNT; ++index) { size_t group = index / EXAMPLE_MEASUREMENT_COUNT; size_t measurement = index % EXAMPLE_MEASUREMENT_COUNT; IEC104_ParameterPoint_t *point = &app->parameter_points[index]; point->common_address = IEC104_Station_Get_Common_Address(&app->station); point->ioa = (uint32_t)(EXAMPLE_IOA_PARAMETER_BASE + group * EXAMPLE_IOA_PARAMETER_STRIDE + measurement); point->kind = kinds[group]; point->type_id = group == 3U ? IEC60870_ASDU_P_ME_NC_1 : (group == 0U && measurement >= 4U ? IEC60870_ASDU_P_ME_NA_1 : IEC60870_ASDU_P_ME_NB_1); } Example_Reset_Parameter_Values(app); } /** * 功能:准备参数点表和初值,再创建借用app固定数组的标准参数模块;重复初始化返回false。 * 输入参数:app——示例应用上下文。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:返回true表示创建成功,调用方须让点表和运行值存储覆盖模块整个生命周期。 */ static inline bool Example_Init_Parameter(ExampleApp *app) { IEC104_ParameterConfig_t config; if (app->parameter != NULL) { return false; } Example_Prepare_Parameter_Values(app); IEC104_Parameter_Config_Default(&config); config.points = app->parameter_points; config.point_count = EXAMPLE_PARAMETER_COUNT; config.values = app->parameter_values; app->parameter = IEC104_Parameter_Create(app->slave, &config); return app->parameter != NULL; } /* ============================================================================ * [PARAMETER/CONFIG] 应用业务校验与可选文件持久化;协议模块不直接读写存储 * ============================================================================ */ /** * 功能:网络装载和文件恢复共用业务判据;values可指向尚未提交的整份加载候选。 * 输入参数:app——示例应用上下文;values——与点表同序的参数运行值数组;index——本次条目、点或逻辑槽的下标;value——解析结果回写位置。 * 输出参数:无独立输出参数。 * 返回值:候选参数满足该点的业务值域及关联约束时返回true,否则返回false。 * 说明:调用方先检查index。恢复时以候选中的另一限值校验,不能拿默认上下限与新配置混合判断。 */ static bool Example_Parameter_Value_Valid(const ExampleApp *app, const IEC104_ParameterValue_t *values, size_t index, const IEC104_ParameterValue_t *value) { size_t measurement = index % EXAMPLE_MEASUREMENT_COUNT; switch (app->parameter_points[index].kind) { case IEC60870_ASDU_KPA_THRESHOLD: return app->parameter_points[index].type_id == IEC60870_ASDU_P_ME_NA_1 ? value->normalized >= 0 : value->scaled >= 0; case IEC60870_ASDU_KPA_SMOOTHING: /* 正向区间判断同时排除NaN;存储格式和协议层还各自拒绝非有限浮点。 */ return value->short_float >= 0.0f && value->short_float <= 60.0f; case IEC60870_ASDU_KPA_LOW_LIMIT: return value->scaled >= EXAMPLE_SCALED_MIN && value->scaled <= EXAMPLE_SCALED_MAX && value->scaled <= values[2U * EXAMPLE_MEASUREMENT_COUNT + measurement].scaled; case IEC60870_ASDU_KPA_HIGH_LIMIT: return value->scaled >= EXAMPLE_SCALED_MIN && value->scaled <= EXAMPLE_SCALED_MAX && value->scaled >= values[EXAMPLE_MEASUREMENT_COUNT + measurement].scaled; default: return false; } } /** * 功能:只比较该Type使用的union成员,不能memcmp未使用字节;同值重装无需重复写盘。 * 输入参数:type——信息对象或日志类型标识;a——第一个待比较值或身份;b——第二个待比较值或身份。 * 输出参数:无独立输出参数。 * 返回值:指定类型的两个参数运行值相等时返回true,否则返回false。 * 说明:无。 */ static bool Example_Parameter_Value_Equal(uint8_t type, const IEC104_ParameterValue_t *a, const IEC104_ParameterValue_t *b) { if (type == IEC60870_ASDU_P_ME_NA_1) { return a->normalized == b->normalized; } if (type == IEC60870_ASDU_P_ME_NB_1) { return a->scaled == b->scaled; } return a->short_float == b->short_float; } /** * 功能:动作回调只登记保存需求,不做文件I/O;连续装载在首次修改后的500ms窗口内合并。 * 输入参数:app——示例应用上下文。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:无。 * 说明:失败退避期间的新修改继续合入最新运行值,既不清失败状态,也不把退避无限顺延。 */ static void Example_Config_Changed(ExampleApp *app) { if (app->config_path == NULL || app->config_dirty) { return; } app->config_dirty = true; app->config_wait_started_ms = IEC104_Net_Now_Ms(); app->config_wait_ms = EXAMPLE_CONFIG_SAVE_MS; } /** * 功能:首次创建、或纯内存模式协议重建时恢复初值;调用前须已完成预置清理。 * 输入参数:app——示例应用上下文。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:无。 * 说明:持久化模式重建保留定值,独立映像记录example_image也不在此复位。 */ static void Example_Reset_Remote_Values(ExampleApp *app); /** * 功能:仅复制已固化值,不保存预置候选、连接身份或只读映像信息。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:已固化远程定值的完整值副本。 * 说明:无。 */ static ExampleRemoteConfig Example_Remote_Config_Snapshot(const ExampleApp *app); /** * 功能:将已校验的远程参数配置复制到运行区;包含当前区号、全局死区和五套区值。 * 输入参数:app——示例应用上下文;saved——已经校验的配置快照。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:无。 * 说明:本函数只应用内存值,持久化、预置清理和生效通知由调用方编排。 */ static void Example_Remote_Config_Apply(ExampleApp *app, const ExampleRemoteConfig *saved); /** * 功能:打印本次远程参数操作目标及当前实际选用的运行定值。 * 输入参数:app——示例应用上下文;reason——状态输出中的原因文字;target_area——本次操作的目标区号。 * 输出参数:无独立输出参数。 * 返回值:无。 * 说明:target_area是本次操作的目标,current_area是当前实际选用的设置。 * 固化非当前区时两者可以不同;输出仍显示当前区的值,便于观察“保存”和“选用”的区别。 * 只在初始化/成功变更/复位/退出展示,PRESET、撤销及TEST不发布配置变更。 */ static void Example_Remote_Report_Settings(const ExampleApp *app, const char *reason, uint16_t target_area); /** * 功能:快照借用已提交区;只有当前提交者的候选覆盖对应领域,不包含远程预置或文件半成品。 * 输入参数:app——示例应用上下文;remote——可选远程定值提交候选;temp——已提交或待提交的TEMP快照。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:沿用Example_Config_Save结果:OK表示保存成功,INVALID表示候选非法,IO_ERROR表示文件操作失败。 * 说明:所有业务共用同一原子替换入口,成功同时落盘最新标准参数,因此可清除其dirty/退避状态。 */ static ExampleConfigResult Example_Config_Store(ExampleApp *app, const ExampleRemoteConfig *remote, const ExampleTempConfig *temp) { ExamplePersistentConfig saved = {0}; ExampleConfigResult result; saved.remote = remote != NULL ? *remote : Example_Remote_Config_Snapshot(app); #ifdef IEC104_EXAMPLE_DTU_PROFILE /* 同步借用提交候选或已固化区;其他业务保存不能夹带dtu_stage预置值。 */ saved.dtu = app->dtu_config_candidate != NULL ? app->dtu_config_candidate : &app->dtu_settings; saved.remote.current_area = saved.dtu->current_area; #endif saved.temp.present = app->files.present; saved.temp.name = app->files.file_name; saved.temp.name_length = app->files.file_name_length; saved.temp.bytes = app->files.file_bytes; saved.temp.size = app->files.file_size; saved.temp.time = app->files.file_time; if (temp != NULL) { saved.temp = *temp; } result = Example_Config_Save(app->config_path, app->parameter_points, app->parameter_values, EXAMPLE_PARAMETER_COUNT, &saved); if (result == EXAMPLE_CONFIG_OK) { app->config_dirty = app->config_failed = false; } return result; } /** * 功能:标准参数的延迟保存由应用主循环执行,不在其协议动作回调或信号处理器中执行。 * 输入参数:app——示例应用上下文;force——是否强制刷新或提交。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:肯定确认只承诺运行参数已生效;写盘失败不回滚运行值,保留dirty并按5秒重试。 * force用于正常退出,跳过合并和退避;返回false表示本次实际保存失败。 * 文件系统I/O仍可能阻塞,当前Windows演示没有独立存储线程或实时耗时保证。 */ static inline bool Example_Config_Flush(ExampleApp *app, bool force) { ExampleConfigResult result; uint64_t now; if (app->config_path == NULL || !app->config_dirty) { return true; } now = IEC104_Net_Now_Ms(); if (!force && now >= app->config_wait_started_ms && now - app->config_wait_started_ms < app->config_wait_ms) { return true; } result = Example_Config_Store(app, NULL, NULL); if (result != EXAMPLE_CONFIG_OK) { if (!app->config_failed) { fprintf(stderr, "CONFIG save failed: %s; retry in 5000ms\n", Example_Config_Result_Name(result)); } app->config_failed = true; app->config_wait_started_ms = IEC104_Net_Now_Ms(); app->config_wait_ms = EXAMPLE_CONFIG_RETRY_MS; return false; } app->config_dirty = app->config_failed = false; puts("CONFIG SAVED"); fflush(stdout); return true; } /** * 功能:监听前完整验证三个领域,包括未启用的协议模块,防止下一次保存丢掉其数据。 * 输入参数:app——示例应用上下文;path——NUL结尾的宿主文件路径。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示请求的资源或存储实例已准备就绪;false表示输入校验、资源获取或恢复失败。 * 说明:复用文件接收暂存区加载TEMP,不额外分配大缓冲。旧格式全部校验后才原子迁移。 * 只有所有旧档都不存在才创建默认档;非法或不可读的文件不覆盖,父目录须已存在。 */ static inline bool Example_Config_Open(ExampleApp *app, const char *path) { IEC104_ParameterValue_t loaded[EXAMPLE_PARAMETER_COUNT]; ExamplePersistentConfig saved = {0}; ExampleConfigResult result; bool created; size_t index; #ifdef IEC104_EXAMPLE_DTU_PROFILE DtuSettings loaded_dtu; #endif if (path == NULL) { return true; } if (app->parameter == NULL) { Example_Prepare_Parameter_Values(app); } if (app->remote_parameter == NULL) { Example_Reset_Remote_Values(app); } memcpy(loaded, app->parameter_values, sizeof(loaded)); saved.remote = Example_Remote_Config_Snapshot(app); #ifdef IEC104_EXAMPLE_DTU_PROFILE loaded_dtu = app->dtu_settings; saved.dtu = &loaded_dtu; #endif saved.temp.name = app->files.stage_name; saved.temp.bytes = app->files.stage_bytes; result = Example_Config_Load(path, app->parameter_points, loaded, EXAMPLE_PARAMETER_COUNT, &saved); created = result == EXAMPLE_CONFIG_NOT_FOUND; if (result != EXAMPLE_CONFIG_OK && !created) { fprintf(stderr, "CONFIG load failed: %s\n", Example_Config_Result_Name(result)); return false; } for (index = 0U; index < EXAMPLE_PARAMETER_COUNT; ++index) { if (!Example_Parameter_Value_Valid(app, loaded, index, &loaded[index])) { fputs("CONFIG invalid parameter values\n", stderr); return false; } } if (created || saved.legacy) { result = Example_Config_Save(path, app->parameter_points, loaded, EXAMPLE_PARAMETER_COUNT, &saved); if (result != EXAMPLE_CONFIG_OK) { fprintf(stderr, "CONFIG %s failed: %s\n", created ? "create" : "migration", Example_Config_Result_Name(result)); return false; } } memcpy(app->parameter_values, loaded, sizeof(loaded)); Example_Reset_Measurements(app); Example_Remote_Config_Apply(app, &saved.remote); #ifdef IEC104_EXAMPLE_DTU_PROFILE app->dtu_settings = loaded_dtu; app->remote_area = loaded_dtu.current_area; #endif app->files.present = saved.temp.present; if (saved.temp.present) { memcpy(app->files.file_name, saved.temp.name, saved.temp.name_length); memcpy(app->files.file_bytes, saved.temp.bytes, saved.temp.size); app->files.file_name_length = saved.temp.name_length; app->files.file_size = saved.temp.size; app->files.file_time = saved.temp.time; } app->config_path = path; puts(created ? "CONFIG CREATED" : saved.legacy ? "CONFIG MIGRATED" : "CONFIG LOADED"); if (app->remote_parameter != NULL) { puts("REMOTE_CONFIG LOADED"); Example_Remote_Report_Settings(app, "load", app->remote_area); } if (app->file_service != NULL && saved.temp.present) { puts("FILE_CONFIG LOADED"); } fflush(stdout); return true; } /* ============================================================================ * [PARAMETER/ACTION] 装载后更新测量处理;门限只抑制普通变化上送 * ============================================================================ */ /** * 功能:短时同步动作:LOAD通过业务校验后更新运行值,再返回APPLIED供模块形成带值确认。 * 输入参数:context——调用方注册的回调上下文;request——仅在当前回调期间借用的协议请求。 * 输出参数:无独立输出参数。 * 返回值:APPLIED表示动作已完成,UNKNOWN_IOA表示请求点或周期目标不支持,REJECTED表示身份、动作或业务校验拒绝。 * 说明:模块已检查地址、类型、KPA和有限浮点;本函数补业务范围与上下限之间的约束。 * 110..112合法TEST由模块直接确认,不调用此动作;113 TEST会进入,只检查周期配置。 * 本例未实现ACK扩展的预留和收尾,因此仅接受EXECUTE,不能直接打开扩展位沿用此动作。 */ static IEC104_ParameterActionResult_t Example_Parameter_Action(void *context, const IEC104_ParameterRequest_t *request) { ExampleApp *app = context; IEC104_Station_t *station = IEC104_Slave_Get_Station_By_Id(app->slave, request->station_id); /* 使用受理时的站点身份,不把同CA重注册后的站点当作原请求对象。 */ if (station != &app->station || !IEC104_Station_Is_Registered(station) || request->phase != IEC104_PARAMETER_PHASE_EXECUTE) { return IEC104_PARAMETER_ACTION_REJECTED; } if (request->operation == IEC104_PARAMETER_OP_LOAD) { size_t measurement = request->point_index % EXAMPLE_MEASUREMENT_COUNT; bool changed; IEC104_ParameterValue_t before; if (request->point_index >= EXAMPLE_PARAMETER_COUNT) { return IEC104_PARAMETER_ACTION_REJECTED; } /* 与另一限值的当前运行值比较:上移区间先装上限,下移区间先装下限。 * 拒绝路径不改数组,模块随后回报仍在运行的旧值。 */ if (!Example_Parameter_Value_Valid(app, app->parameter_values, request->point_index, &request->value)) { return IEC104_PARAMETER_ACTION_REJECTED; } changed = !Example_Parameter_Value_Equal(request->type_id, &app->parameter_values[request->point_index], &request->value); before = app->parameter_values[request->point_index]; /* 先按旧配置积分到动作时刻,再切换配置并重估品质/直通值;TEST不会到达此路径。 * 回复、总召读取同一运行配置;变化发布留给主循环,动作不调用网络发送。 */ { uint64_t now = IEC104_Net_Now_Ms(); Example_Update_Measurement(app, measurement, now); app->parameter_values[request->point_index] = request->value; Example_Update_Measurement(app, measurement, now); } if (changed) { Example_Config_Changed(app); /* 10记运行值已经生效;INI的延迟保存尚未完成,不能在这里宣称配置文件已保存。 * 协议随后重试固定确认,不会再调用本动作;日志失败也保持本次APPLIED事实。 */ Example_User_Log_Parameter(app, "STANDARD", request->ioa, 0U, request->type_id == 112U ? (double)before.short_float : request->type_id == 111U ? (double)before.scaled : (double)before.normalized, request->type_id == 112U ? (double)request->value.short_float : request->type_id == 111U ? (double)request->value.scaled : (double)request->value.normalized); } return IEC104_PARAMETER_ACTION_APPLIED; } if (request->qpa == IEC60870_ASDU_QPA_CYCLIC_TRANSMISSION) { IEC104_PeriodicScanGroupStatus_t group; size_t index; uint32_t period; /* QPA=3寻址扫描的测量对象,不查参数点表;仅组0(COT=1)成员可以被启停。 */ if (app->periodic_scan == NULL) { return IEC104_PARAMETER_ACTION_UNKNOWN_IOA; } for (index = 0U; index < EXAMPLE_SCAN_POINT_COUNT; ++index) { const IEC104_PeriodicScanPoint_t *point = &app->scan_points[index]; if (point->common_address == request->common_address && point->ioa == request->ioa && (point->groups & 1U) != 0U) { break; } } if (index == EXAMPLE_SCAN_POINT_COUNT) { return IEC104_PARAMETER_ACTION_UNKNOWN_IOA; } /* 有该周期对象但使用组周期模式时回否定,不能用停整组替代寻址点的停止激活。 */ if (!IEC104_PeriodicScan_Get_Group_Status(app->periodic_scan, 0U, &group) || !group.point_period) { return IEC104_PARAMETER_ACTION_REJECTED; } /* 停止写0但保留另存的恢复周期;激活还要确认组未停用且周期是组刻度的正整数倍。 * 只改COT=1的点级周期,同一测量对象所属的COT=2背景组仍可继续上送。 */ period = request->operation == IEC104_PARAMETER_OP_DEACTIVATE ? 0U : app->parameter_cyclic_ms; if (request->operation == IEC104_PARAMETER_OP_ACTIVATE && (period == 0U || group.period_ms == 0U || period % group.period_ms != 0U)) { return IEC104_PARAMETER_ACTION_REJECTED; } /* TEST只检查,与真实请求共享判据,短路求值保证绝不调用setter。 * 真实请求的APPLIED表示配置已启停;不承诺数据送达,也不替代扫描故障后的Resume。 */ if (!request->test) { uint32_t before = app->point_period_ms[index]; if (!IEC104_PeriodicScan_Set_Point_Period(app->periodic_scan, index, period)) { return IEC104_PARAMETER_ACTION_REJECTED; } Example_User_Log_Parameter(app, "CYCLIC_MS", request->ioa, 0U, (double)before, (double)period); } return IEC104_PARAMETER_ACTION_APPLIED; } return IEC104_PARAMETER_ACTION_REJECTED; } /** * 功能:读空Slave通知后每轮至多交付一次动作:前后Process分别处理期限/旧确认与本次新确认。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。 * 说明:WAIT要求先继续分派通知,EMPTY表示当前没有可执行动作;二者都正常让出本轮。 * 即使need_process为false仍要调用Process,以观察状态变化和重试发送背压。 */ static bool Example_Step_Parameter(ExampleApp *app) { IEC104_ParameterExecuteResult_t result; if (app->parameter == NULL) { return true; } if (!IEC104_Parameter_Process(app->parameter)) { return false; } result = IEC104_Parameter_Execute_Next(app->parameter, Example_Parameter_Action, app); return result != IEC104_PARAMETER_EXECUTE_ERROR && IEC104_Parameter_Process(app->parameter) && IEC104_Parameter_Get_Status(app->parameter, &app->parameter_status); } /* [REMOTE_PARAMETER] 应用归属、整批暂存与运行值。 * 七个地址按设计示例排列;权限、值域和五个定值区属于本示例配置,不能推作设备能力。 * 固有/运行参数位于前五行,分区动作定值位于末两行;读全部借用该固定顺序。 */ #ifdef IEC104_EXAMPLE_DTU_PROFILE #include "iec104_dtu_settings.inc" #else static const uint32_t example_remote_ioas[] = { 0x8001U, 0x8003U, 0x8005U, 0x8006U, 0x8020U, 0x8221U, 0x8224U }; /** * 功能:当前区只选择一套已固化的动作定值;不分区死区由所有区共享。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:当前选中区及其运行定值的值副本。 * 说明:调用方与动作回调在同一事件循环取值,不读取PRESET候选,也不改变任何配置。 * remote_area仅由初始化和校验后的SWITCH_AREA写入,始终在0–4内。 */ static ExampleRemoteSettings Example_Remote_Current_Settings(const ExampleApp *app) { ExampleRemoteSettings settings; settings.area = app->remote_area; settings.reset_seconds = app->remote_reset_seconds[settings.area]; settings.x_time = app->remote_x_time[settings.area]; settings.deadband = app->remote_deadband; return settings; } /** * 功能:打印本次远程参数操作目标及当前实际选用的运行定值。 * 输入参数:app——示例应用上下文;reason——状态输出中的原因文字;target_area——本次操作的目标区号。 * 输出参数:无独立输出参数。 * 返回值:无。 * 说明:target_area是本次操作的目标,current_area是当前实际选用的设置。 * 固化非当前区时两者可以不同;输出仍显示当前区的值,便于观察“保存”和“选用”的区别。 * 只在初始化/成功变更/复位/退出展示,PRESET、撤销及TEST不发布配置变更。 */ static void Example_Remote_Report_Settings(const ExampleApp *app, const char *reason, uint16_t target_area) { ExampleRemoteSettings settings = Example_Remote_Current_Settings(app); printf("REMOTE_SETTINGS reason=%s target_area=%u current_area=%u reset_seconds=%u x_time=%.9g deadband=%.9g\n", reason, (unsigned)target_area, (unsigned)settings.area, (unsigned)settings.reset_seconds, (double)settings.x_time, (double)settings.deadband); fflush(stdout); /* 管道运行时也即时显示切区/固化结果,不等进程退出。 */ } /** * 功能:首次创建、或纯内存模式协议重建时恢复初值;调用前须已完成预置清理。 * 输入参数:app——示例应用上下文。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:无。 * 说明:持久化模式重建保留定值,独立映像记录example_image也不在此复位。 */ static void Example_Reset_Remote_Values(ExampleApp *app) { /* 不同初值便于主站观察五套配置;这些是演示值,不是规约规定的默认定值。 */ static const uint16_t reset_seconds[5] = {30U, 60U, 90U, 120U, 150U}; static const float x_time[5] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f}; app->remote_area = 0U; app->remote_deadband = 0.0f; memcpy(app->remote_reset_seconds, reset_seconds, sizeof(app->remote_reset_seconds)); memcpy(app->remote_x_time, x_time, sizeof(app->remote_x_time)); memset(&app->remote_stage, 0, sizeof(app->remote_stage)); } /** * 功能:仅复制已固化值,不保存预置候选、连接身份或只读映像信息。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:已固化远程定值的完整值副本。 * 说明:无。 */ static ExampleRemoteConfig Example_Remote_Config_Snapshot(const ExampleApp *app) { ExampleRemoteConfig saved; saved.current_area = app->remote_area; saved.deadband = app->remote_deadband; memcpy(saved.reset_seconds, app->remote_reset_seconds, sizeof(saved.reset_seconds)); memcpy(saved.x_time, app->remote_x_time, sizeof(saved.x_time)); return saved; } /** * 功能:将已校验的远程参数配置复制到运行区;包含当前区号、全局死区和五套区值。 * 输入参数:app——示例应用上下文;saved——已经校验的配置快照。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:无。 * 说明:本函数只应用内存值,持久化、预置清理和生效通知由调用方编排。 */ static void Example_Remote_Config_Apply(ExampleApp *app, const ExampleRemoteConfig *saved) { app->remote_area = saved->current_area; app->remote_deadband = saved->deadband; memcpy(app->remote_reset_seconds, saved->reset_seconds, sizeof(saved->reset_seconds)); memcpy(app->remote_x_time, saved->x_time, sizeof(saved->x_time)); } /** * 功能:Windows小文件同步提交:写盘失败不发布任何运行值,不改变原选择或其他区。 * 输入参数:app——示例应用上下文;saved——已经校验的配置快照。 * 输出参数:无独立输出参数。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:这是示例应用的持久化语义;无配置路径时保持原有RAM模式。 */ static bool Example_Remote_Config_Commit(ExampleApp *app, const ExampleRemoteConfig *saved) { ExampleRemoteConfig before = Example_Remote_Config_Snapshot(app); size_t index; if (app->config_path != NULL) { ExampleConfigResult result = Example_Config_Store(app, saved, NULL); if (result != EXAMPLE_CONFIG_OK) { fprintf(stderr, "REMOTE_CONFIG save failed: %s\n", Example_Config_Result_Name(result)); return false; } puts("REMOTE_CONFIG SAVED"); fflush(stdout); } Example_Remote_Config_Apply(app, saved); /* 整份配置提交与发布完成后才写日志;失败不得回滚已生效配置或让SOLIDIFY重新执行。 * 非当前区记录已保存的参数值,scope明确其含义;切区只记选择变化,PRESET不进入这里。 */ Example_User_Log_Parameter(app, "REMOTE_AREA", 0U, saved->current_area, (double)before.current_area, (double)saved->current_area); Example_User_Log_Parameter(app, "REMOTE_GLOBAL", example_remote_ioas[4], 0U, (double)before.deadband, (double)saved->deadband); for (index = 0U; index < 5U; ++index) { Example_User_Log_Parameter(app, "REMOTE_STORED", example_remote_ioas[5], (unsigned)index, (double)before.reset_seconds[index], (double)saved->reset_seconds[index]); Example_User_Log_Parameter(app, "REMOTE_STORED", example_remote_ioas[6], (unsigned)index, (double)before.x_time[index], (double)saved->x_time[index]); } return true; } /** * 功能:在消费首条Slave通知前创建;本例用memcpy解码binary32,因此先检查宿主表示。 * 输入参数:app——示例应用上下文。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:使用模块默认类型、镜像确认和期限;实例存在期间不切换确认模式或应用上下文。 */ static inline bool Example_Init_RemoteParameter(ExampleApp *app) { IEC104_RemoteParameterConfig_t config; if (app->remote_parameter != NULL || sizeof(float) != 4U || FLT_RADIX != 2 || FLT_MANT_DIG != 24 || FLT_MAX_EXP != 128) { return false; } Example_Reset_Remote_Values(app); IEC104_RemoteParameter_Config_Default(&config); app->remote_parameter = IEC104_RemoteParameter_Create(app->slave, &config); if (app->remote_parameter != NULL) { Example_Remote_Report_Settings(app, "init", 0U); } return app->remote_parameter != NULL; } /** * 功能:按完整原归属查暂存,不只看CA;同CA删除重注册、重连或换实例均不能接续旧批次。 * 输入参数:stage——远程预置候选及所属身份;request——仅在当前回调期间借用的协议请求。 * 输出参数:无独立输出参数。 * 返回值:预置记录与请求的所有者身份一致时返回true,否则返回false。 * 说明:此处故意不比较SN:合法CANCEL允许携带不同SN;续帧/固化另行核对SN。 */ static bool Example_Remote_Owner(const ExampleRemoteStage *stage, const IEC104_RemoteParameterRequest_t *request) { const IEC104_RemoteParameterRequest_t *owner = &stage->owner; return stage->active && owner->identity.slave == request->identity.slave && owner->identity.instance_id == request->identity.instance_id && owner->identity.generation == request->identity.generation && owner->instance_id == request->instance_id && owner->generation == request->generation && owner->station_id == request->station_id && owner->common_address == request->common_address && owner->test == request->test; } /** * 功能:返回固定点表下标;等于表长表示未知地址,用于区分UNKNOWN_IOA与权限/值域拒绝。 * 输入参数:ioa——信息体地址。 * 输出参数:无独立输出参数。 * 返回值:IOA对应的定值项索引;未匹配时返回固定点表长度。 * 说明:无。 */ static size_t Example_Remote_Index(uint32_t ioa) { size_t index; for (index = 0U; index < sizeof(example_remote_ioas) / sizeof(example_remote_ioas[0]); ++index) { if (example_remote_ioas[index] == ioa) { break; } } return index; } /** * 功能:普通读写核对本例站点的注册编号及CA;旧站清理必须走暂存归属匹配,不能受此检查阻挡。 * 输入参数:app——示例应用上下文;request——仅在当前回调期间借用的协议请求。 * 输出参数:无独立输出参数。 * 返回值:请求仍属于本应用登记的站点时返回true,否则返回false。 * 说明:无。 */ static bool Example_Remote_Station(const ExampleApp *app, const IEC104_RemoteParameterRequest_t *request) { return request->identity.slave == app->slave && request->station_id == IEC104_Station_Get_Id(&app->station) && request->common_address == IEC104_Station_Get_Common_Address(&app->station); } /** * 功能:短时同步动作,应用负责权限、区号和值域,模块已检查帧结构和Tag基本编码。 * 输入参数:context——调用方注册的回调上下文;request——仅在当前回调期间借用的协议请求;area——远程参数区域查询结果回写位置。 * 输出参数:area——远程参数区域查询结果回写位置。 * 返回值:APPLIED表示请求阶段已处理,UNKNOWN_IOA表示定值地址不支持,REJECTED表示身份、区号、状态、候选值校验拒绝或持久化失败。 * 说明:PRESET只写暂存,SOLIDIFY一次发布;失败返回前清本归属整批资源,不等待后续DISCARD。 * TEST写动作由模块模拟,不会进入这里;READ_AREA即使TEST也只读当前区号。 */ static IEC104_RemoteParameterActionResult_t Example_Remote_Action(void *context, const IEC104_RemoteParameterRequest_t *request, IEC104_RemoteParameterArea_t *area) { ExampleApp *app = context; ExampleRemoteStage *stage = &app->remote_stage; IEC104_RemoteParameterActionResult_t failure = IEC104_REMOTE_PARAMETER_ACTION_REJECTED; size_t index; /* 原站即使已被删除,仍须按完整归属清理旧暂存;先清理再检查当前注册站。 * CANCEL携带的SN不是暂存选择器,不能误清该SN下其他资源;重复清理允许无操作。 */ if (request->operation == IEC104_REMOTE_PARAMETER_OP_CANCEL || request->operation == IEC104_REMOTE_PARAMETER_OP_DISCARD) { if (Example_Remote_Owner(stage, request)) { memset(stage, 0, sizeof(*stage)); } return IEC104_REMOTE_PARAMETER_ACTION_APPLIED; } if (!Example_Remote_Station(app, request)) { goto reject; } if (request->operation == IEC104_REMOTE_PARAMETER_OP_READ_AREA) { if (area == NULL) { return failure; } area->minimum = 0U; area->maximum = 4U; area->current = app->remote_area; return IEC104_REMOTE_PARAMETER_ACTION_APPLIED; } if (request->operation == IEC104_REMOTE_PARAMETER_OP_SWITCH_AREA) { ExampleRemoteConfig saved; /* 只选择已有设置,不复制或重置各区内容;真实暂存期间禁止切区。 * 非当前区仍可按请求SN读取或预置,当前配置由Current_Settings统一取值。 */ if (request->sn > 4U || stage->active) { return failure; } saved = Example_Remote_Config_Snapshot(app); saved.current_area = request->sn; if (!Example_Remote_Config_Commit(app, &saved)) { return failure; } Example_Remote_Report_Settings(app, "switch", request->sn); return IEC104_REMOTE_PARAMETER_ACTION_APPLIED; } if (request->operation == IEC104_REMOTE_PARAMETER_OP_PRESET) { ExampleRemoteValues candidate; if (request->first_frame) { if (stage->active) { goto reject; } memset(&candidate, 0, sizeof(candidate)); } else { if (!Example_Remote_Owner(stage, request)) { return failure; } candidate = stage->values; } if (request->sn > 4U || (!request->first_frame && stage->owner.sn != request->sn)) { goto reject; } /* 在局部候选副本上检查全帧,任一元素失败都不发布半帧暂存。 * 同一IOA重复出现按顺序覆盖;固定三项可写槽不随元素数增加,不会截断成功。 */ for (index = 0U; index < request->count; ++index) { IEC104_RemoteParameterElement_t element; size_t point; if (!IEC104_RemoteParameter_Get_Element(request, index, &element)) { goto reject; } point = Example_Remote_Index(element.ioa); if (point == 7U) { failure = IEC104_REMOTE_PARAMETER_ACTION_UNKNOWN_IOA; goto reject; } /* 前四项只读;电流死区不分区,非零SN不能访问,不能偷换成当前区。 */ if (point < 4U || (point == 4U && request->sn != 0U)) { goto reject; } if (point == 5U) { uint16_t value; if (element.tag != IEC104_REMOTE_PARAMETER_TAG_USHORT || element.length != 2U) { goto reject; } value = (uint16_t)((uint16_t)element.value[0] | ((uint16_t)element.value[1] << 8)); if (value > 3600U) { goto reject; } candidate.reset_seconds = value; candidate.reset_set = true; } else { uint32_t bits; float value; if (element.tag != IEC104_REMOTE_PARAMETER_TAG_FLOAT || element.length != 4U) { goto reject; } bits = (uint32_t)element.value[0] | ((uint32_t)element.value[1] << 8) | ((uint32_t)element.value[2] << 16) | ((uint32_t)element.value[3] << 24); memcpy(&value, &bits, sizeof(value)); if (!(value >= 0.0f && value <= (point == 4U ? 10.0f : 100.0f))) { goto reject; } if (point == 4U) { candidate.deadband = value; candidate.deadband_set = true; } else { candidate.x_time = value; candidate.x_time_set = true; } } } if (request->first_frame) { /* 只保留身份等纯值字段,绝不把回调期TLV指针带到下一帧或DISCARD。 */ stage->owner = *request; stage->owner._data = NULL; stage->owner._length = 0U; stage->owner.count = 0U; stage->active = true; } stage->values = candidate; return IEC104_REMOTE_PARAMETER_ACTION_APPLIED; } if (request->operation == IEC104_REMOTE_PARAMETER_OP_SOLIDIFY) { ExampleRemoteValues *candidate = &stage->values; ExampleRemoteConfig saved; if (!Example_Remote_Owner(stage, request)) { return failure; } if (request->sn > 4U || stage->owner.sn != request->sn || (candidate->deadband_set && (request->sn != 0U || !(candidate->deadband >= 0.0f && candidate->deadband <= 10.0f))) || (candidate->reset_set && candidate->reset_seconds > 3600U) || (candidate->x_time_set && !(candidate->x_time >= 0.0f && candidate->x_time <= 100.0f))) { goto reject; } /* 所有约束通过后才发布已固化值;事件循环串行,发布期间不调回调或推进Slave。 * 目标是非当前区时只保存该套设置,不隐式切区;当前区写入立即可被Current_Settings读取。 * deadband不分区,经SN0修改后对任何当前区立即可见。 * 本例标准Parameter未开ACK且访问不同物理参数;若产品共用存储, * 此处还须检查对方未提交的约束组预留,不能拿候选值当已生效值。 */ saved = Example_Remote_Config_Snapshot(app); if (candidate->deadband_set) { saved.deadband = candidate->deadband; } if (candidate->reset_set) { saved.reset_seconds[request->sn] = candidate->reset_seconds; } if (candidate->x_time_set) { saved.x_time[request->sn] = candidate->x_time; } if (!Example_Remote_Config_Commit(app, &saved)) { goto reject; } memset(stage, 0, sizeof(*stage)); Example_Remote_Report_Settings(app, "solidify", request->sn); return IEC104_REMOTE_PARAMETER_ACTION_APPLIED; } return failure; reject: /* 拒绝只清本请求所属批次;身份不匹配不能破坏另一实例或旧站仍欠清理的资源。 */ if (Example_Remote_Owner(stage, request)) { memset(stage, 0, sizeof(*stage)); } return failure; } /** * 功能:202读取请求SN的已固化值;可读取未选用的区,不使用Current_Settings偷换请求SN。 * 输入参数:context——调用方注册的回调上下文;request——仅在当前回调期间借用的协议请求;index——本次条目、点或逻辑槽的下标;ioa——信息体地址;frame——借用的远程参数回复帧。 * 输出参数:frame——借用的远程参数回复帧。 * 返回值:ADDED表示对象已加入回复,FULL表示当前帧已满,END表示全读遍历结束,UNKNOWN表示地址未知,ERROR表示身份或编码失败。 * 说明:纯读取且可重复:指定地址预检、正式组帧和发送WAIT后均可能重取同一下标。 * 不推进业务游标、不清计数;运行值允许变化,但整次请求的成员与index→IOA映射固定。 * 每次只向借用Frame加入一个元素,FULL表示本帧放不下,由模块在下一帧重取。 */ static IEC104_RemoteParameterLookupResult_t Example_Remote_Lookup(void *context, const IEC104_RemoteParameterRequest_t *request, size_t index, uint32_t ioa, IEC104_RemoteParameterFrame_t *frame) { ExampleApp *app = context; IEC104_RemoteParameterAddResult_t added; size_t point; if (!Example_Remote_Station(app, request) || request->sn > 4U) { return IEC104_REMOTE_PARAMETER_LOOKUP_ERROR; } if (request->count == 0U) { /* SN0含不分区参数与第0区动作定值;非零区只枚举末两项,避免错标不分区参数。 */ size_t count = request->sn == 0U ? 7U : 2U; if (index >= count) { return IEC104_REMOTE_PARAMETER_LOOKUP_END; } point = index + (request->sn == 0U ? 0U : 5U); ioa = example_remote_ioas[point]; } else { point = Example_Remote_Index(ioa); if (point == 7U) { return IEC104_REMOTE_PARAMETER_LOOKUP_UNKNOWN; } } if (request->sn != 0U && point < 5U) { return IEC104_REMOTE_PARAMETER_LOOKUP_ERROR; } switch (point) { case 0U: added = IEC104_RemoteParameter_Add_String(frame, ioa, "DTU", 3U); break; case 1U: added = IEC104_RemoteParameter_Add_String(frame, ioa, "Example", 7U); break; case 2U: { /* uint32十进制最多10字节;此处内容长度不含NUL,String写入器负责追加终止符。 */ char version[11]; int length = snprintf(version, sizeof(version), "%lu", (unsigned long)example_image.version); if (length <= 0 || (size_t)length >= sizeof(version)) { return IEC104_REMOTE_PARAMETER_LOOKUP_ERROR; } added = IEC104_RemoteParameter_Add_String(frame, ioa, version, (size_t)length); break; } case 3U: added = IEC104_RemoteParameter_Add_Uint(frame, ioa, example_image.crc); break; case 4U: added = IEC104_RemoteParameter_Add_Float(frame, ioa, app->remote_deadband); break; case 5U: added = IEC104_RemoteParameter_Add_UShort(frame, ioa, app->remote_reset_seconds[request->sn]); break; default: added = IEC104_RemoteParameter_Add_Float(frame, ioa, app->remote_x_time[request->sn]); break; } return added == IEC104_REMOTE_PARAMETER_ADD_OK ? IEC104_REMOTE_PARAMETER_LOOKUP_ADDED : added == IEC104_REMOTE_PARAMETER_ADD_FULL ? IEC104_REMOTE_PARAMETER_LOOKUP_FULL : IEC104_REMOTE_PARAMETER_LOOKUP_ERROR; } #endif /* 从首次执行到任务、预置、恢复及DISCARD全部结束,函数指针与app上下文身份保持稳定。 */ static const IEC104_RemoteParameterHandlers_t example_remote_handlers = { Example_Remote_Action, Example_Remote_Lookup }; /** * 功能:每轮网络推进、读空通知后调用;先处理期限/固定回复,再执行一次动作或至多一帧读取。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。 * 说明:OK不等于动作成功或主站收到;回调后故障也可能返回OK,故仍检查Process与faulted。 * WAIT交回外层网络等待,不能在此原地循环重取。 */ static bool Example_Step_RemoteParameter(ExampleApp *app) { IEC104_RemoteParameterExecuteResult_t result; if (app->remote_parameter == NULL) { return true; } if (!IEC104_RemoteParameter_Process(app->remote_parameter)) { return false; } result = IEC104_RemoteParameter_Execute_Next(app->remote_parameter, &example_remote_handlers, app); return result != IEC104_REMOTE_PARAMETER_EXECUTE_ERROR && IEC104_RemoteParameter_Process(app->remote_parameter) && IEC104_RemoteParameter_Get_Status(app->remote_parameter, &app->remote_status) && !app->remote_status.faulted; } /** * 功能:先Cancel、Close并分派生命周期,再进入仅清理路径;退出时绝不执行排队中的新业务。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。 * 说明:每实例最多欠一次DISCARD,原连接已结束也必须交付;app与暂存容器保留至清理完成。 * 状态查询失败或仍有恢复/任务均返回false,不假装Destroy前置条件已满足。 */ static bool Example_Drain_RemoteParameter(ExampleApp *app) { if (app->remote_parameter == NULL) { return true; } if (!IEC104_RemoteParameter_Get_Status(app->remote_parameter, &app->remote_status)) { return false; } if (app->remote_status.discard_pending && IEC104_RemoteParameter_Execute_Next(app->remote_parameter, &example_remote_handlers, app) != IEC104_REMOTE_PARAMETER_EXECUTE_OK) { return false; } return IEC104_RemoteParameter_Get_Status(app->remote_parameter, &app->remote_status) && !app->remote_status.discard_pending && !app->remote_status.preset_active && !app->remote_status.recovery_required && app->remote_status.pending_requests == 0U; } /* ============================================================================ * [SOFTWARE_UPGRADE] Type211控制;候选、预留激活任务与设备owner属于应用 * ============================================================================ */ /** * 功能:Slave地址不足以识别连接:实例编号防池槽复用,generation防重连后的TCP会话串接旧候选。 * 输入参数:a——第一个待比较值或身份;b——第二个待比较值或身份。 * 输出参数:无独立输出参数。 * 返回值:两份服务及连接身份相同时返回true,否则返回false。 * 说明:无。 */ static bool Example_Upgrade_Identity(const IEC104_SlaveEventIdentity_t *a, const IEC104_SlaveEventIdentity_t *b) { return a->slave == b->slave && a->instance_id == b->instance_id && a->generation == b->generation; } /** * 功能:OA保留在请求中但不作为会话键;相同CA注销重注册后仍须被station_id挡住。 * 输入参数:app——示例应用上下文;request——仅在当前回调期间借用的协议请求。 * 输出参数:无独立输出参数。 * 返回值:请求与当前升级所有者身份一致时返回true,否则返回false。 * 说明:无。 */ static bool Example_Upgrade_Owner(const ExampleApp *app, const IEC104_SoftwareUpgradeRequest_t *request) { const ExampleUpgradeDevice *device = &example_upgrade_device; return device->owned && device->context == app && Example_Upgrade_Identity(&device->owner.identity, &request->identity) && device->owner.common_address == request->common_address && device->owner.station_id == request->station_id && device->owner.session_serial == request->session_serial; } /** * 功能:锁存固件存储故障,交由主循环执行统一退出。 * 输入参数:app——示例应用上下文。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:无。 * 说明:I/O/提交故障不可就地重试;候选格式或许可拒绝不等同于持久存储损坏。 * 这里只锁存退出原因,不关闭文件、不改写协议结果;当前回调仍须走完自己的最终收尾。 */ static void Example_Upgrade_Store_Failed(ExampleApp *app) { if (!app->upgrade_store_failed) { fputs("UPGRADE_STORE failed; close and recover before retry.\n", stderr); } app->upgrade_store_failed = true; } /** * 功能:后端bool失败后的分类检查:只查询故障位,不推进恢复,也不据此重做失败的写入。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:存储实例健康或未启用持久存储时返回true,查询失败或已故障时返回false。 * 说明:返回true仅表示实例尚可继续受理合法动作;不会把前一次拒绝改判为成功。 */ static bool Example_Upgrade_Store_Healthy(ExampleApp *app) { IEC60870_FirmwareUpdateStatus_t status; if (app->upgrade_store == NULL) { return true; } if (!IEC60870_FirmwareUpdate_Get_Status(&app->upgrade_store->core, &status) || status.faulted) { Example_Upgrade_Store_Failed(app); return false; } return !app->upgrade_store_failed; } /** * 功能:Prepare_Boot只在一次启动/激活中调用一次。查询实际启动角色,不把TRIAL的旧current当作新映像。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:app借用的后端须已Open且保持串行;返回false后交统一退出清理,不在原实例循环重试安装。 * 宿主只安装文件,不执行负载;恢复回退与试运行分别记录事实,不能伪报升级成功。 * before用于辨认本次恢复动作,after用于核验真实结果;普通STABLE启动不新增升级行为日志。 */ static bool Example_Upgrade_Prepare_Boot(ExampleApp *app) { IEC60870_FirmwareUpdateStatus_t before, after; uint8_t slot; char text[IEC60870_USER_LOG_TEXT_MAX + 1U]; const char *phase; int length; if (app->upgrade_store == NULL) { return true; } if (!IEC60870_FirmwareUpdate_Get_Status(&app->upgrade_store->core, &before) || before.faulted || !Example_Upgrade_Store_Prepare_Boot(app->upgrade_store) || !IEC60870_FirmwareUpdate_Get_Status(&app->upgrade_store->core, &after) || after.faulted) { Example_Upgrade_Store_Failed(app); return false; } slot = after.state == IEC60870_FIRMWARE_UPDATE_TRIAL ? after.candidate_slot : after.current_slot; if ((after.state != IEC60870_FIRMWARE_UPDATE_TRIAL && after.state != IEC60870_FIRMWARE_UPDATE_STABLE) || slot >= IEC60870_FIRMWARE_UPDATE_SLOT_COUNT || after.images[slot].version == 0U || after.images[slot].size == 0U) { Example_Upgrade_Store_Failed(app); return false; } phase = after.state == IEC60870_FIRMWARE_UPDATE_TRIAL ? "BOOT_TRIAL" : (before.state == IEC60870_FIRMWARE_UPDATE_TRIAL || before.state == IEC60870_FIRMWARE_UPDATE_ROLLING_BACK || before.state == IEC60870_FIRMWARE_UPDATE_AUTHORIZED || before.state == IEC60870_FIRMWARE_UPDATE_INSTALLING) ? "BOOT_ROLLBACK" : NULL; if (phase != NULL) { length = snprintf(text, sizeof(text), "HOST_FILE UPGRADE %s version=%lu", phase, (unsigned long)after.images[slot].version); if (length <= 0 || (size_t)length >= sizeof(text)) { Example_Upgrade_Store_Failed(app); return false; } Example_User_Log_Append(app, 11U, 1U, IEC104_Net_Now_Ms(), text); } /* 核心可能拒绝损坏候选并成功恢复旧映像;恢复成功不等于本次升级成功。 * 运行期已领取任务必须确实启动冻结的目标,启动恢复路径没有内存任务则可接受旧current。 */ if (example_upgrade_device.context == app && example_upgrade_device.taken && (after.state != IEC60870_FIRMWARE_UPDATE_TRIAL || after.images[slot].version != example_upgrade_device.activation.version || after.images[slot].size != example_upgrade_device.activation.size - 16U || after.images[slot].crc != example_upgrade_device.activation.crc)) { return false; } return !app->user_log_failed; } /** * 功能:网络初始化及COI登记成功后才确认文件健康;current只在持久Confirm成功后发布。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:此健康条件只覆盖宿主文件与协议准备,不声明负载曾运行或真实设备完成自检。 * STABLE确认幂等;TRIAL确认可能在返回失败前已提交,因此失败只能重开核对角色。 * 已确认后的日志失败由外层停机处理,不撤销确认、不重复轮转,也不抹掉已发布版本。 */ static bool Example_Upgrade_Confirm_Boot(ExampleApp *app) { IEC60870_FirmwareUpdateDescriptor_t current; IEC60870_FirmwareUpdateStatus_t before; if (app->upgrade_store == NULL) { return true; } if (!IEC60870_FirmwareUpdate_Get_Status(&app->upgrade_store->core, &before) || before.faulted || !Example_Upgrade_Store_Confirm(app->upgrade_store) || !Example_Upgrade_Store_Current(app->upgrade_store, ¤t)) { Example_Upgrade_Store_Failed(app); return false; } example_image.version = current.version; example_image.crc = current.crc; if (before.state == IEC60870_FIRMWARE_UPDATE_TRIAL) { char text[96]; (void)snprintf(text, sizeof(text), "HOST_FILE UPGRADE HEALTH_CONFIRMED version=%lu", (unsigned long)current.version); Example_User_Log_Append(app, 11U, 1U, IEC104_Net_Now_Ms(), text); } return true; } /** * 功能:打开固件持久存储,并在首次使用时导入显式基线包。 * 输入参数:app——示例应用上下文;store——固件持久适配实例;directory——持久存储目录;seed——首次初始化的基线包路径或句柄。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:首次启动必须导入完整基线包;seed为NULL表示只恢复已有库,不能凭默认版本制造映像。 * store由调用者保活至Destroy,directory/seed仅在同步Open期间读取;失败也保留已取得的后端供关闭。 * 此处只恢复、准备并读取最后确认版,尚未确认TRIAL;后续监听与COI就绪后才调用Confirm_Boot。 */ static bool Example_Init_Upgrade_Store(ExampleApp *app, ExampleUpgrade *store, const char *directory, const char *seed) { IEC60870_FirmwareUpdateDescriptor_t current; if (app->software_upgrade == NULL || app->upgrade_store != NULL || !Example_Upgrade_Store_Open(store, directory, seed)) { return false; } app->upgrade_store = store; /* 后续任一步失败仍由统一Destroy关闭,不隐式撤销磁盘授权。 */ if (!Example_Upgrade_Prepare_Boot(app) || !Example_Upgrade_Store_Current(store, ¤t)) { return false; } example_image.version = current.version; example_image.crc = current.crc; return true; } /** * 功能:已失效的owner只能在最后一个文件handle归还且没有已领取任务时释放。 * 输入参数:无。 * 输出参数:无独立输出参数。 * 返回值:无。 * 说明:单调token从不清零,模块Destroy/Create也不能让旧应用工作重新匹配当前候选。 * 这里清掉的persistent_handoff只属于内存任务,不表示磁盘AUTH/TRIAL已经完成或取消。 */ static void Example_Upgrade_Release(void) { ExampleUpgradeDevice *device = &example_upgrade_device; if (!device->owned || !device->invalidated || device->file.active || device->taken) { return; } device->owned = false; device->context = NULL; device->reserved = device->committed = device->verified = false; device->persistent_handoff = false; device->state = EXAMPLE_UPGRADE_EMPTY; device->size = device->received = 0U; memset(&device->owner, 0, sizeof(device->owner)); memset(&device->activation, 0, sizeof(device->activation)); } /** * 功能:撤销或ABANDON先失效,旧write立即失败;存在文件handle时仅延后释放owner,不擦除其存储。 * 输入参数:无。 * 输出参数:无独立输出参数。 * 返回值:无。 * 说明:taken后所有权已移交激活任务,协议清理无权撤回;由Activation_Finished显式结束该任务。 */ static void Example_Upgrade_Invalidate(void) { ExampleUpgradeDevice *device = &example_upgrade_device; ExampleApp *app = device->context; if (!device->owned || device->taken) { return; } /* 领取后的提交结果即使不确定,也只能重开恢复;不能让退出清理擦除AUTH/TRIAL事实。 */ if (app->upgrade_store != NULL && !device->persistent_handoff && !Example_Upgrade_Store_Candidate_Abort(app->upgrade_store)) { Example_Upgrade_Store_Failed(app); } device->invalidated = true; device->reserved = device->committed = device->verified = false; device->state = EXAMPLE_UPGRADE_INVALID; memset(&device->activation, 0, sizeof(device->activation)); Example_Upgrade_Release(); } /** * 功能:11逐阶段记录已发生的升级动作;owner/transfer只是来源标识,绝不把ACK或END叫升级成功。 * 输入参数:app——示例应用上下文;phase——已发生的升级阶段名称。 * 输出参数:无独立输出参数。 * 返回值:无。 * 说明:RAM模式标SIMULATED;持久模式标HOST_FILE,只声明真实文件安装,避免冒充Flash刷写或硬件重启。 * phase由调用处提供本次事实,value=1表示行为发生;FILE_REJECTED/取消等阶段并不表示升级成功。 * 本函数不改变设备owner或候选状态,写日志失败仍须由原动作完成自己的释放。 */ static void Example_User_Log_Upgrade(ExampleApp *app, const char *phase) { char text[IEC60870_USER_LOG_TEXT_MAX + 1U]; ExampleUpgradeDevice *device = &example_upgrade_device; int length; if (app->user_log == NULL) { return; } length = snprintf(text, sizeof(text), "%s UPGRADE %s owner=%llu transfer=%llu version=%lu", app->upgrade_store == NULL ? "SIMULATED" : "HOST_FILE", phase, (unsigned long long)device->owner_token, (unsigned long long)device->transfer_token, (unsigned long)device->target_version); if (length <= 0 || (size_t)length >= sizeof(text)) { Example_User_Log_Result(app, IEC60870_USER_LOG_INVALID); return; } Example_User_Log_Append(app, 11U, 1U, IEC104_Net_Now_Ms(), text); } /** * 功能:按字节累计CRC-32/ISO-HDLC;仅覆盖负载,不包含16字节工程包头。 * 输入参数:crc——跨片段CRC累积值;data——字节数据缓冲;length——本次数据或名称的有效字节数。 * 输出参数:无独立输出参数。 * 返回值:可继续处理后续片段的CRC中间状态,最终异或在提交时执行。 * 说明:OPEN置初值0xFFFFFFFF,函数保留中间值供跨段续算,COMMIT才异或0xFFFFFFFF并比较包头期望值。 */ static uint32_t Example_Upgrade_Crc(uint32_t crc, const uint8_t *data, uint32_t length) { uint32_t index; for (index = 0U; index < length; ++index) { unsigned bit; crc ^= data[index]; for (bit = 0U; bit < 8U; ++bit) { crc = (crc >> 1) ^ ((crc & 1U) != 0U ? UINT32_C(0xEDB88320) : 0U); } } return crc; } /** * 功能:包头采用小端且可能未对齐;显式逐字节解码,调用者先保证完整四字节可读。 * 输入参数:bytes——字节数据缓冲。 * 输出参数:无独立输出参数。 * 返回值:解码后的32位无符号整数。 * 说明:无。 */ static uint32_t Example_Upgrade_U32(const uint8_t *bytes) { return (uint32_t)bytes[0] | ((uint32_t)bytes[1] << 8) | ((uint32_t)bytes[2] << 16) | ((uint32_t)bytes[3] << 24); } /** * 功能:文件服务必须先创建;这里只绑定协议实例,设备owner和映像记录不随实例初始化清零。 * 输入参数:app——示例应用上下文。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:无。 */ static inline bool Example_Init_SoftwareUpgrade(ExampleApp *app) { IEC104_SoftwareUpgradeConfig_t config; if (app->software_upgrade != NULL || app->file_service == NULL) { return false; } IEC104_SoftwareUpgrade_Config_Default(&config); app->software_upgrade = IEC104_SoftwareUpgrade_Create(app->slave, &config); return app->software_upgrade != NULL; } /** * 功能:START只取得设备owner;END仅冻结候选和预留任务,不能在协议动作内重启。 * 输入参数:context——调用方注册的回调上下文;request——仅在当前回调期间借用的协议请求。 * 输出参数:无独立输出参数。 * 返回值:ACCEPT表示本阶段升级操作获准并已完成对应应用处理,REJECT表示会话、所有者或候选状态不允许。 * 说明:真实与TEST由模块隔离;本回调从不收到TEST。REJECT分支不改变应用状态。 */ static IEC104_SoftwareUpgradeDecision_t Example_Upgrade_Action(void *context, const IEC104_SoftwareUpgradeRequest_t *request) { ExampleApp *app = context; ExampleUpgradeDevice *device = &example_upgrade_device; if (request->operation == IEC104_SOFTWARE_UPGRADE_OP_ABANDON) { /* 通知可在连接失效后到达,只按原START归属清理,不要求原站点仍注册。 */ if (Example_Upgrade_Owner(app, request) && !device->invalidated && !device->taken) { Example_User_Log_Upgrade(app, "ABANDON"); Example_Upgrade_Invalidate(); } return IEC104_SOFTWARE_UPGRADE_DECISION_ACCEPT; } if (request->operation == IEC104_SOFTWARE_UPGRADE_OP_START) { /* 所有Slave在同一串行上下文竞争这一个owner;旧handle未收尾也不能覆盖候选。 */ if (app->quiescing || app->upgrade_store_failed || device->owned || device->file.active || device->owner_token == UINT64_MAX || !IEC104_Station_Is_Registered(&app->station) || request->station_id != IEC104_Station_Get_Id(&app->station) || request->common_address != IEC104_Station_Get_Common_Address(&app->station)) { return IEC104_SOFTWARE_UPGRADE_DECISION_REJECT; } ++device->owner_token; device->context = app; device->owner = *request; device->owned = true; device->invalidated = device->committed = device->verified = device->reserved = device->taken = false; device->persistent_handoff = false; device->state = EXAMPLE_UPGRADE_EMPTY; device->size = device->received = 0U; device->target_version = 0U; Example_User_Log_Upgrade(app, "START"); return IEC104_SOFTWARE_UPGRADE_DECISION_ACCEPT; } if (!Example_Upgrade_Owner(app, request) || device->invalidated || device->taken) { return IEC104_SOFTWARE_UPGRADE_DECISION_REJECT; } if (request->operation == IEC104_SOFTWARE_UPGRADE_OP_CANCEL) { Example_User_Log_Upgrade(app, "CANCEL"); Example_Upgrade_Invalidate(); return IEC104_SOFTWARE_UPGRADE_DECISION_ACCEPT; } if (request->operation != IEC104_SOFTWARE_UPGRADE_OP_END || device->file.active || !device->committed || !device->verified || device->state != EXAMPLE_UPGRADE_VERIFIED || device->reserved || device->received != device->size || device->target_version <= example_image.version) { return IEC104_SOFTWARE_UPGRADE_DECISION_REJECT; } if (app->upgrade_store != NULL) { IEC60870_FirmwareUpdateDescriptor_t candidate; /* 核对COMMIT发布的同一候选;END只冻结应用描述,核心仍为VERIFIED,尚未获得持久授权。 * 候选size仅含负载,而应用size含16字节头;比较前已由接收路径保证整包最小长度。 */ if (!Example_Upgrade_Store_Candidate_Info(app->upgrade_store, &candidate) || candidate.version != device->target_version || candidate.crc != device->payload_crc || candidate.size != device->size - 16U) { (void)Example_Upgrade_Store_Healthy(app); return IEC104_SOFTWARE_UPGRADE_DECISION_REJECT; } } /* 当前COMMIT完整且验证通过才接受END;固定此transfer的目标,后续不能改取“最新文件”。 * 本例只有一个内嵌任务槽,reserved检查就是预留准入,不涉及领取后的堆分配。 */ device->activation.owner_token = device->owner_token; device->activation.transfer_token = device->transfer_token; device->activation.version = device->target_version; device->activation.crc = device->payload_crc; device->activation.size = device->size; device->reserved = true; device->state = EXAMPLE_UPGRADE_FROZEN; Example_User_Log_Upgrade(app, "END_RESERVED"); return IEC104_SOFTWARE_UPGRADE_DECISION_ACCEPT; } /** * 功能:每轮先冻结已有ACK事实,再执行一项请求;实际领取由统一仲裁器完成。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。 * 说明:无。 */ static bool Example_Step_SoftwareUpgrade(ExampleApp *app) { IEC104_SoftwareUpgradeExecuteResult_t result; if (app->software_upgrade == NULL) { return true; } if (!IEC104_SoftwareUpgrade_Process(app->software_upgrade)) { return false; } result = IEC104_SoftwareUpgrade_Execute_Next(app->software_upgrade, Example_Upgrade_Action, app); return result != IEC104_SOFTWARE_UPGRADE_EXECUTE_ERROR && !app->upgrade_store_failed && IEC104_SoftwareUpgrade_Process(app->software_upgrade) && IEC104_SoftwareUpgrade_Get_Status(app->software_upgrade, &app->upgrade_status) && !app->upgrade_status.faulted; } /** * 功能:成功发布发生在协议Init与COI登记之后、重新处理网络之前;失败保持原映像记录。 * 输入参数:app——示例应用上下文;success——激活过程是否成功。 * 输出参数:无独立输出参数。 * 返回值:无。 * 说明:版本和CRC在同一串行上下文确认后发布,COMMIT/END/ACK都不会提前发布。 * 持久模式已经由Confirm_Boot读取确认版,这里只结算任务;不能再用activation描述冒充确认结果。 * 领取后的候选不受模块Cancel影响,只有本应用任务完成或失败才解除冻结;重复收尾无操作。 */ static void Example_Upgrade_Activation_Finished(ExampleApp *app, bool success) { ExampleUpgradeDevice *device = &example_upgrade_device; if (!device->owned || device->context != app || !device->taken) { return; } if (success) { if (app->upgrade_store == NULL) { ExampleImage image; image.version = device->activation.version; image.crc = device->activation.crc; example_image = image; } ++device->succeeded; } else { ++device->failed; } Example_User_Log_Upgrade(app, success ? "ACTIVATION_SUCCESS" : "ACTIVATION_FAILED"); /* 映像发布结果已经确定,日志失败只能触发停机,仍须归还taken及候选;重复收尾不得改写成功结果。 */ device->taken = false; Example_Upgrade_Invalidate(); } /* ============================================================================ * [FILE_SERVICE] Type210目录快照、内存只读文件、TEMP事务和BUSY接入 * ============================================================================ */ /* 这些只是传输演示内容,不声明符合COMTRADE或现场MSG文件格式;名称及大小由应用定义。 */ static const uint8_t example_file_soe[] = "SOE example: breaker closed\n"; static const uint8_t example_file_ulog[] = "ULOG example: service started\n"; static const struct { const char *directory, *name, *path; const uint8_t *data; size_t size; } example_files[] = { {"HISTORY/SOE", "soe.msg", "HISTORY/SOE/soe.msg", example_file_soe, sizeof(example_file_soe) - 1U}, {"HISTORY/ULOG", "ulog.msg", "HISTORY/ULOG/ulog.msg", example_file_ulog, sizeof(example_file_ulog) - 1U} }; /** * 功能:按显式长度匹配线上名称与本地字符串常量,区分大小写且不读取线上结束符。 * 输入参数:name——文件名或显式长度的协议名称;length——本次数据或名称的有效字节数;literal——本地NUL结尾名称常量。 * 输出参数:无独立输出参数。 * 返回值:显式长度名称与本地常量完全相同时返回true,否则返回false。 * 说明:空名称只匹配空常量;非空名称要求name有效。 */ static bool Example_File_Name_Is(const uint8_t *name, uint8_t length, const char *literal) { size_t expected = strlen(literal); /* literal仅来自本文件的常量,线上名称没有结束符。 */ return (size_t)length == expected && (expected == 0U || (name != NULL && memcmp(name, literal, expected) == 0)); } /** * 功能:示例只允许TEMP下的单层ASCII文件名,不做路径归一化或宿主路径映射。 * 输入参数:name——文件名或显式长度的协议名称;length——本次数据或名称的有效字节数。 * 输出参数:无独立输出参数。 * 返回值:名称属于允许的TEMP单层文件名时返回true,否则返回false。 * 说明:因而../、反斜线、绝对路径、NUL及编码别名都无法触及升级/运行资源。 * upgrade.bin由独立升级入口处理;TEMP/upgrade.bin只是独立TEMP文件,不映射候选。 * 叶名称还须能放入目录项,因此上限采用目录名容量,而非激活报文的完整路径容量。 */ static bool Example_File_Temp_Name(const uint8_t *name, uint8_t length) { size_t index; if (name == NULL || length <= 5U || (size_t)length > 5U + IEC104_FILE_SERVICE_MAX_DIRECTORY_NAME || memcmp(name, "TEMP/", 5U) != 0 || name[5] == '.') { return false; } for (index = 5U; index < length; ++index) { uint8_t ch = name[index]; if (!((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9') || ch == '_' || ch == '-' || ch == '.')) { return false; } } return true; } /** * 功能:清理按保存的原归属匹配;站点注销、重连后仍允许清理旧handle,不能改查新注册站。 * 输入参数:resource——应用侧文件资源及归属身份;request——仅在当前回调期间借用的协议请求。 * 输出参数:无独立输出参数。 * 返回值:文件资源保存的身份与请求完全匹配时返回true,否则返回false。 * 说明:handle区分同一站的连续OPEN,模块instance_id与Slave的identity.instance_id分别校验; * OA只用于报文来源诊断,不把它当作访问权限或资源所有权凭证。 */ static bool Example_File_Owner(const ExampleFileResource *resource, const IEC104_FileServiceRequest_t *request) { const IEC104_FileServiceRequest_t *owner = &resource->owner; return resource->active && owner->handle == request->handle && owner->identity.slave == request->identity.slave && owner->identity.instance_id == request->identity.instance_id && owner->identity.generation == request->identity.generation && owner->instance_id == request->instance_id && owner->station_id == request->station_id && owner->common_address == request->common_address && owner->test == request->test; } /** * 功能:只分配空闲资源并复制身份,不保存协议原文中的名称指针。 * 输入参数:files——应用文件存储与目录快照;resource——应用侧文件资源及归属身份;request——仅在当前回调期间借用的协议请求;open——文件打开结果回写位置。 * 输出参数:resource——本次操作更新的实例或工作区;open——文件打开结果回写位置。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:token耗尽拒绝新OPEN;不能回绕后让迟到CLOSE/ABORT匹配新资源。 */ static bool Example_File_Open_Resource(ExampleFileStore *files, ExampleFileResource *resource, const IEC104_FileServiceRequest_t *request, IEC104_FileServiceOpen_t *open) { if (resource->active || files->next_handle == UINTPTR_MAX) { return false; } resource->owner = *request; resource->owner.name = NULL; resource->owner.name_length = 0U; resource->owner.handle = ++files->next_handle; resource->active = true; open->handle = resource->owner.handle; return true; } /** * 功能:保留升级目标只能绑定当前OPEN会话;读取状态不推进任何协议模块。 * 输入参数:app——示例应用上下文;request——仅在当前回调期间借用的协议请求;open——文件打开结果回写位置。 * 输出参数:open——文件打开结果回写位置。 * 返回值:OK表示上传资源已建立,NAME_UNSUPPORTED表示目标或所有者不支持,SIZE_OUT_OF_RANGE表示声明大小越界,FAILED表示资源或存储准备失败。 * 说明:完整身份、CA、站点注册编号和会话序号同时匹配owner,WAIT_ACK/已冻结时禁止重写。 * 身份/状态拒绝不改变候选;新OPEN取得handle后,持久模式先撤销旧未授权候选,再接收新传输。 * 后端此时失败须归还刚取得的handle,并使旧验证标记失效,不能再END已被撤销的包。 */ static IEC104_FileServiceResult_t Example_Upgrade_File_Open(ExampleApp *app, const IEC104_FileServiceRequest_t *request, IEC104_FileServiceOpen_t *open) { ExampleUpgradeDevice *device = &example_upgrade_device; IEC104_SoftwareUpgradeStatus_t status; if (app->software_upgrade == NULL) { return IEC104_FILE_SERVICE_RESULT_NAME_UNSUPPORTED; } /* 先限制整包至少16字节头加1字节负载,后续用size-16核对,避免头长加负载长度回绕。 */ if (request->file_size < 17U || request->file_size > (app->upgrade_store == NULL ? EXAMPLE_UPGRADE_BYTES : EXAMPLE_UPGRADE_PACKAGE_MAX)) { return IEC104_FILE_SERVICE_RESULT_SIZE_OUT_OF_RANGE; } if (request->test || app->quiescing || app->upgrade_store_failed || !device->owned || device->context != app || device->invalidated || device->taken || device->reserved || device->file.active || device->state == EXAMPLE_UPGRADE_VERIFYING || device->transfer_token == UINT64_MAX || !IEC104_SoftwareUpgrade_Get_Status(app->software_upgrade, &status) || status.faulted || status.session_state != IEC104_SOFTWARE_UPGRADE_SESSION_OPEN || !Example_Upgrade_Identity(&status.session_identity, &request->identity) || !Example_Upgrade_Identity(&device->owner.identity, &request->identity) || status.session_common_address != request->common_address || status.session_station_id != request->station_id || status.session_serial != device->owner.session_serial || device->owner.common_address != request->common_address || device->owner.station_id != request->station_id || !Example_File_Open_Resource(&app->files, &device->file, request, open)) { return IEC104_FILE_SERVICE_RESULT_FAILED; } if (app->upgrade_store != NULL && (!Example_Upgrade_Store_Candidate_Abort(app->upgrade_store) || !Example_Upgrade_Store_Candidate_Open(app->upgrade_store, request->file_size))) { /* OPEN被拒绝不会再收到最终回调,本次刚分配的handle必须立即归还。 */ device->file.active = false; device->committed = device->verified = false; device->state = EXAMPLE_UPGRADE_INVALID; (void)Example_Upgrade_Store_Healthy(app); return IEC104_FILE_SERVICE_RESULT_FAILED; } /* 文件句柄与两个token同时固定这一轮接收;重传产生新transfer,旧最终回调不能终结新候选。 */ ++device->transfer_token; device->file_owner_token = device->owner_token; device->file_transfer_token = device->transfer_token; device->committed = device->verified = false; device->state = EXAMPLE_UPGRADE_RECEIVING; device->size = request->file_size; device->received = device->target_version = device->payload_crc = 0U; device->rolling_crc = UINT32_C(0xFFFFFFFF); return IEC104_FILE_SERVICE_RESULT_OK; } /** * 功能:最终回调恰一次;COMMIT失败自行归还handle,不等待不会到来的ABORT。 * 输入参数:app——示例应用上下文;request——仅在当前回调期间借用的协议请求。 * 输出参数:无独立输出参数。 * 返回值:归属正确且COMMIT有效或请求为ABORT_WRITE时返回OK;归属错误或提交校验失败返回FAILED。 * 说明:单缓冲不允许新OPEN跨越旧handle,因此旧token清理不会覆盖另一候选。 */ static IEC104_FileServiceResult_t Example_Upgrade_File_Finish(ExampleApp *app, const IEC104_FileServiceRequest_t *request) { ExampleUpgradeDevice *device = &example_upgrade_device; IEC60870_FirmwareUpdateDescriptor_t candidate; bool valid; if (!Example_File_Owner(&device->file, request) || device->context != app) { return IEC104_FILE_SERVICE_RESULT_FAILED; } /* 逐段传输校验不等于整包校验;实际累计CRC必须与主站包头给出的期望CRC比较。 * ABORT也走此出口归还handle,但不发布候选;被取消的旧COMMIT安全失败并完成自己的收尾。 */ valid = request->call == IEC104_FILE_SERVICE_CALL_COMMIT && device->owned && !device->invalidated && device->file_owner_token == device->owner_token && device->file_transfer_token == device->transfer_token && device->state == EXAMPLE_UPGRADE_RECEIVING && device->size >= 17U && device->received == device->size && request->transferred == device->size; if (app->upgrade_store != NULL) { /* COMMIT的成功凭证来自磁盘同步和读回校验;不以最后一段到齐代替完整性检查。 * CRC/许可拒绝仍可Abort后重传;存储故障会闭锁,但两者都必须归还原文件handle。 */ valid = valid && Example_Upgrade_Store_Candidate_Finish(app->upgrade_store) && Example_Upgrade_Store_Candidate_Info(app->upgrade_store, &candidate) && candidate.version > example_image.version && candidate.size == device->size - 16U; if (!valid && !Example_Upgrade_Store_Candidate_Abort(app->upgrade_store)) { (void)Example_Upgrade_Store_Healthy(app); } } else { valid = valid && memcmp(device->bytes, "I104", 4U) == 0 && Example_Upgrade_U32(device->bytes + 8U) == device->size - 16U && Example_Upgrade_U32(device->bytes + 4U) > example_image.version && (device->rolling_crc ^ UINT32_C(0xFFFFFFFF)) == Example_Upgrade_U32(device->bytes + 12U); } device->file.active = false; device->committed = device->verified = valid; if (valid) { device->target_version = app->upgrade_store == NULL ? Example_Upgrade_U32(device->bytes + 4U) : candidate.version; device->payload_crc = app->upgrade_store == NULL ? Example_Upgrade_U32(device->bytes + 12U) : candidate.crc; device->state = EXAMPLE_UPGRADE_VERIFIED; } else { device->state = EXAMPLE_UPGRADE_INVALID; } Example_User_Log_Upgrade(app, request->call == IEC104_FILE_SERVICE_CALL_ABORT_WRITE ? "FILE_ABORT" : valid ? "FILE_VERIFIED" : "FILE_REJECTED"); Example_Upgrade_Release(); return valid || request->call == IEC104_FILE_SERVICE_CALL_ABORT_WRITE ? IEC104_FILE_SERVICE_RESULT_OK : IEC104_FILE_SERVICE_RESULT_FAILED; } /** * 功能:写入只接受OPEN捕获的handle和token,不重新解释用途;必须连续且不越过声明总长。 * 输入参数:app——示例应用上下文;request——仅在当前回调期间借用的协议请求;offset——从起点计算的字节偏移;data——字节数据缓冲;length——本次数据或名称的有效字节数;last——是否为本次上传的末段。 * 输出参数:无独立输出参数。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:坏包使当前候选失效但不释放handle,文件服务随后仍须交付一次最终收尾。 */ static bool Example_Upgrade_File_Write(ExampleApp *app, const IEC104_FileServiceRequest_t *request, uint32_t offset, const uint8_t *data, uint16_t length, bool last) { ExampleUpgradeDevice *device = &example_upgrade_device; /* 包头可跨多个数据段;skip超过本段长度时整段不计CRC,跨越边界的段仅累计尾部负载。 */ uint32_t skip = offset < 16U ? 16U - offset : 0U; if (!Example_File_Owner(&device->file, request) || device->context != app || !device->owned || device->invalidated || request->test || device->state != EXAMPLE_UPGRADE_RECEIVING || device->file_owner_token != device->owner_token || device->file_transfer_token != device->transfer_token || offset != device->received || offset > device->size || length > device->size - offset || (last && length != device->size - offset) || (length != 0U && data == NULL)) { return false; } if (app->upgrade_store != NULL) { /* 持久模式只把当前小段交给后端;64KB模拟缓冲保持不动,整包大小不占RAM。 * offset/received含包头,后端自行拆头;只有整段成功才推进应用偏移,失败不原位重试。 */ if (!Example_Upgrade_Store_Candidate_Write(app->upgrade_store, offset, data, length)) { device->state = EXAMPLE_UPGRADE_INVALID; (void)Example_Upgrade_Store_Healthy(app); return false; } device->received += length; return true; } if (length != 0U) { memcpy(device->bytes + offset, data, length); } if (skip < length) { device->rolling_crc = Example_Upgrade_Crc(device->rolling_crc, data + skip, length - skip); } device->received += length; /* 收满16字节前不读包头字段;声明总长已在OPEN限界,size-16不会下溢。 */ if (device->received >= 16U && (memcmp(device->bytes, "I104", 4U) != 0 || Example_Upgrade_U32(device->bytes + 8U) != device->size - 16U || Example_Upgrade_U32(device->bytes + 4U) <= example_image.version)) { device->state = EXAMPLE_UPGRADE_INVALID; return false; } return true; } /** * 功能:快照保存名称/大小/时标的值副本;即使之后TEMP被提交替换,list同一下标仍保持一致。 * 输入参数:files——应用文件存储与目录快照;name——文件名或显式长度的协议名称;length——本次数据或名称的有效字节数;size——本次数据的字节数;time——输入CP56日历时标。 * 输出参数:files——本次操作更新的实例或工作区。 * 返回值:无。 * 说明:调用点只枚举固定目录,最多两项;扩展演示清单时须同步核对固定快照容量,不能静默截断。 */ static void Example_File_Entry(ExampleFileStore *files, const uint8_t *name, uint8_t length, uint32_t size, const IEC60870_CP56Time2a_t *time) { ExampleFileDirectoryEntry *entry = &files->entries[files->entry_count++]; memcpy(entry->name, name, length); entry->name_length = length; entry->size = size; entry->time = *time; } /** * 功能:首次创建时固定演示文件的本地日历;时钟不可读则初始化失败,不伪造有效的文件时标。 * 输入参数:app——示例应用上下文。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:协议复位复用本模块和存储,不重新清空已经提交的TEMP文件。 */ static inline bool Example_Init_FileService(ExampleApp *app) { IEC104_FileServiceConfig_t config; IEC60870_ClockValue_t clock; uint8_t encoded[IEC60870_CP56_LEN]; if (app->file_service != NULL || IEC60870_Clock_Read(&clock) == 0) { return false; } memset(&app->files, 0, sizeof(app->files)); app->files.startup_time.time = clock.time; app->files.startup_time.is_invalid = clock.is_invalid; if (!IEC60870_Time_To_CP56(&app->files.startup_time, encoded, sizeof(encoded))) { return false; } IEC104_FileService_Config_Default(&config); app->file_service = IEC104_FileService_Create(app->slave, &config); return app->file_service != NULL; } /** * 功能:OPEN只准备快照或暂存;COMMIT在同一串行循环内发布,返回前释放暂存所有权。 * 输入参数:context——调用方注册的回调上下文;request——仅在当前回调期间借用的协议请求;open——文件打开结果回写位置。 * 输出参数:open——文件打开结果回写位置。 * 返回值:OK表示请求阶段处理成功;NAME_UNSUPPORTED、SIZE_OUT_OF_RANGE分别表示目标不支持和大小越界,FAILED表示身份、资源或存储处理失败。 * 说明:失败COMMIT也自行清理,协议不会再补ABORT;清理动作不要求原站仍注册。 * 历史目录和下载由独立适配器持有快照,录波借用冻结记录;owner 校验通过后才释放相应资源。 */ static IEC104_FileServiceResult_t Example_File_Action(void *context, const IEC104_FileServiceRequest_t *request, IEC104_FileServiceOpen_t *open) { ExampleApp *app = context; ExampleFileStore *files = &app->files; size_t index; switch (request->call) { case IEC104_FILE_SERVICE_CALL_CLOSE_DIRECTORY: if (!Example_File_Owner(&files->directory, request)) { return IEC104_FILE_SERVICE_RESULT_FAILED; } /* 历史和日志目录结束枚举后仍保留已列出的XML版本,供随后OPEN_READ取得一致文件。 * 必须先匹配原owner;日志故障也不能跳过关闭或误清另一请求的缓存。 */ if (files->directory_history) { Example_History_Directory_Close(app->history); } files->directory_history = false; if (files->directory_user_log) { Example_User_Log_Directory_Close(app->user_log); } files->directory_user_log = false; if (files->directory_energy) { Example_Energy_Freeze_Directory_Close(app->energy); } files->directory_energy = false; files->directory.active = false; files->entry_count = 0U; return IEC104_FILE_SERVICE_RESULT_OK; case IEC104_FILE_SERVICE_CALL_CLOSE_READ: if (!Example_File_Owner(&files->read, request)) { return IEC104_FILE_SERVICE_RESULT_FAILED; } /* 历史和日志读句柄各自拥有独立临时副本;关闭不影响目录缓存,随后清除本次数据源标志。 */ if (files->read_history) { Example_History_Read_Close(app->history); } files->read_history = false; if (files->read_user_log) { Example_User_Log_Read_Close(app->user_log); } files->read_user_log = false; if (files->read_energy) { Example_Energy_Freeze_Read_Close(app->energy); } files->read_energy = false; files->read.active = false; files->read_temp = false; files->read_data = NULL; files->read_recording = 0U; files->read_size = 0U; return IEC104_FILE_SERVICE_RESULT_OK; case IEC104_FILE_SERVICE_CALL_ABORT_WRITE: if (Example_File_Owner(&example_upgrade_device.file, request)) { return Example_Upgrade_File_Finish(app, request); } if (!Example_File_Owner(&files->stage, request)) { return IEC104_FILE_SERVICE_RESULT_FAILED; } files->stage.active = false; files->stage_received = 0U; return IEC104_FILE_SERVICE_RESULT_OK; case IEC104_FILE_SERVICE_CALL_COMMIT: if (Example_File_Owner(&example_upgrade_device.file, request)) { return Example_Upgrade_File_Finish(app, request); } if (!Example_File_Owner(&files->stage, request)) { return IEC104_FILE_SERVICE_RESULT_FAILED; } /* 失败前未触碰已提交区;成功发布仅一次,不以随后确认WAIT/丢失回滚。 */ files->stage.active = false; if (files->stage_received != files->stage_size || files->read_temp) { files->stage_received = 0U; return IEC104_FILE_SERVICE_RESULT_FAILED; } /* 先保存完整名称/时标/内容快照,失败时磁盘与RAM均保留旧文件。 * 复制中途没有其他消费者观察此区;成功后确认丢失也不能回滚已提交文件。 */ if (app->config_path != NULL) { ExampleTempConfig candidate = {0}; ExampleConfigResult result; candidate.present = true; candidate.name = files->stage_name; candidate.name_length = files->stage_name_length; candidate.bytes = files->stage_bytes; candidate.size = files->stage_size; candidate.time = files->startup_time; result = Example_Config_Store(app, NULL, &candidate); if (result != EXAMPLE_CONFIG_OK) { fprintf(stderr, "FILE_CONFIG save failed: %s\n", Example_Config_Result_Name(result)); files->stage_received = 0U; return IEC104_FILE_SERVICE_RESULT_FAILED; } puts("FILE_CONFIG SAVED"); fflush(stdout); } memcpy(files->file_bytes, files->stage_bytes, files->stage_size); memcpy(files->file_name, files->stage_name, files->stage_name_length); files->file_name_length = files->stage_name_length; files->file_size = files->stage_size; files->file_time = files->startup_time; files->present = true; files->stage_received = 0U; return IEC104_FILE_SERVICE_RESULT_OK; default: break; } /* 新OPEN只允许当前已注册站;上面的收尾先按旧owner处理,避免注销后无法归还旧资源。 */ if (open == NULL || request->identity.slave != app->slave || !IEC104_Station_Is_Registered(&app->station) || request->station_id != IEC104_Station_Get_Id(&app->station) || request->common_address != IEC104_Station_Get_Common_Address(&app->station)) { return IEC104_FILE_SERVICE_RESULT_FAILED; } if (request->call == IEC104_FILE_SERVICE_CALL_OPEN_DIRECTORY) { if (!Example_File_Open_Resource(files, &files->directory, request, open)) { return IEC104_FILE_SERVICE_RESULT_FAILED; } files->entry_count = 0U; files->directory_exists = false; files->directory_history = false; files->directory_user_log = false; files->directory_energy = false; if (app->energy != NULL && (Example_File_Name_Is(request->name, request->name_length, "HISTORY/FRZ") || Example_File_Name_Is(request->name, request->name_length, "HISTORY/FLOWREV"))) { if (!Example_Energy_Freeze_Directory_Open(app->energy, request->name, request->name_length)) { files->directory.active = false; return IEC104_FILE_SERVICE_RESULT_FAILED; } files->directory_energy = files->directory_exists = true; return IEC104_FILE_SERVICE_RESULT_OK; } /* 运行日志单独启用;目录按名称匹配,目录编号不参与后端路由。 * 已登记协议资源后才冻结文件;失败撤回本次active,不能让后续LIST读取半份清单。 */ if (app->user_log != NULL && Example_File_Name_Is(request->name, request->name_length, "HISTORY/ULOG")) { if (!Example_User_Log_Directory_Open(app->user_log, request->name, request->name_length)) { files->directory.active = false; return IEC104_FILE_SERVICE_RESULT_FAILED; } files->directory_user_log = files->directory_exists = true; return IEC104_FILE_SERVICE_RESULT_OK; } /* 历史模式按目录名切换到持久数据;空目录继续代表 SOE,不依赖主站目录编号。 * 适配器冻结清单,协议随后使用条目时间筛选,不能在 list 重试时重建。 */ if (app->history != NULL && (request->name_length == 0U || Example_File_Name_Is(request->name, request->name_length, "HISTORY/SOE") || Example_File_Name_Is(request->name, request->name_length, "HISTORY/CO") || Example_File_Name_Is(request->name, request->name_length, "HISTORY/EXV") || Example_File_Name_Is(request->name, request->name_length, "HISTORY/FIXPT"))) { const uint8_t *name = request->name_length == 0U ? (const uint8_t *)"HISTORY/SOE" : request->name; size_t length = request->name_length == 0U ? strlen("HISTORY/SOE") : request->name_length; if (!Example_History_Directory_Open(app->history, name, length)) { files->directory.active = false; return IEC104_FILE_SERVICE_RESULT_FAILED; } files->directory_history = files->directory_exists = true; return IEC104_FILE_SERVICE_RESULT_OK; } /* 默认目录固定为HISTORY/SOE。时间过滤交给协议模块,快照不因重试或过滤而重建。 */ for (index = 0U; index < sizeof(example_files) / sizeof(example_files[0]); ++index) { if ((request->name_length == 0U && index == 0U) || Example_File_Name_Is(request->name, request->name_length, example_files[index].directory)) { files->directory_exists = true; Example_File_Entry(files, (const uint8_t *)example_files[index].path, (uint8_t)strlen(example_files[index].path), (uint32_t)example_files[index].size, &files->startup_time); } } if (Example_File_Name_Is(request->name, request->name_length, "TEMP")) { files->directory_exists = true; if (files->present) { Example_File_Entry(files, files->file_name, files->file_name_length, files->file_size, &files->file_time); } } if (Example_File_Name_Is(request->name, request->name_length, "COMTRADE")) { files->directory_exists = true; /* 两个文件均落盘且故障简报已入队后才一起列出;名称包含COMTRADE/,供主站原样回传。 * 清单复制到本次目录快照,后续list重取同一下标时不能看到变化中的条目。 */ if (app->recording != NULL && app->recording->saved && app->recording->published) { for (index = 0U; index < 2U; ++index) { Example_File_Entry(files, (const uint8_t *)app->recording->paths[index], (uint8_t)strlen(app->recording->paths[index]), index == 0U ? (uint32_t)app->recording->cfg_size : app->recording->dat_size, &app->recording->trigger_time); } } } /* 不存在的目录也成功持有本次快照;list返回NO_DIRECTORY后仍由协议交付一次CLOSE。 */ return IEC104_FILE_SERVICE_RESULT_OK; } if (request->call == IEC104_FILE_SERVICE_CALL_OPEN_READ) { const uint8_t *data = NULL, *name = NULL; uint32_t size = 0U; uint8_t length = 0U; bool temporary = false; unsigned recording_index = 0U; /* 电能量目录独立启用,先于通用HISTORY分支路由;后端严格验证完整文件名。 */ if (app->energy != NULL && request->name != NULL && ((request->name_length >= 12U && memcmp(request->name, "HISTORY/FRZ/", 12U) == 0) || (request->name_length >= 16U && memcmp(request->name, "HISTORY/FLOWREV/", 16U) == 0))) { if (files->read.active || !Example_Energy_Freeze_Read_Open(app->energy, request->name, request->name_length, &size)) { return IEC104_FILE_SERVICE_RESULT_FAILED; } if (!Example_File_Open_Resource(files, &files->read, request, open)) { Example_Energy_Freeze_Read_Close(app->energy); return IEC104_FILE_SERVICE_RESULT_FAILED; } files->read_energy = true; files->read_user_log = files->read_history = files->read_temp = false; files->read_recording = 0U; files->read_data = NULL; files->read_size = open->size = size; return IEC104_FILE_SERVICE_RESULT_OK; } /* 启用后ULOG路径只允许真实XML,旧演示名或别名不得回落成固定文本。 * 先冻结完整文件,再发布协议资源;失败时只关闭本次候选。 */ if (app->user_log != NULL && request->name != NULL && request->name_length >= 13U && memcmp(request->name, "HISTORY/ULOG/", 13U) == 0) { if (files->read.active || !Example_User_Log_Read_Open(app->user_log, request->name, request->name_length, &size)) { return IEC104_FILE_SERVICE_RESULT_FAILED; } if (!Example_File_Open_Resource(files, &files->read, request, open)) { Example_User_Log_Read_Close(app->user_log); return IEC104_FILE_SERVICE_RESULT_FAILED; } files->read_user_log = true; files->read_history = files->read_temp = false; files->read_recording = 0U; files->read_data = NULL; files->read_size = open->size = size; return IEC104_FILE_SERVICE_RESULT_OK; } /* 历史路径由适配器严格匹配,避免回落到固定 SOE 演示文本;日志演示仍沿用原分支。 * 先打开完整快照,后登记协议资源;登记失败时立即关闭候选,不遗留活动读句柄。 */ if (app->history != NULL && request->name != NULL && request->name_length > 8U && memcmp(request->name, "HISTORY/", 8U) == 0 && !Example_File_Name_Is(request->name, request->name_length, "HISTORY/ULOG/ulog.msg")) { if (files->read.active || !Example_History_Read_Open(app->history, request->name, request->name_length, &size)) { return IEC104_FILE_SERVICE_RESULT_FAILED; } if (!Example_File_Open_Resource(files, &files->read, request, open)) { Example_History_Read_Close(app->history); return IEC104_FILE_SERVICE_RESULT_FAILED; } files->read_history = true; files->read_user_log = false; files->read_temp = false; files->read_recording = 0U; files->read_data = NULL; files->read_size = open->size = size; return IEC104_FILE_SERVICE_RESULT_OK; } for (index = 0U; index < sizeof(example_files) / sizeof(example_files[0]); ++index) { if (Example_File_Name_Is(request->name, request->name_length, example_files[index].path)) { data = example_files[index].data; size = (uint32_t)example_files[index].size; name = (const uint8_t *)example_files[index].path; length = (uint8_t)strlen(example_files[index].path); break; } } /* OPEN_READ沿用目录的可见性门禁,防止绕过召目录提前读到录波。 * 只匹配目录中给出的完整路径;本分支按冻结记录编码,data可以保持NULL。 */ if (app->recording != NULL && app->recording->saved && app->recording->published) { for (index = 0U; index < 2U; ++index) { if (Example_File_Name_Is(request->name, request->name_length, app->recording->paths[index])) { recording_index = (unsigned)index + 1U; size = index == 0U ? (uint32_t)app->recording->cfg_size : app->recording->dat_size; name = (const uint8_t *)app->recording->paths[index]; length = (uint8_t)strlen(app->recording->paths[index]); break; } } } if (data == NULL && files->present && request->name != NULL && request->name_length == files->file_name_length && memcmp(request->name, files->file_name, files->file_name_length) == 0) { /* 暂存已打开就拒绝新的TEMP读取;反向由OPEN_WRITE检查read_temp,避免发布撞上读锁。 */ if (files->stage.active) { return IEC104_FILE_SERVICE_RESULT_FAILED; } data = files->file_bytes; size = files->file_size; name = files->file_name; length = files->file_name_length; temporary = true; } if ((data == NULL && recording_index == 0U) || !Example_File_Open_Resource(files, &files->read, request, open)) { return IEC104_FILE_SERVICE_RESULT_FAILED; } files->read_data = data; files->read_size = size; files->read_temp = temporary; files->read_recording = recording_index; files->read_history = false; files->read_user_log = false; /* 回显名来自常驻表或应用文件名数组,返回后仍有效,协议可立即复制;不借用局部数组。 */ open->size = size; open->name = name; open->name_length = length; return IEC104_FILE_SERVICE_RESULT_OK; } if (request->call == IEC104_FILE_SERVICE_CALL_OPEN_WRITE) { /* 用途在OPEN固定:保留升级名无论因何被拒绝,都直接返回,不降级到普通TEMP写入。 */ if (Example_File_Name_Is(request->name, request->name_length, "upgrade.bin")) { return Example_Upgrade_File_Open(app, request, open); } /* 先判实际名称白名单,再检查大小及暂存占用;拒绝请求不会破坏前一次尚待COMMIT的候选。 */ if (!Example_File_Temp_Name(request->name, request->name_length)) { return IEC104_FILE_SERVICE_RESULT_NAME_UNSUPPORTED; } if (request->file_size > EXAMPLE_FILE_BYTES) { return IEC104_FILE_SERVICE_RESULT_SIZE_OUT_OF_RANGE; } if (request->test || files->read_temp || !Example_File_Open_Resource(files, &files->stage, request, open)) { return IEC104_FILE_SERVICE_RESULT_FAILED; } memcpy(files->stage_name, request->name, request->name_length); files->stage_name_length = request->name_length; files->stage_size = request->file_size; files->stage_received = 0U; return IEC104_FILE_SERVICE_RESULT_OK; } return IEC104_FILE_SERVICE_RESULT_FAILED; } /** * 功能:只读快照,不在index=0重建;WAIT重取只返回同一条,不消费记录或按当前文件重新计算。 * 输入参数:context——调用方注册的回调上下文;request——仅在当前回调期间借用的协议请求;index——本次条目、点或逻辑槽的下标;entry——目录条目。 * 输出参数:entry——目录条目。 * 返回值:ENTRY表示取得目录条目,END表示枚举结束,NO_DIRECTORY表示首项请求的目录不存在,ERROR表示资源身份或快照读取失败。 * 说明:无。 */ static IEC104_FileServiceListResult_t Example_File_List(void *context, const IEC104_FileServiceRequest_t *request, size_t index, IEC104_FileServiceEntry_t *entry) { ExampleFileStore *files = &((ExampleApp *)context)->files; const ExampleFileDirectoryEntry *saved; if (!Example_File_Owner(&files->directory, request)) { return IEC104_FILE_SERVICE_LIST_ERROR; } if (files->directory_energy) { ExampleEnergyFreeze *energy = ((ExampleApp *)context)->energy; if (index >= Example_Energy_Freeze_Directory_Count(energy)) { return IEC104_FILE_SERVICE_LIST_END; } if (!Example_Energy_Freeze_Directory_Get(energy, index, &files->energy_entry)) { return IEC104_FILE_SERVICE_LIST_ERROR; } entry->name = (const uint8_t *)files->energy_entry.name; entry->name_length = (uint8_t)strlen(files->energy_entry.name); entry->attribute = 0U; entry->size = files->energy_entry.size; entry->time = files->energy_entry.time; return IEC104_FILE_SERVICE_LIST_ENTRY; } if (files->directory_user_log) { /* LIST可因发送WAIT重取同一index,只拷贝冻结条目;名称借自常驻字段,回调返回后仍可编码。 */ ExampleUserLog *log = ((ExampleApp *)context)->user_log; if (index >= Example_User_Log_Directory_Count(log)) { return IEC104_FILE_SERVICE_LIST_END; } if (!Example_User_Log_Directory_Get(log, index, &files->user_log_entry)) { return IEC104_FILE_SERVICE_LIST_ERROR; } entry->name = (const uint8_t *)files->user_log_entry.name; entry->name_length = (uint8_t)strlen(files->user_log_entry.name); entry->attribute = 0U; entry->size = files->user_log_entry.size; entry->time = files->user_log_entry.time; return IEC104_FILE_SERVICE_LIST_ENTRY; } if (files->directory_history) { /* 名称复制到常驻 history_entry,供本次回调返回后协议编码,不能借用局部结构体字段。 */ ExampleHistory *history = ((ExampleApp *)context)->history; if (index >= Example_History_Directory_Count(history)) { return IEC104_FILE_SERVICE_LIST_END; } if (!Example_History_Directory_Get(history, index, &files->history_entry)) { return IEC104_FILE_SERVICE_LIST_ERROR; } entry->name = (const uint8_t *)files->history_entry.name; entry->name_length = (uint8_t)strlen(files->history_entry.name); entry->attribute = 0U; entry->size = files->history_entry.size; entry->time = files->history_entry.time; return IEC104_FILE_SERVICE_LIST_ENTRY; } if (!files->directory_exists) { return index == 0U ? IEC104_FILE_SERVICE_LIST_NO_DIRECTORY : IEC104_FILE_SERVICE_LIST_ERROR; } if (index >= EXAMPLE_FILE_DIRECTORY_ITEMS || index >= files->entry_count) { return IEC104_FILE_SERVICE_LIST_END; } saved = &files->entries[index]; entry->name = saved->name; entry->name_length = saved->name_length; entry->attribute = 0U; entry->size = saved->size; entry->time = saved->time; return IEC104_FILE_SERVICE_LIST_ENTRY; } /** * 功能:read没有消费游标;每次完全按offset取相同内容,适合IDLE提交WAIT后的同偏移重取。 * 输入参数:context——调用方注册的回调上下文;request——仅在当前回调期间借用的协议请求;offset——从起点计算的字节偏移;buffer——调用方提供的数据缓冲;length——本次数据或名称的有效字节数。 * 输出参数:buffer——调用方提供的数据缓冲。 * 返回值:true表示指定范围的数据已完整读出;false表示范围非法、读取失败或短读。 * 说明:先检查offset再做减法,避免offset+length溢出绕过应用缓冲边界;空文件不解引用buffer。 */ static bool Example_File_Read(void *context, const IEC104_FileServiceRequest_t *request, uint32_t offset, uint8_t *buffer, uint16_t length) { ExampleFileStore *files = &((ExampleApp *)context)->files; if (!Example_File_Owner(&files->read, request) || offset > files->read_size || length > files->read_size - offset || (length != 0U && buffer == NULL)) { return false; } if (files->read_energy) { return Example_Energy_Freeze_Read(((ExampleApp *)context)->energy, offset, buffer, length); } if (files->read_user_log) { return Example_User_Log_Read(((ExampleApp *)context)->user_log, offset, buffer, length); } if (files->read_history) { /* 历史分支读取已冻结的临时文件,后台环形覆盖或重新召目录不会改变本会话字节。 */ return Example_History_Read(((ExampleApp *)context)->history, offset, buffer, length); } if (files->read_recording != 0U) { /* 读会话绑定同一份冻结记录;任意偏移或重试都得到相同字节,网络回调不访问磁盘。 */ return Example_Recording_Read(((ExampleApp *)context)->recording, files->read_recording - 1U, offset, buffer, length); } if (length != 0U) { memcpy(buffer, files->read_data + offset, length); } return true; } /** * 功能:模块检查线上偏移和模和,应用再次防御性检查自己的缓冲边界;分段仅写RAM,COMMIT才落盘。 * 输入参数:context——调用方注册的回调上下文;request——仅在当前回调期间借用的协议请求;offset——从起点计算的字节偏移;data——字节数据缓冲;length——本次数据或名称的有效字节数;last——是否为本次上传的末段。 * 输出参数:无独立输出参数。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:读锁与暂存互斥使TEMP内容在整次读会话内不变,COMMIT前所有读者仍只见旧完整文件。 * last仅验证完整长度,write仍不发布;确认排序和一次COMMIT由协议模块推进。 */ static bool Example_File_Write(void *context, const IEC104_FileServiceRequest_t *request, uint32_t offset, const uint8_t *data, uint16_t length, bool last) { ExampleFileStore *files = &((ExampleApp *)context)->files; if (Example_File_Owner(&example_upgrade_device.file, request)) { return Example_Upgrade_File_Write(context, request, offset, data, length, last); } if (!Example_File_Owner(&files->stage, request) || request->test || offset != files->stage_received || offset > files->stage_size || length > files->stage_size - offset || (last && length != files->stage_size - offset) || (length != 0U && data == NULL)) { return false; } if (length != 0U) { memcpy(files->stage_bytes + offset, data, length); } files->stage_received += length; return true; } /* 全过程使用同一组回调及app上下文,旧资源收尾前不得换到另一份文件存储。 */ static const IEC104_FileServiceHandlers_t example_file_handlers = { Example_File_List, Example_File_Action, Example_File_Read, Example_File_Write }; /** * 功能:用触发时的冻结帧发布TI42故障简报,入队成功后再开放成对录波文件。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:输入为调用者长期持有的模拟录波;本函数不重新采样、不改触发时间,也不从文件名反推故障。 * WAIT保留published=false,下一轮重试同一组数值和时标;true也可能表示仍待重试。 * OK仅代表发布队列已接收,不代表主站ACK或持久送达;覆盖/断线/复位仍受发布模块规则约束。 */ static bool Example_Publish_Recording(ExampleApp *app) { IEC104_SpontaneousFaultEvent_t report; IEC104_SpontaneousPublishInfo_t info; IEC104_SpontaneousPublishResult_t result; IEC60870_FaultEventSignal_t signal; IEC60870_FaultEventMeasurement_t measurements[8]; IEC60870_FaultRecorderFrame_t frame; ExampleRecording *recording = app->recording; unsigned index; #ifdef IEC104_EXAMPLE_DTU_PROFILE if (recording != NULL && app->dtu_recording_directory != NULL && app->dtu_recording_pending != 0U && !app->files.directory.active && !app->files.read.active && (!recording->complete || recording->published)) { if (app->dtu_recording_sequence == 9999U || !Example_Recording_Capture(recording, &app->dtu_recording_time, 1U, (uint16_t)(app->dtu_recording_sequence + 1U), app->dtu_recording_before, app->dtu_recording_after, app->dtu_recording_before_digital, app->dtu_recording_after_digital) || !Example_Recording_Save(recording, app->dtu_recording_directory)) { fputs("DTU triggered recording failed\n", stderr); return false; } ++app->dtu_recording_sequence; printf("DTU_RECORDING reasons=%lu %s %s\n", (unsigned long)app->dtu_recording_pending, recording->paths[0], recording->paths[1]); fflush(stdout); app->dtu_recording_pending = 0U; app->dtu_digital[8U] = app->dtu_digital[0x46U] = 1U; } if (recording != NULL && app->dtu_recording_directory != NULL && !recording->complete) { return true; } #endif if (recording == NULL || recording->published) { return true; } /* 本演示固定4 kHz、故障前4周波,逻辑下标320为触发点;它不是实时遥测的当前帧。 */ if (!recording->saved || !IEC60870_FaultRecorder_Get_Frame(&recording->recorder, 320U, &frame)) { return false; } memset(&report, 0, sizeof(report)); memset(&signal, 0, sizeof(signal)); memset(measurements, 0, sizeof(measurements)); #ifdef IEC104_EXAMPLE_DTU_PROFILE signal.ioa = 0x0022U; #else signal.ioa = 2U; #endif signal.value = 1U; signal.timestamp = recording->trigger_time; /* 通道依次Ua/Ub/Uc/U0/Ia/Ib/Ic/I0,标度须与示例CFG的0.01 V、0.001 A一致。 */ for (index = 0U; index < 8U; ++index) { #ifdef IEC104_EXAMPLE_DTU_PROFILE /* PT1相压和零序、保护三相和零序电流,使用DTU实际点表地址。 */ static const uint32_t ioas[8] = {0x400CU, 0x400DU, 0x400EU, 0x400FU, 0x4015U, 0x4016U, 0x4017U, 0x4018U}; measurements[index].ioa = ioas[index]; #else measurements[index].ioa = EXAMPLE_IOA_MEASUREMENT_BASE + index; #endif measurements[index].value.short_float = (float)frame.analog[index] / (index < 4U ? 100.0f : 1000.0f); } report.common_address = IEC104_Station_Get_Common_Address(&app->station); report.station_id = IEC104_Station_Get_Id(&app->station); IEC60870_FaultEvent_Init(&report.event); report.event.signals = &signal; report.event.signal_count = 1U; report.event.measurements = measurements; report.event.measurement_count = 8U; /* Publish在本次调用内编码并复制内容,不借用这两个局部数组到函数返回之后。 */ result = IEC104_Spontaneous_Publish_Fault_Event(app->spontaneous, &report, &info); if (result == IEC104_SPONTANEOUS_PUBLISH_ERROR) { return false; } /* published 只标记本次简报已被发布模块接手,目录/直接读取共同使用此门,不等主站回执。 */ if (result == IEC104_SPONTANEOUS_PUBLISH_OK) { recording->published = true; } return true; } /** * 功能:普通推进位于参数之后、周期扫描之前;文件确认先进入HIGH,读数据先尝试共享IDLE机会。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。 * 说明:faulted由主循环停止服务并Cancel/排空收尾,不在此销毁重建或重复不可撤销的COMMIT。 */ static bool Example_Step_FileService(ExampleApp *app) { IEC104_FileServiceExecuteResult_t result; if (app->file_service == NULL) { return true; } if (!IEC104_FileService_Process(app->file_service)) { return false; } result = IEC104_FileService_Execute_Next(app->file_service, &example_file_handlers, app); return result != IEC104_FILE_SERVICE_EXECUTE_ERROR && IEC104_FileService_Process(app->file_service) && IEC104_FileService_Get_Status(app->file_service, &app->file_status) && !app->file_status.faulted; } /** * 功能:严格调度把控制与数据分开;CONTROL仍交付本地写入和资源收尾,DATA只推进已打开的读数据。 * 输入参数:app——示例应用上下文;mode——文件服务控制或数据执行阶段;executed——本轮执行结果回写位置。 * 输出参数:executed——本轮执行结果回写位置。 * 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。 * 说明:两阶段都保留Process,使目录/确认重试和期限照常推进;实际IDLE机会由发送层按当前等级裁决。 * executed 可选,用于区分本轮确有本地进展还是等待;函数成功不代表文件传输已结束。 */ static bool Example_Step_FileService_Mode(ExampleApp *app, IEC104_FileServiceExecuteMode_t mode, IEC104_FileServiceExecuteResult_t *executed) { IEC104_FileServiceExecuteResult_t result; if (executed != NULL) { *executed = IEC104_FILE_SERVICE_EXECUTE_EMPTY; } if (app->file_service == NULL) { return true; } if (!IEC104_FileService_Process(app->file_service)) { return false; } result = IEC104_FileService_Execute_Next_Mode(app->file_service, &example_file_handlers, app, mode); if (executed != NULL) { *executed = result; } return result != IEC104_FILE_SERVICE_EXECUTE_ERROR && IEC104_FileService_Process(app->file_service) && IEC104_FileService_Get_Status(app->file_service, &app->file_status) && !app->file_status.faulted; } /* ============================================================================ * [PERIODIC_SCAN/INIT] 扫描初始化:应用持有点表,模块复制组配置 * ============================================================================ */ /** * 功能:app已由Example_Init绑定Slave和站点;cyclic_ms/background_ms分别是周期上送、背景扫描的组周期。 * 输入参数:app——示例应用上下文;cyclic_ms——周期上送间隔,单位毫秒;background_ms——背景扫描间隔,单位毫秒;sequence——是否使用SQ连续地址编码。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:两者均为0时不创建模块;否则须在消费首条连接通知前绑定,单组的0表示停用。 * 组0为COT=1遥测,组1为COT=2遥测;下标顺序使周期上送先使用同一轮留下的空闲发送机会。 * CLI默认关闭组0,仅每30秒以组1刷新当前值;这是低频刷新,不按变化门限筛选或重设COT3基准。 * 两组配置由Create复制,局部groups可在返回后消失;点表借用ExampleApp的固定存储至Destroy。 * 同时启用参数和周期组时使用点级周期;其余情况保留组周期模式。 * 返回true表示已创建或两组均关闭,false表示重复初始化或配置/静态池分配失败,由调用方统一回退。 */ static inline bool Example_Init_PeriodicScan_Reserve(ExampleApp *app, uint32_t cyclic_ms, uint32_t background_ms, bool sequence, uint16_t window_reserve) { IEC104_PeriodicScanConfig_t config; IEC104_PeriodicScanGroupConfig_t groups[2] = { {0U, 0U, IEC60870_ASDU_COT_PERIODIC, 0U, 0U}, {0U, 0U, IEC60870_ASDU_COT_BACKGROUND, 0U, 0U} }; uint16_t ca = IEC104_Station_Get_Common_Address(&app->station); size_t index; if (app->periodic_scan != NULL) { return false; } if (cyclic_ms == 0U && background_ms == 0U) { return true; } /* 两个扫描组均只登记遥测,遥信在总召外由带CP56的变位、读取和遥控反馈路径提供。 * 扫描模块当前只接收无时标类型,不能只往点表填入30/31就扩展为带时标遥信扫描。 */ for (index = 0U; index < EXAMPLE_SCAN_POINT_COUNT; ++index) { IEC104_PeriodicScanPoint_t *point = &app->scan_points[index]; point->common_address = ca; point->type_id = EXAMPLE_MEASUREMENT_TYPE; point->ioa = example_measurements[index].ioa; point->groups = 0x03U; } /* 示例首轮延迟取各组一个周期,让STARTDT后的首轮也能观察到等待;这是示例策略,库默认延迟为0。 */ groups[0].period_ms = groups[0].first_delay_ms = cyclic_ms; groups[1].period_ms = groups[1].first_delay_ms = background_ms; /* 每个(CA, Type)段都是完整的8点连续段,阈值2便于联调观察SQ=1;实际主站确认兼容后再打开。 * 默认阈值0保持SQ=0,周期与背景组分别组帧,不会因共享测点把两种COT混在一帧。 */ groups[0].sequence_min_run = groups[1].sequence_min_run = sequence ? 2U : 0U; /* 其余沿用库默认:reserve=2、OA=0、每帧按容量、每次Step至多交接一帧。 */ IEC104_PeriodicScan_Config_Default(&config); config.window_reserve = window_reserve; config.points = app->scan_points; config.point_count = EXAMPLE_SCAN_POINT_COUNT; config.groups = groups; config.group_count = 2U; /* QPA=3需要单点启停;只在参数和非零周期同时开启时改用点级组,保持其他CLI组合的原行为。 * 8项周期数组均为周期遥测;位图按全表每点1位提供,Create负责清零并独占维护。 * 两份存储均借用至Destroy,Create后只能用Set_Point_Period改周期,不能直接赋值或memset。 */ if (app->parameter != NULL && cyclic_ms != 0U) { groups[0].point_period = 1U; app->parameter_cyclic_ms = cyclic_ms; for (index = 0U; index < EXAMPLE_SCAN_POINT_COUNT; ++index) { app->point_period_ms[index] = (app->scan_points[index].groups & 1U) != 0U ? cyclic_ms : 0U; } config.point_period_ms = app->point_period_ms; config.point_retry_pending = app->point_retry_pending; config.point_retry_pending_size = sizeof(app->point_retry_pending); } app->periodic_scan = IEC104_PeriodicScan_Create(app->slave, &config); return app->periodic_scan != NULL; } static inline bool Example_Init_PeriodicScan(ExampleApp *app, uint32_t cyclic_ms, uint32_t background_ms, bool sequence) { return Example_Init_PeriodicScan_Reserve(app, cyclic_ms, background_ms, sequence, 2U); } /* ============================================================================ * [PERIODIC_SCAN/LOOKUP] 空闲扫描共用应用当前值,不建立变化队列 * ============================================================================ */ /** * 功能:读取周期或背景扫描请求的运行点并构造单对象ASDU。 * 输入参数:context——调用方注册的回调上下文;request——仅在当前回调期间借用的协议请求;object——单对象ASDU编码工作区。 * 输出参数:object——单对象ASDU编码工作区。 * 返回值:ADDED表示所请求运行点已加入ASDU,ERROR表示站点、地址、读取或编码失败。 * 说明:context为当前ExampleApp;request由模块借出,仅在本次回调中有效,包含所属组、COT、站点编号和IOA。 * object是模块已设好COT/CA/OA的SQ=0单对象临时容器;本回调只Create并Add恰好一个匹配对象,检查两步结果。 * 模块随后负责校验和合帧,SQ=1也不改变回调用法;回调不改容器头、不提交发送、不保存借用指针。 * 先核对站点context,再按Type和IOA映射到共享运行值数组,读到本轮已执行遥控更新后的当前值。 * 成功返回ADDED;站点/地址/类型或编码失败返回ERROR并由模块中止该组本轮,已交接帧不撤回。 * Send返回WAIT后同一点可能重新取值,因此这里不消费应用事件、不读后清零,也不缓存本次结果。 */ static IEC104_PeriodicScanLookupResult_t Example_PeriodicScan_Point(void *context, const IEC104_PeriodicScanRequest_t *request, IEC60870_Asdu_t *object) { ExampleApp *app = context; IEC104_Station_t *station = IEC104_Slave_Get_Station_By_Id(app->slave, request->station_id); size_t index; if (IEC104_Station_Get_Context(station) != app) { return IEC104_PERIODIC_SCAN_LOOKUP_ERROR; } switch (request->type_id) { case IEC60870_ASDU_M_SP_NA_1: { IEC60870_SinglePointInformation_t point; index = request->ioa - EXAMPLE_IOA_SINGLE_BASE; if (index >= EXAMPLE_SIGNAL_COUNT) { return IEC104_PERIODIC_SCAN_LOOKUP_ERROR; } return IEC60870_SinglePointInformation_Create(&point, request->ioa, app->signal_values[index], 0U) == IEC60870_ASDU_OK && IEC60870_Asdu_Add_InformationObject(object, &point.object) == IEC60870_ASDU_OK ? IEC104_PERIODIC_SCAN_LOOKUP_ADDED : IEC104_PERIODIC_SCAN_LOOKUP_ERROR; } case IEC60870_ASDU_M_DP_NA_1: { IEC60870_DoublePointInformation_t point; index = request->ioa - EXAMPLE_IOA_DOUBLE_BASE; if (index >= EXAMPLE_DOUBLE_COUNT) { return IEC104_PERIODIC_SCAN_LOOKUP_ERROR; } return IEC60870_DoublePointInformation_Create(&point, request->ioa, app->double_values[index], 0U) == IEC60870_ASDU_OK && IEC60870_Asdu_Add_InformationObject(object, &point.object) == IEC60870_ASDU_OK ? IEC104_PERIODIC_SCAN_LOOKUP_ADDED : IEC104_PERIODIC_SCAN_LOOKUP_ERROR; } case EXAMPLE_MEASUREMENT_TYPE: { ExampleMeasurementObject point; index = request->ioa - EXAMPLE_IOA_MEASUREMENT_BASE; if (index >= EXAMPLE_MEASUREMENT_COUNT) { return IEC104_PERIODIC_SCAN_LOOKUP_ERROR; } return Example_Create_Measurement(&point, request->ioa, app->scaled_values[index], Example_Measurement_Quality(app, index)) == IEC60870_ASDU_OK && IEC60870_Asdu_Add_InformationObject(object, &point.object) == IEC60870_ASDU_OK ? IEC104_PERIODIC_SCAN_LOOKUP_ADDED : IEC104_PERIODIC_SCAN_LOOKUP_ERROR; } default: return IEC104_PERIODIC_SCAN_LOOKUP_ERROR; } } /* ============================================================================ * [SYSTEM_COMMAND/ACTION] Type104/107回显、Type70初始化结束、Type105复位许可与本站事件清除 * ============================================================================ */ /** * 功能:Create只绑定模块,不登记初始化原因,也不启动网络。main须在消费首条Slave通知前调用。 * 输入参数:app——示例应用上下文。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:本例沿用默认标准功能及决定/ACK期限;启动同步启用时用EVERY_START,每轮重报初始化结束。 * 重报沿用登记的COI,不代表每次连接都执行设备上电初始化;仅ONCE无法为重连提供新轮完成证据。 * 未约定QRP128..255的专用语义,因此不启用FEATURE_RESET_PRIVATE。 * 接入专用复位时须同时补齐许可回调和Take_Reset后的qualifier分派,不能只打开功能位。 */ static bool Example_Init_SystemCommand(ExampleApp *app) { IEC104_SystemCommandConfig_t config; IEC104_Startup_Config_Default(NULL, &config, NULL, NULL, NULL); app->system_command = IEC104_SystemCommand_Create(app->slave, &config); return app->system_command != NULL; } /** * 功能:库已检查请求站点仍注册且未被同CA新节点替换;这里仍用station_id取得原context。 * 输入参数:context——调用方注册的回调上下文;request——仅在当前回调期间借用的协议请求。 * 输出参数:无独立输出参数。 * 返回值:ACCEPT表示本次复位限定词获准并完成允许的本地处理,REJECT表示站点、限定词或运行状态不允许。 * 说明:QRP=1仅许可,不能在回调中重启。真实设备可在许可前检查就地/远方、闭锁和运行状态。 * QRP=2只改变本CA应用缓存,发送层NORMAL由模块随后清除;不推进Slave、不自行发送确认。 * 返回REJECT的分支发生在任何修改之前;ACCEPT不表示NORMAL清除或后续确认必然成功。 */ static IEC104_SystemCommandDecision_t Example_Reset_Action(void *context, const IEC104_SystemCommandResetRequest_t *request) { ExampleApp *app = (ExampleApp *)context; IEC104_Station_t *station = IEC104_Slave_Get_Station_By_Id(app->slave, request->station_id); size_t index = 0U; if (IEC104_Station_Get_Context(station) != app) { return IEC104_SYSTEM_COMMAND_DECISION_REJECT; } if (request->qualifier == 1U) { /* 本例Take_Reset后重建整个协议实例,只能在单站模型下授权。 * 多站集成须实现定向复位;某一站获准不能被扩大为所有站或整机的重启许可。 */ return station == &app->station && IEC104_Slave_Get_Station_Count(app->slave) == 1U ? IEC104_SYSTEM_COMMAND_DECISION_ACCEPT : IEC104_SYSTEM_COMMAND_DECISION_REJECT; } /* 只实现QRP1/2;即使集成方开启专用入口,也必须明确拒绝尚未定义的QRP,不能按QRP2清缓存。 */ if (request->qualifier != 2U) { return IEC104_SYSTEM_COMMAND_DECISION_REJECT; } #ifdef IEC104_EXAMPLE_DTU_PROFILE /* QRP2清待发变位,保留当前遥信值。 */ app->dtu_signal_pending = 0U; #endif while (index < app->publication_count) { ExamplePublication *entry = &app->publications[index]; if (entry->change.common_address != request->common_address) { ++index; continue; } entry->time_tag_cleared = true; /* 未决遥控占位还承担FINISHED配对,暂不移除;普通类型补报再应用同一形态清除规则。 * 独立SOE随后由核心按CA清除;保留旧票据以便FINISHED收尾,但解析不能重新生成已清原文。 * 删除普通条目会把下一条移到当前index,因此删除分支不递增游标。 */ if (entry->placeholder) { entry->time_tag_cleared = true; ++index; } else if (Example_Clear_Publication_Time(app, entry)) { ++index; } else { Example_Remove_Publication(app, index); } } /* 显式清除放弃此前差量,但不改参数/原始值/滤波。幸存旧条目不能在提交时回退此基准, * 否则普通PLAIN排空或命令FINISHED后会把已清除的历史重新造为CP56事件。 */ if (app->parameter != NULL) { for (index = 0U; index < EXAMPLE_MEASUREMENT_COUNT; ++index) { ExampleMeasurement *state = &app->measurements[index]; state->submitted_value = app->scaled_values[index]; state->submitted_quality = state->quality; state->submitted_range = state->range; } } return IEC104_SYSTEM_COMMAND_DECISION_ACCEPT; } /** * 功能:Take_Reset成功才置restart_requested;首次STOP前按时ACK的授权在断线后仍可领取。 * 输入参数:app——示例应用上下文。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:无。 * 说明:只保存布尔值是因为本例重建整个单站协议实例,许可回调已拒绝多站模型的QRP1。 * 多站设备若需定向复位,应保存返回请求的纯值身份/CA,并另行管理应用资源寿命。 * 专用QRP也可通过Take_Reset交出,但本例未实现其动作,绝不将任意授权转换为QRP1重启。 */ static void Example_Take_System_Reset(ExampleApp *app) { IEC104_SystemCommandResetRequest_t request; /* 启用211时此处不领取105授权;两种授权留给同一仲裁点选择,避免同轮分别Take两个设备动作。 */ if (app->system_command != NULL && app->software_upgrade == NULL && IEC104_SystemCommand_Take_Reset(app->system_command, &request)) { if (request.qualifier == 1U) { app->restart_requested = app->quiescing = true; } else { /* 正常配置及许可回调不会产生此分支;扩展入口未配套动作分派时显式报告接入错误。 */ ++app->system_command_faults; (void)fputs("System command: granted QRP has no application handler; no action taken.\n", stderr); } } } /** * 功能:每轮先推进旧回复、期限和ACK,再至多决定一条105;104/107和70由Process自行处理。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。 * 说明:Execute_Next的OK只表示队首已处理,新的回复可在后续Process提交,不能当作已送达。 * FAULT表示应用清除已发生、库清除失败;记录后继续推进否定回复,不重调同一请求的动作。 */ static bool Example_Step_SystemCommand(ExampleApp *app) { IEC104_SystemCommandExecuteResult_t result; if (app->system_command == NULL) { return true; } if (!IEC104_SystemCommand_Process(app->system_command)) { return false; } result = IEC104_SystemCommand_Execute_Next(app->system_command, Example_Reset_Action, app); if (result == IEC104_SYSTEM_COMMAND_EXECUTE_ERROR) { return false; } if (result == IEC104_SYSTEM_COMMAND_EXECUTE_FAULT) { ++app->system_command_faults; EXAMPLE_SYSTEM_COMMAND_REPORT_FAULT(app); } Example_Take_System_Reset(app); return IEC104_SystemCommand_Get_Status(app->system_command, &app->system_command_status); } /* ============================================================================ * [COMMON/INIT] 公共初始化:运行值、站点注册、必需模块创建及失败回退 * ============================================================================ */ /** * 功能:必须在开始消费Slave事件之前创建业务模块;config本地对象按值复制,广播数组仍为借用。 * 输入参数:app——示例应用上下文;slave——已创建的从站服务;common_address——站点公共地址;broadcast_states——调用方长期持有的广播站点工作区;broadcast_capacity——广播站点工作区容量;total_timeout_ms——整轮业务期限,单位毫秒。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:单站可传NULL/0;多站广播须提供覆盖全部目标的数组,保持独占和地址稳定直到模块Destroy。 * total_timeout_ms是部署指定的整体提交期限,0显式禁用;必须在Create复制配置之前写入。 * 命令行main只注册一个CA;多站回归提供状态数组并增加站点,复用本例的分派和取数函数。 */ static bool Example_Init(ExampleApp *app, IEC104_Slave_t *slave, uint16_t common_address, IEC104_InterrogationStationState_t *broadcast_states, size_t broadcast_capacity, uint32_t total_timeout_ms) { IEC104_InterrogationConfig_t config; size_t index; memset(app, 0, sizeof(*app)); app->slave = slave; /* 每个应用实例独立保存受控运行值:单点取配置初值,通用双点1为分位,DTU双点2为合位。 * 上面的整实例清零已把步位置置0、位串所有位清0;两类值不由field/stress采样更新。 * 这里只在应用初始化时赋值,选择结束、撤销和FINISHED清理均不得恢复这些初值。 */ for (index = 0U; index < EXAMPLE_SIGNAL_COUNT; ++index) { app->signal_values[index] = Example_Initial_Signal(index); } for (index = 0U; index < EXAMPLE_DOUBLE_COUNT; ++index) { #ifdef IEC104_EXAMPLE_DTU_PROFILE app->double_values[index] = 2U; #else app->double_values[index] = 1U; #endif } #ifdef IEC104_EXAMPLE_DTU_PROFILE app->dtu_started_ms = IEC104_Net_Now_Ms(); app->dtu_signal_pending = 0U; Example_Dtu_Reset_Process(app); app->dtu_energy_last_ms = app->dtu_started_ms; memset(app->dtu_energy_wh, 0, sizeof(app->dtu_energy_wh)); memset(app->dtu_energy_frozen_wh, 0, sizeof(app->dtu_energy_frozen_wh)); #endif for (index = 0U; index < EXAMPLE_MEASUREMENT_COUNT; ++index) { app->scaled_values[index] = Example_Initial_Measurement(index); } if (IEC104_Slave_Add_Station(slave, &app->station, common_address, app) != IEC104_STATION_OK) { return false; } IEC104_Startup_Config_Default(NULL, NULL, &config, NULL, NULL); /* CA只在注册时指定;多站广播需提供每站状态区。 */ config.broadcast_states = broadcast_states; config.broadcast_capacity = broadcast_capacity; config.max_objects_per_asdu = 4U; config.total_timeout_ms = total_timeout_ms; app->interrogation = IEC104_Interrogation_Create(slave, &config); if (app->interrogation != NULL) { IEC104_SpontaneousConfig_t spontaneous_config; IEC104_ReadConfig_t read_config; IEC104_Startup_Config_Default(NULL, NULL, NULL, NULL, &spontaneous_config); /* publication_forms须与统一配置一致,QRP2才能展开forms=0并删除遥信事件。 */ memcpy(app->publication_forms, spontaneous_config.forms, sizeof(app->publication_forms)); app->spontaneous = IEC104_Spontaneous_Create(slave, &spontaneous_config); /* 在消费CONNECTED/ACTIVATED前绑定,模块从通知建立会话;默认15秒期限,无额外CLI项。 */ IEC104_Read_Config_Default(&read_config); app->read = IEC104_Read_Create(slave, &read_config); if (app->spontaneous != NULL && app->read != NULL) { return true; } if (app->read != NULL) { (void)IEC104_Read_Destroy(app->read); app->read = NULL; } if (app->spontaneous != NULL) { (void)IEC104_Spontaneous_Destroy(app->spontaneous); app->spontaneous = NULL; } (void)IEC104_Interrogation_Destroy(app->interrogation); app->interrogation = NULL; } (void)IEC104_Slave_Remove_Station(slave, &app->station); return false; } /* ============================================================================ * [COMMON/SCHEDULING] 公共调度:取消、等待时间与Slave通知分派 * ============================================================================ */ /** * 功能:统一取消应用业务;app为有效应用上下文,未创建的可选模块直接跳过,无返回值。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:无。 * 说明:遥控Cancel丢弃模块持有应答但保留应交付FINISHED,不回滚已经执行的输出。 * 本函数不消费终结通知;调用方还须Drain_Finished排空总召、计数量及遥控事件并归还应用引用。 * SystemCommand取消只撤销尚未交出的复位授权,已被发送层接手的确认仍可能发出。 * 扫描Cancel仅中止进行中的轮次,不停用组或清除网格;收尾期间不再调用普通Step,随后Close并分派断线。 * 已交给发送层的IDLE帧由原流程收尾,Cancel不会撤回它,也不产生待补发的点值队列。 */ static void Example_Cancel(ExampleApp *app) { if (app->software_upgrade != NULL) { /* 必须早于Slave_Close释放观察槽;已领取的激活任务在应用侧,不能在这里清候选。 * 未领取会话转ABANDON后由Drain_Finished交付,不能仅清状态快照就认定owner归还。 */ IEC104_SoftwareUpgrade_Cancel(app->software_upgrade); (void)IEC104_SoftwareUpgrade_Get_Status(app->software_upgrade, &app->upgrade_status); } if (app->file_service != NULL) { /* 暂存与句柄不能在Cancel时由应用抢先清掉;稍后由原归属的收尾恰一次释放。 * 未交付COMMIT会转ABORT;已经提交的file_bytes及present继续保留。 */ IEC104_FileService_Cancel(app->file_service); (void)IEC104_FileService_Get_Status(app->file_service, &app->file_status); } if (app->remote_parameter != NULL) { /* 只取消协议任务,已固化的运行值不回滚;健康连接上的恢复屏障仍在。 * 若存在真实暂存,稍后Close及生命周期分派后仍须交付一次DISCARD。 */ IEC104_RemoteParameter_Cancel(app->remote_parameter); (void)IEC104_RemoteParameter_Get_Status(app->remote_parameter, &app->remote_status); } if (app->parameter != NULL) { /* 示例不开ACK扩展,Cancel立即移除参数任务;运行值及周期启停配置保留。 * ACK模式应用还须在Destroy或改换资源之前交付全部COMMIT/ABORT,不能只照抄本例取消。 */ IEC104_Parameter_Cancel(app->parameter); (void)IEC104_Parameter_Get_Status(app->parameter, &app->parameter_status); } if (app->periodic_scan != NULL) { IEC104_PeriodicScan_Cancel(app->periodic_scan); } if (app->system_command != NULL) { IEC104_SystemCommand_Cancel(app->system_command); } if (app->read != NULL) { IEC104_Read_Cancel(app->read); (void)IEC104_Read_Get_Status(app->read, &app->rd); } IEC104_Interrogation_Cancel(app->interrogation); if (app->counter != NULL) { IEC104_Interrogation_Cancel(app->counter); (void)IEC104_Interrogation_Get_Status(app->counter, &app->ci); } if (app->clock != NULL) { IEC104_ClockSynchronization_Cancel(app->clock); (void)IEC104_ClockSynchronization_Get_Status(app->clock, &app->cs); } if (app->command != NULL) { IEC104_Command_Cancel(app->command); (void)IEC104_Command_Get_Status(app->command, &app->command_status); } (void)IEC104_Interrogation_Get_Status(app->interrogation, &app->gi); } /** * 功能:两种授权统一仲裁;升级优先,选中Take返回false时不得取消另一授权或改取另一种。 * 输入参数:app——示例应用上下文。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:本轮仲裁无错误时返回true,未取得授权时可继续等待;身份或持久处理失败返回false。 * 说明:END已经预留任务,Take前只核验,不执行可能失败的分配;成功同轮进入QUIESCING并清队列。 */ static bool Example_Arbitrate_Restart(ExampleApp *app) { ExampleUpgradeDevice *device = &example_upgrade_device; IEC104_SoftwareUpgradeRequest_t upgrade; IEC104_SystemCommandResetRequest_t reset; if (app->software_upgrade == NULL || app->quiescing) { return true; } if (!IEC104_SoftwareUpgrade_Get_Status(app->software_upgrade, &app->upgrade_status)) { return false; } if (app->upgrade_status.restart_ready) { /* 协议授权与应用预留须同时归属原会话;新连接或新站点不能接续旧候选。 */ if (!device->owned || device->context != app || device->invalidated || !device->reserved || device->taken || device->state != EXAMPLE_UPGRADE_FROZEN || device->activation.owner_token != device->owner_token || device->activation.transfer_token != device->transfer_token || !Example_Upgrade_Identity(&device->owner.identity, &app->upgrade_status.session_identity) || device->owner.common_address != app->upgrade_status.session_common_address || device->owner.station_id != app->upgrade_status.session_station_id || device->owner.session_serial != app->upgrade_status.session_serial) { return false; } /* WAIT_EVENTS等暂缓不丢预留,也不提前撤销105;下一轮仍先尝试升级授权。 * 因而WAIT不会重复写授权元数据或阶段日志,ACK事实也不能跳过实际Take。 */ if (!IEC104_SoftwareUpgrade_Take_Restart(app->software_upgrade, &upgrade)) { return true; } if (!Example_Upgrade_Owner(app, &upgrade)) { return false; } device->taken = true; device->activation.taken_ms = IEC104_Net_Now_Ms(); if (app->upgrade_store != NULL) { /* Take是唯一授权入口。提交失败可能已经落盘,先移交所有权,再尝试持久授权。 * 失败后不回退到普通循环,也不让Cancel/退出把不确定的授权当未授权候选撤销。 */ device->persistent_handoff = true; if (!Example_Upgrade_Store_Authorize(app->upgrade_store)) { Example_Upgrade_Store_Failed(app); return false; } } Example_User_Log_Upgrade(app, "ACTIVATION_AUTHORIZED"); } else { if (app->system_command == NULL) { return true; } if (!IEC104_SystemCommand_Get_Status(app->system_command, &app->system_command_status)) { return false; } if (!app->system_command_status.reset_ready || !IEC104_SystemCommand_Take_Reset(app->system_command, &reset)) { return true; } if (reset.qualifier != 1U) { return false; } } /* 只有选中授权真正交出,才取消未选中的授权和所有排队业务。 * 先置QUIESCING,使Take后到达的CANCEL不会按“无会话”回复肯定却仍执行重启。 */ app->restart_requested = app->quiescing = true; Example_Cancel(app); return true; } /** * 功能:每次等待前重新查询剩余期限,避免采样/业务处理耗时后继续使用旧的毫秒数。 * 输入参数:app——示例应用上下文;maximum_ms——本轮允许等待的毫秒上限。 * 输出参数:无独立输出参数。 * 返回值:受业务期限收紧后的等待毫秒数;0表示需要立即续跑。 * 说明:输入app为有效上下文,maximum_ms为调用方等待上限;返回0表示本地立即续跑,否则为缩短后的上限。 * 查询失败也返回0,让随后推进路径处理错误;本函数只查状态,不消费事件或触发业务到期转换。 * 本地可推进时不休眠;否则本例网络等待最多50ms,并受最近业务期限限制。 */ static uint32_t Example_Wait_Time(ExampleApp *app, uint32_t maximum_ms) { if (app->quiescing) { return 0U; } if (app->software_upgrade != NULL) { IEC104_SoftwareUpgradeStatus_t *status = &app->upgrade_status; if (!IEC104_SoftwareUpgrade_Get_Status(app->software_upgrade, status)) { return 0U; } /* 仅等待ACK或观察槽不强制零等待;结果就绪、收尾或业务期限才唤醒本地推进。 */ if (status->events_pending || status->execute_ready || status->need_process || status->restart_ready) { return 0U; } if (status->timer_active && status->timeout_remaining_ms < maximum_ms) { maximum_ms = status->timeout_remaining_ms; } } if (app->file_service != NULL) { IEC104_FileServiceStatus_t *status = &app->file_status; if (!IEC104_FileService_Get_Status(app->file_service, status)) { return 0U; } /* execute_pending或暂缓COMMIT本身不要求零等待;HIGH/IDLE背压交网络推进后重试。 */ if (status->events_pending || status->execute_ready || status->need_process) { return 0U; } if (status->timer_active && status->timeout_remaining_ms < maximum_ms) { maximum_ms = status->timeout_remaining_ms; } } if (app->remote_parameter != NULL) { IEC104_RemoteParameterStatus_t *status = &app->remote_status; if (!IEC104_RemoteParameter_Get_Status(app->remote_parameter, status)) { return 0U; } /* 单纯有排队、确认WAIT或恢复状态不要求零等待;只合并模块可处理的最近期限。 * 网络再次唤醒后仍调用Step,让上一次容量WAIT有重试机会。 */ if (status->events_pending || status->execute_ready || status->need_process) { return 0U; } if (status->timer_active && status->timeout_remaining_ms < maximum_ms) { maximum_ms = status->timeout_remaining_ms; } } if (app->parameter != NULL) { IEC104_ParameterStatus_t *status = &app->parameter_status; if (!IEC104_Parameter_Get_Status(app->parameter, status)) { return 0U; } /* execute_ready表示本轮能推进;不能用仅表示排队的execute_pending触发零等待。 * 默认模式二者相同,ACK模式排队可能受前序准备阻挡,单纯ack_pending也不应忙轮询。 */ if (status->events_pending || status->execute_ready || status->need_process) { return 0U; } if (status->timer_active && status->timeout_remaining_ms < maximum_ms) { maximum_ms = status->timeout_remaining_ms; } } if (app->periodic_scan != NULL) { IEC104_PeriodicScanStatus_t status; if (!IEC104_PeriodicScan_Get_Status(app->periodic_scan, &status)) { return 0U; } /* 未读通知先交给Drain;need_process才表示需要立即再推进扫描,不能因轮次尚未完成就强制零等待。 * 扫描被发送层阻塞时允许Poll等待网络/ACK/协议期限;尚未开轮的最近起点才用于缩短本次等待。 */ if (status.events_pending || status.need_process) { return 0U; } if (status.timer_active && status.timeout_remaining_ms < maximum_ms) { maximum_ms = status.timeout_remaining_ms; } } if (app->system_command != NULL) { IEC104_SystemCommandStatus_t *status = &app->system_command_status; if (!IEC104_SystemCommand_Get_Status(app->system_command, status)) { return 0U; } /* 两个发送来源的WAIT、等待交接及等待ACK本身都不要求忙轮询。 * need_process包含已出现的交接/ACK结果;reset_ready则要求本轮尽快Take_Reset。 */ if (status->events_pending || status->need_process || status->decide_pending || status->reset_ready) { return 0U; } if (status->timer_active && status->timeout_remaining_ms < maximum_ms) { maximum_ms = status->timeout_remaining_ms; } } if (app->read != NULL) { if (!IEC104_Read_Get_Status(app->read, &app->rd)) { return 0U; } /* READ仍排队不代表本轮可发送;send_waiting时允许网络等待,避免反复空取。 * REPLY背压同样由Process在下一轮网络推进后重试,期限继续限制等待上限。 */ if (app->rd.events_pending || app->rd.need_process || (app->rd.execute_pending && !app->rd.send_waiting)) { return 0U; } if (app->rd.timer_active && app->rd.timeout_remaining_ms < maximum_ms) { maximum_ms = app->rd.timeout_remaining_ms; } } if (app->events_interval_ms != 0U) { uint64_t now = IEC104_Net_Now_Ms(); uint64_t elapsed = now >= app->events_last_ms ? now - app->events_last_ms : app->events_interval_ms; if (elapsed >= app->events_interval_ms) { return 0U; } if (app->events_interval_ms - elapsed < maximum_ms) { maximum_ms = (uint32_t)(app->events_interval_ms - elapsed); } } if (app->command != NULL) { if (!IEC104_Command_Get_Status(app->command, &app->command_status)) { return 0U; } #ifdef IEC104_EXAMPLE_DTU_PROFILE if (app->command_step == 1U && app->dtu_command_due_ms != 0U) { uint64_t command_now = IEC104_Net_Now_Ms(); if (command_now >= app->dtu_command_due_ms) { return 0U; } if (app->dtu_command_due_ms - command_now < maximum_ms) { maximum_ms = (uint32_t)(app->dtu_command_due_ms - command_now); } } #endif /* 未读Slave通知、FINISHED等业务事件及模块本地进度都须立即处理。 * 应用持有事件/收尾步骤不代表能立即发送:上次WAIT时允许Poll等待,避免确认拥塞造成空转。 */ if (app->command_status.events_pending || app->command_status.pending_events != 0U || app->command_status.need_process || ((app->command_pending || app->command_step != 0U) && !app->command_waiting)) { return 0U; } if (app->command_status.timer_active && app->command_status.timeout_remaining_ms < maximum_ms) { maximum_ms = app->command_status.timeout_remaining_ms; } } if (!IEC104_Interrogation_Get_Status(app->interrogation, &app->gi)) { return 0U; } if (app->counter != NULL) { if (!IEC104_Interrogation_Get_Status(app->counter, &app->ci)) { return 0U; } if (app->ci.events_pending || app->ci.pending_events != 0U || app->ci.need_process) { return 0U; } if (app->ci.timer_active && app->ci.timeout_remaining_ms < maximum_ms) { maximum_ms = app->ci.timeout_remaining_ms; } } if (app->clock != NULL) { if (!IEC104_ClockSynchronization_Get_Status(app->clock, &app->cs)) { return 0U; } /* execute_pending包含尚未取样的READ;不能只用设时专属confirm_pending决定是否推进。 * 固定读回复的发送WAIT可以等待网络,下一轮Step_Clock仍须先Process再查询状态。 */ if (app->cs.events_pending || app->cs.execute_pending || app->cs.need_process) { return 0U; } if (app->cs.timer_active && app->cs.timeout_remaining_ms < maximum_ms) { maximum_ms = app->cs.timeout_remaining_ms; } } /* 撤销后的FINISHED须及时消费;逐站COT=9遇WAIT则由模块need_process反映可推进性。 * 不能仅因pending_requests非零就零超时重试:它也包含等网络和等应用清理的任务。 */ if (app->events_pending || app->gi.events_pending) { return 0U; } /* 初始化交接前暂存总召BEGIN;未读业务事件不是当前可推进的工作,不能触发空转。 * 网络事件及下面的请求期限仍参与等待,初始化完成后恢复正常消费。 */ if (IEC104_Startup_Can_Consume_General(&app->startup) && (app->gi.pending_events != 0U || app->gi.need_process)) { return 0U; } if (app->publication_count != 0U && !app->publications[0].placeholder && !app->publication_waiting) { return 0U; } if (app->gi.timer_active && app->gi.timeout_remaining_ms < maximum_ms) { return app->gi.timeout_remaining_ms; } return maximum_ms; } /** * 功能:状态事件交给所有实例;I帧由总召、计数量、校时、遥控、读、系统命令、参数、文件及兜底接手。 * 输入参数:app——示例应用上下文;event——本轮借用的协议事件。 * 输出参数:无独立输出参数。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:输入app为有效上下文,event是刚由Slave_NextEvent交付的借用事件,本函数不保存它的指针。 * 返回true表示分派完成(包括模块拒绝/丢弃),false表示业务入口或状态查询失败,应统一收尾。 * 生命周期通知不能因前一个模块HANDLED而短路,否则遥控可能漏读STOP/换代后继续执行旧请求。 * Handle_Event负责消费这些通知,不能在它之前用Check_Request等待通知读空而阻断分派。 */ static bool Example_Handle_Event(ExampleApp *app, const IEC104_SlaveEvent_t *event) { IEC104_InterrogationEventResult_t result; /* 一条生命周期只在此分派入口记一次;日志失败不提前return,所有模块仍须收到原通知完成清理。 */ Example_User_Log_Connection(app, event); if (!Example_Startup_Handle_Event(app, event)) { return false; } /* 激活任务取得候选后停收新业务;生命周期仍须传给所有模块,才能归还旧请求资源。 */ if (event->transport.type == IEC104_TCP_EVENT_I_FRAME && (app->quiescing || example_upgrade_device.taken)) { return true; } /* Receiver已过滤线上基础格式错误;仍防御性过滤不可用视图,避免误交给业务分派或未知类型兜底。 */ if (event->transport.type == IEC104_TCP_EVENT_I_FRAME && event->asdu_result != IEC60870_ASDU_OK) { return true; } /* 扫描只据生命周期建立/停用会话,ACTIVATED时校验reserve并设置首轮网格;I帧和回执返回IGNORED。 * 即使扫描已HANDLED,仍继续向其他业务分派同一通知;STOP、断线和换代都不能只送到一个模块。 */ if (app->periodic_scan != NULL && IEC104_PeriodicScan_Handle_Event(app->periodic_scan, event) == IEC104_PERIODIC_SCAN_EVENT_ERROR) { return false; } /* COT=8同其他Type100请求一样交给总召模块,它负责匹配、停止目标及保存确认。 * 不能改为Example_Cancel:本地取消会丢弃待发回复并影响其他业务,也不会生成撤销确认。 */ result = IEC104_Interrogation_Handle_Event(app->interrogation, event); if (app->counter != NULL && (event->transport.type != IEC104_TCP_EVENT_I_FRAME || result == IEC104_INTERROGATION_EVENT_IGNORED)) { IEC104_InterrogationEventResult_t counter_result = IEC104_Interrogation_Handle_Event(app->counter, event); if (counter_result == IEC104_INTERROGATION_EVENT_ERROR || !IEC104_Interrogation_Get_Status(app->counter, &app->ci)) { return false; } if (result == IEC104_INTERROGATION_EVENT_IGNORED) { result = counter_result; } } if (result == IEC104_INTERROGATION_EVENT_ERROR || !IEC104_Interrogation_Get_Status(app->interrogation, &app->gi)) { return false; } if (app->clock != NULL && (event->transport.type != IEC104_TCP_EVENT_I_FRAME || result == IEC104_INTERROGATION_EVENT_IGNORED)) { IEC104_ClockSynchronizationEventResult_t clock_result = IEC104_ClockSynchronization_Handle_Event(app->clock, event); if (clock_result == IEC104_CLOCK_SYNCHRONIZATION_EVENT_ERROR || !IEC104_ClockSynchronization_Get_Status(app->clock, &app->cs)) { return false; } if (clock_result != IEC104_CLOCK_SYNCHRONIZATION_EVENT_IGNORED && event->transport.type == IEC104_TCP_EVENT_I_FRAME) { return true; } } if (app->command != NULL && (event->transport.type != IEC104_TCP_EVENT_I_FRAME || result == IEC104_INTERROGATION_EVENT_IGNORED)) { /* HANDLED也包括格式否定、实例忙和过载丢弃,不能再走44兜底;未启用类型仍可继续分派。 */ IEC104_CommandEventResult_t command_result = IEC104_Command_Handle_Event(app->command, event); if (command_result == IEC104_COMMAND_EVENT_ERROR || !IEC104_Command_Get_Status(app->command, &app->command_status)) { return false; } if (command_result != IEC104_COMMAND_EVENT_IGNORED && event->transport.type == IEC104_TCP_EVENT_I_FRAME) { return true; } } if (app->read != NULL && (event->transport.type != IEC104_TCP_EVENT_I_FRAME || result == IEC104_INTERROGATION_EVENT_IGNORED)) { IEC104_ReadEventResult_t read_result = IEC104_Read_Handle_Event(app->read, event); if (read_result == IEC104_READ_EVENT_ERROR || !IEC104_Read_Get_Status(app->read, &app->rd)) { return false; } if (read_result != IEC104_READ_EVENT_IGNORED && event->transport.type == IEC104_TCP_EVENT_I_FRAME) { return true; } } if (app->system_command != NULL && (event->transport.type != IEC104_TCP_EVENT_I_FRAME || result == IEC104_INTERROGATION_EVENT_IGNORED)) { IEC104_SystemCommandEventResult_t handled = IEC104_SystemCommand_Handle_Event(app->system_command, event); if (handled == IEC104_SYSTEM_COMMAND_EVENT_ERROR) { return false; } if (handled == IEC104_SYSTEM_COMMAND_EVENT_HANDLED && event->transport.type == IEC104_TCP_EVENT_I_FRAME) { return true; } } /* 参数置于未知类型兜底前;HANDLED包含拒绝和槽满丢新,不能再回44。 * 生命周期通知仍逐个广播给本模块,不能因其他业务接手而跳过会话清理。 */ if (app->parameter != NULL && (event->transport.type != IEC104_TCP_EVENT_I_FRAME || result == IEC104_INTERROGATION_EVENT_IGNORED)) { IEC104_ParameterEventResult_t handled = IEC104_Parameter_Handle_Event(app->parameter, event); if (handled == IEC104_PARAMETER_EVENT_ERROR) { return false; } if (handled == IEC104_PARAMETER_EVENT_HANDLED && event->transport.type == IEC104_TCP_EVENT_I_FRAME) { return true; } } /* 200–203在标准参数之后接手;HANDLED还包括满槽丢新和faulted丢弃,不能再回44。 * 生命周期继续广播,尤其不可漏掉旧代次DISCARD所依赖的断线清理。 */ if (app->remote_parameter != NULL && (event->transport.type != IEC104_TCP_EVENT_I_FRAME || result == IEC104_INTERROGATION_EVENT_IGNORED)) { IEC104_RemoteParameterEventResult_t handled = IEC104_RemoteParameter_Handle_Event(app->remote_parameter, event); if (handled == IEC104_REMOTE_PARAMETER_EVENT_ERROR) { return false; } if (handled == IEC104_REMOTE_PARAMETER_EVENT_HANDLED && event->transport.type == IEC104_TCP_EVENT_I_FRAME) { return true; } } if (app->file_service != NULL && (event->transport.type != IEC104_TCP_EVENT_I_FRAME || result == IEC104_INTERROGATION_EVENT_IGNORED)) { IEC104_FileServiceEventResult_t handled; unsigned steps = 0U; /* 此处是“先读空通知再执行”的唯一业务例外:环满时保留当前event和ASDU视图, * 不调用NextEvent、不分派后续通知;Execute只推进暂存/收尾,COMMIT仍检查READY。 * 被保留的是最后一条通知时Check_Request可为READY,此时允许交付已安排的COMMIT。 * 内存回调短时完成;真实Flash接入必须约束整轮写回调累计耗时,不能只测单次write。 * BUSY不等于已消费;只有重试返回HANDLED才能读下一条,ERROR或超过上界立即停止。 */ while ((handled = IEC104_FileService_Handle_Event(app->file_service, event)) == IEC104_FILE_SERVICE_EVENT_BUSY) { if (++steps > IEC104_FILE_SERVICE_BUSY_STEP_LIMIT || IEC104_FileService_Execute_Next(app->file_service, &example_file_handlers, app) != IEC104_FILE_SERVICE_EXECUTE_OK) { return false; } } if (handled == IEC104_FILE_SERVICE_EVENT_ERROR) { return false; } if (handled == IEC104_FILE_SERVICE_EVENT_HANDLED && event->transport.type == IEC104_TCP_EVENT_I_FRAME) { return true; } } /* 211接在文件服务之后、未知类型兜底之前;HANDLED含拒绝和故障丢弃,不能再回复44。 */ if (app->software_upgrade != NULL && (event->transport.type != IEC104_TCP_EVENT_I_FRAME || result == IEC104_INTERROGATION_EVENT_IGNORED)) { IEC104_SoftwareUpgradeEventResult_t handled = IEC104_SoftwareUpgrade_Handle_Event(app->software_upgrade, event); if (handled == IEC104_SOFTWARE_UPGRADE_EVENT_ERROR) { return false; } if (handled == IEC104_SOFTWARE_UPGRADE_EVENT_HANDLED && event->transport.type == IEC104_TCP_EVENT_I_FRAME) { return true; } } if (result != IEC104_INTERROGATION_EVENT_IGNORED || event->transport.type != IEC104_TCP_EVENT_I_FRAME || !app->gi.active || event->transport.generation != app->gi.generation) { return true; } /* 当前事件当场提交,必须在NextEvent读取后续通知之前调用;应用不保存兜底请求。 * HIGH满只丢本条并计数;原连接停用/断开则取消,不跨启停续发。 */ ++app->other_rejected; switch (IEC104_Slave_Reject_Request(app->slave, event, IEC60870_ASDU_COT_UNKNOWN_TYPE)) { case IEC104_TCP_SUBMIT_OK: ++app->other_submitted; break; case IEC104_TCP_SUBMIT_WAIT: ++app->other_overloads; break; case IEC104_TCP_SUBMIT_FATAL: /* 可能已写出字节;cancelled仅表示不再重试,继续读取断线通知。 */ ++app->other_cancelled; break; default: ++app->other_cancelled; break; } return true; } /* ============================================================================ * [COMMON/LOOP] 公共主循环:协调所有业务并读空Slave通知 * ============================================================================ */ /** * 功能:strict_business_priority关闭时保留原应用调用顺序及两类召唤轮换,不用严格调度的业务轮接口。 * 输入参数:app——示例应用上下文。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。 * 说明:已执行参数/校时确认先重试,随后遥控、读命令、系统命令、发布队列、两类召唤轮换、新校时/参数及扫描。 * app为有效上下文;返回true表示本轮成功或因未读通知暂缓,false交给主循环停止并清理。 * Command_Process只推进协议应答,Drain_Command才执行应用决定及结果/返回信息步骤,最后刷新调度快照。 * 通知预算尚未读空时不能调用Accept;否则可能在尚未分派的STOP或撤销之后错误启动设备。 */ static bool Example_Step_Compatible(ExampleApp *app) { if (app->quiescing || example_upgrade_device.taken) { return true; } if (app->events_pending) { return true; } /* 即使--events=0也继续收敛遥调产生的阶跃;lookup和发送重试不推进滤波。 */ Example_Update_Measurements(app); if (app->parameter != NULL) { if (!IEC104_Parameter_Get_Status(app->parameter, &app->parameter_status)) { return false; } if (app->parameter_status.confirm_pending && !IEC104_Parameter_Process(app->parameter)) { return false; } } /* 优先重试已经执行动作的校时确认;HIGH拥塞不暂停独立的NORMAL发布。 * 随后的读命令仍须通过自己的HIGH余量预检,不能因业务独立就绕过背压。 */ if (app->clock != NULL) { if (!IEC104_ClockSynchronization_Get_Status(app->clock, &app->cs)) { return false; } if (app->cs.confirm_pending && (!IEC104_ClockSynchronization_Process(app->clock) || !IEC104_ClockSynchronization_Get_Status(app->clock, &app->cs))) { return false; } } if (!Example_Collect_Events(app)) { return false; } if (app->command != NULL && (!IEC104_Command_Process(app->command) || !Example_Drain_Command(app) || !IEC104_Command_Get_Status(app->command, &app->command_status))) { return false; } /* 读可见本轮已执行遥控的新值;位置本身不保证与校时等其他HIGH生产者的应答先后。 * 105先推进观察记录,211再重试提交,最后统一领取,避免同轮各取一次设备动作授权。 */ if (!Example_Step_Read(app) || !Example_Step_SystemCommand(app) || !Example_Step_SoftwareUpgrade(app) || app->user_log_failed || !Example_Arbitrate_Restart(app)) { return false; } /* 先观察本轮Type70是否已交接,使下面GI消费者只在初始化完成后领取BEGIN。 */ if (!Example_Startup_Step(app)) { return false; } /* 授权已交给应用,立即让出正常业务Step;主循环收尾前不再发布变化或启动新的业务动作。 */ if (app->restart_requested) { return true; } if (!Example_Publish_Recording(app) || !Example_Collect_Measurement_Changes(app) || !Example_Drain_Publications(app)) { return false; } /* 轮换两类召唤的推进机会;这只是应用调用次序,不承诺跨业务报文先后。 */ app->counter_first = !app->counter_first; if (app->counter_first) { if (!Example_Step_Counter(app) || !Example_Step_General(app)) { return false; } } else { if (!Example_Step_General(app) || !Example_Step_Counter(app)) { return false; } } /* GI消费者可能刚保存末站完成票据;再次检查可及时放行,PENDING仍留待网络推进。 */ if (!Example_Startup_Step(app)) { return false; } /* 参数动作位于复位授权检查之后、空闲扫描之前;本轮QPA=3的启停立即影响随后扫描。 * 总召本轮先前已取的批次仍可带旧值,下一批再读取运行值,不构造整轮快照。 */ /* 远程参数使用同一串行循环发布运行值;各模块FIFO仅保证各自顺序,不组成跨模块事务。 */ if (!Example_Step_Clock(app) || !Example_Step_Parameter(app) || app->user_log_failed || !Example_Step_RemoteParameter(app) || app->user_log_failed || !Example_Step_FileService(app)) { return false; } /* 参数动作可立即改变范围品质或关闭平滑;排队后下轮按正常发布顺序交接。 */ if (!Example_Collect_Measurement_Changes(app)) { return false; } /* 周期/背景扫描最后推进,使本轮其他业务先提交已准备好的HIGH/NORMAL数据;发送层仍会复查IDLE准入。 * 总召期间不额外暂停背景组,取数间隙若满足准入仍可扫描;名义周期不保证送达时限。 * IDLE/WAIT/PROGRESS都可正常交回主循环,是否立即续跑由下一次Get_Status决定,不能对WAIT就地重试。 */ return app->periodic_scan == NULL || IEC104_PeriodicScan_Step(app->periodic_scan, Example_PeriodicScan_Point, app) != IEC104_PERIODIC_SCAN_STEP_ERROR; } /** * 功能:Begin后的NONE阶段先处理期限、会话失效和已有回复,再为各等级准备新候选,避免过期工作继续参与发送。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。 * 说明:此时不交接IDLE或队满旁路帧,但所有固定回复仍可入队;不能以发送等级为由停掉其他模块期限。 * 本阶段不执行lookup、设备动作或文件读;这些工作留到所属等级,并继续使用模块自身的WAIT契约。 */ static bool Example_Maintain_Business(ExampleApp *app) { return IEC104_Interrogation_Process(app->interrogation) && (app->counter == NULL || IEC104_Interrogation_Process(app->counter)) && (app->command == NULL || IEC104_Command_Process(app->command)) && (app->clock == NULL || IEC104_ClockSynchronization_Process(app->clock)) && (app->read == NULL || IEC104_Read_Process(app->read)) && (app->system_command == NULL || IEC104_SystemCommand_Process(app->system_command)) && (app->parameter == NULL || IEC104_Parameter_Process(app->parameter)) && (app->remote_parameter == NULL || IEC104_RemoteParameter_Process(app->remote_parameter)) && (app->file_service == NULL || IEC104_FileService_Process(app->file_service)) && (app->software_upgrade == NULL || IEC104_SoftwareUpgrade_Process(app->software_upgrade)); } /** * 功能:BEGIN决定和每批数据交接之后,Process才会准备下一条CON/NEED_DATA/TERM。 * 输入参数:app——示例应用上下文;counter——是否推进计数量召唤。 * 输出参数:无独立输出参数。 * 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。 * 说明:离开当前等级前有界续推这些本地步骤,不能把尚未调用Process误认为没有可发业务。 * 预算限制本地推进次数,不是每轮发送帧数;遇发送WAIT或应用保留事件即停止,绝不就地等待网络。 */ static bool Example_Drain_Interrogation_Priority(ExampleApp *app, bool counter) { unsigned round; for (round = 0U; round < EXAMPLE_EVENT_BUDGET; ++round) { IEC104_InterrogationStatus_t *status = counter ? &app->ci : &app->gi; if (counter) { if (!Example_Step_Counter(app)) { return false; } if (app->counter == NULL || app->counter_pending) { return true; } } else { if (!Example_Step_General(app)) { return false; } if (app->business_pending || !IEC104_Startup_Can_Consume_General(&app->startup)) { return true; } } if (status->waiting || status->data_send_waiting || (!status->need_process && status->pending_events == 0U)) { return true; } } /* 等级取自受理时冻结的任务;不能把当前phase2误当成正在准备的普通总召5。 * pending只补记预算用完后仍可立即准备的候选,不预约发送容量;它保留到下一次Begin,约束其间选帧。 * 应用取数、初始化前置及发送WAIT已在循环内退出,不能借此把等待外部条件的任务变成低级业务屏障。 */ { IEC104_BusinessPriority_t priority = IEC104_Interrogation_Get_Pending_Priority( counter ? app->counter : app->interrogation); return priority == IEC104_BUSINESS_PRIORITY_NONE || IEC104_Slave_Set_Pending_Business_Priority(app->slave, priority) == IEC104_TCP_SUBMIT_OK; } } /** * 功能:同一轮只采样一次;随后按12级业务优先级递增准备候选,不重复执行十二轮完整应用Step。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。 * 说明:阶段限制IDLE和队满旁路;非当前等级的固定回复仍可入队,最终线序由发送层同时比较队列与候选。 * 入队本身不发送。HIGH已满时仅当前等级可尝试旁路,与IDLE共用本轮一次直接交接额度,低级不得先占帧边界。 * System/GI分别承载多个等级,重复推进仍由模块的请求身份、FIFO和已提交状态防止重复动作/报文。 */ static bool Example_Step_Strict(ExampleApp *app) { unsigned priority; if (!Example_Maintain_Business(app)) { return false; } /* 先由维护更新ACK/期限,再统一领取仍有效的重启许可;领取成功即停止新采样和候选准备。 * 复位业务等级约束报文候选,不把已成立的设备重启授权延后到该阶段,避免其间再启动其他动作。 */ Example_Take_System_Reset(app); if (!Example_Arbitrate_Restart(app)) { return false; } if (app->restart_requested) { return true; } Example_Update_Measurements(app); if (!Example_Collect_Events(app) || !Example_Collect_Measurement_Changes(app) || !Example_Drain_Publications(app)) { return false; } for (priority = IEC104_BUSINESS_PRIORITY_INITIALIZATION; priority < IEC104_BUSINESS_PRIORITY_COUNT; ++priority) { if (IEC104_Slave_Set_Business_Priority(app->slave, (IEC104_BusinessPriority_t)priority) != IEC104_TCP_SUBMIT_OK) { return false; } switch ((IEC104_BusinessPriority_t)priority) { case IEC104_BUSINESS_PRIORITY_INITIALIZATION: if (app->system_command != NULL && !IEC104_SystemCommand_Process(app->system_command)) { return false; } if (!Example_Startup_Step(app)) { return false; } break; case IEC104_BUSINESS_PRIORITY_INITIAL_INTERROGATION: if (!Example_Drain_Interrogation_Priority(app, false) || !Example_Startup_Step(app)) { return false; } break; case IEC104_BUSINESS_PRIORITY_COMMAND: if (app->command != NULL && (!IEC104_Command_Process(app->command) || !Example_Drain_Command(app) || !IEC104_Command_Process(app->command) || !IEC104_Command_Get_Status(app->command, &app->command_status))) { return false; } if (!Example_Step_Parameter(app) || app->user_log_failed || !Example_Step_RemoteParameter(app) || app->user_log_failed) { return false; } /* 参数或遥调改变本轮品质/处理值时,须在后面的事件/遥测机会前形成候选。 */ if (!Example_Collect_Measurement_Changes(app)) { return false; } break; case IEC104_BUSINESS_PRIORITY_SEQUENCE_EVENT: case IEC104_BUSINESS_PRIORITY_FAULT_EVENT: /* 严格调度模式在故障优先级形成录波简报,再由原有发布队列推进发送。 */ if (priority == IEC104_BUSINESS_PRIORITY_FAULT_EVENT && !Example_Publish_Recording(app)) { return false; } if (!Example_Drain_Publications(app)) { return false; } break; case IEC104_BUSINESS_PRIORITY_INTERROGATION: if (!Example_Drain_Interrogation_Priority(app, false) || !Example_Step_Read(app) || !Example_Startup_Step(app)) { return false; } break; case IEC104_BUSINESS_PRIORITY_CLOCK: if (app->system_command != NULL && !IEC104_SystemCommand_Process(app->system_command)) { return false; } if (!Example_Step_Clock(app)) { return false; } if (app->clock != NULL && !IEC104_ClockSynchronization_Process(app->clock)) { return false; } break; case IEC104_BUSINESS_PRIORITY_MEASUREMENT: if (!Example_Drain_Publications(app)) { return false; } if (app->periodic_scan != NULL && IEC104_PeriodicScan_Step(app->periodic_scan, Example_PeriodicScan_Point, app) == IEC104_PERIODIC_SCAN_STEP_ERROR) { return false; } break; case IEC104_BUSINESS_PRIORITY_RESET: if (!Example_Step_SystemCommand(app) || !Example_Step_SoftwareUpgrade(app) || app->user_log_failed || !Example_Arbitrate_Restart(app)) { return false; } if (app->system_command != NULL && !IEC104_SystemCommand_Process(app->system_command)) { return false; } if (app->restart_requested) { return true; } break; case IEC104_BUSINESS_PRIORITY_FILE_CALL: { unsigned round; /* OPEN/CLOSE等本地步骤之后才会形成目录回复。先有界续推CONTROL,不能让旧读数据抢在目录之前。 * 只有预算耗尽且目录仍execute_ready才登记10级候选,连下一次Poll也不能越过它选低级帧。 * 单有活动读句柄或未完成请求不够;等待ACK、数据或发送余量时仍须让出,其他模块维护已先完成。 */ for (round = 0U; round < EXAMPLE_EVENT_BUDGET; ++round) { IEC104_FileServiceExecuteResult_t executed; if (!Example_Step_FileService_Mode(app, IEC104_FILE_SERVICE_EXECUTE_CONTROL, &executed)) { return false; } if (executed != IEC104_FILE_SERVICE_EXECUTE_OK) { break; } } if (round == EXAMPLE_EVENT_BUDGET && app->file_status.execute_ready && app->file_status.directory_active && app->file_status.pending_requests != 0U && IEC104_Slave_Set_Pending_Business_Priority(app->slave, IEC104_BUSINESS_PRIORITY_FILE_CALL) != IEC104_TCP_SUBMIT_OK) { return false; } break; } case IEC104_BUSINESS_PRIORITY_FILE_TRANSFER: /* 第十级已准备控制候选,第十一级只推进数据;读回调不获得额外发送资格。 */ if (!Example_Step_FileService_Mode(app, IEC104_FILE_SERVICE_EXECUTE_DATA, NULL)) { return false; } break; case IEC104_BUSINESS_PRIORITY_COUNTER_INTERROGATION: if (!Example_Drain_Interrogation_Priority(app, true)) { return false; } break; default: return false; } } return true; } /** * 功能:在匹配的业务收集周期内推进一次应用业务。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。 * 说明:Begin/End限定候选收集轮,不代替Poll。只有Begin成功才配对End;业务失败或已领取重启授权的提前返回也须End。 * 服务使用业务轮后,每次新I帧交接后暂停下一帧编号,直到下一次Begin重新收集;连续Poll不能绕过未组帧候选。 * 已编号帧的续写以及S/U帧、ACK仍由网络推进,严格排序不打断正在发送的APDU。 * 历史观测接在成功业务推进之后;严格路径的 Begin 等待不补做过去定点,持久化错误照常传播。 */ static bool Example_Step(ExampleApp *app) { IEC104_TcpSubmitResult_t result; bool succeeded; /* 这里只停止新业务轮;Cancel、生命周期分派及Drain_Finished不经此门,必须继续归还旧资源。 */ if (app->user_log_failed || app->upgrade_store_failed) { return false; } if (!IEC104_Slave_Strict_Priority_Enabled(app->slave)) { return Example_Step_Compatible(app) && Example_History_Observe(app) && Example_Energy_Step(app) && !app->user_log_failed && !app->upgrade_store_failed; } if (app->quiescing || example_upgrade_device.taken || app->events_pending) { return true; } result = IEC104_Slave_Begin_Business_Cycle(app->slave); if (result == IEC104_TCP_SUBMIT_WAIT) { return true; } if (result != IEC104_TCP_SUBMIT_OK) { return false; } succeeded = Example_Step_Strict(app); /* 无论业务成功与否都结束已开启的收集轮;只有两者成功才把最终遥测交给历史核心。 */ result = IEC104_Slave_End_Business_Cycle(app->slave); return succeeded && result == IEC104_TCP_SUBMIT_OK && Example_History_Observe(app) && Example_Energy_Step(app) && !app->user_log_failed && !app->upgrade_store_failed; } /** * 功能:有界消费通知。预算用完先续读,不能跨过排在后面的STOP/START直接续发旧总召或执行旧遥控。 * 输入参数:app——示例应用上下文。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。 * 说明:只有读到EMPTY才清events_pending并允许Example_Step推进动作,避免用最终激活状态掩盖中间STOP。 * 广播撤销也须先分派:否则应用可能在COT=8已到达但尚未处理时,先接受后续站的BEGIN。 * 文件BUSY例外在Handle_Event内同步保留本条通知,有限步腾出数据槽后才进入下一次NextEvent。 */ static bool Example_Drain(ExampleApp *app) { unsigned count; IEC104_SlaveEvent_t event; Example_Refresh_System_Clock(app, false); for (count = 0U; count < EXAMPLE_EVENT_BUDGET; ++count) { IEC104_TcpEventResult_t result = IEC104_Slave_NextEvent(app->slave, &event); if (result == IEC104_TCP_EVENT_EMPTY) { app->events_pending = false; return true; } if (result != IEC104_TCP_EVENT_READY || !Example_Handle_Event(app, &event)) { return false; } } app->events_pending = true; return true; } /* ============================================================================ * [COMMON/LIFECYCLE] 跨业务生命周期:终结排空、协议重建与引用归还 * ============================================================================ */ /** * 功能:在取消后排空业务终结事件并归还应用持有的引用。 * 输入参数:app——示例应用上下文。 * 输出参数:无独立输出参数。 * 返回值:true表示本轮推进无错误,仍可能保留待办或等待;false表示推进失败。 * 说明:仅用于Cancel之后的收尾,绝不能改成调用普通Example_Drain:后者会分派新的Slave I帧。 * 各Drain有独立预算,须循环到所有业务队列为空且三份应用站点引用都已归还。 * pending每轮必须下降,防止违反收尾约定时无进展自旋;失败交上层停止重建。 * 本函数不要求Slave通知为空;Close之后还须分派非I帧,再调用本函数处理新增终结通知。 */ static bool Example_Drain_Finished(ExampleApp *app) { unsigned previous = UINT_MAX; /* 收尾不再尝试放行启动流程。先归还集合锁及读取引用,避免历史COMPLETED * 因尚未分派的Slave通知反复WAIT,阻断后面的FINISHED清理。 * Reset不消费Slave通知、不开放发送门禁;取消后的资源清理不依赖连接仍然可用。 */ if (!Example_Startup_Reset(app)) { return false; } for (;;) { unsigned pending; if (!Example_Drain_Business(app) || !Example_Drain_Counter(app) || !Example_Drain_Command(app) || !IEC104_Interrogation_Get_Status(app->interrogation, &app->gi)) { return false; } pending = app->gi.pending_events; if (app->counter != NULL) { if (!IEC104_Interrogation_Get_Status(app->counter, &app->ci)) { return false; } pending += app->ci.pending_events; } if (app->command != NULL) { if (!IEC104_Command_Get_Status(app->command, &app->command_status)) { return false; } pending += app->command_status.pending_events; } if (app->file_service != NULL) { unsigned file_pending; if (!IEC104_FileService_Get_Status(app->file_service, &app->file_status)) { return false; } if (app->file_status.finish_pending) { /* Cancel已把所有未执行COMMIT改为ABORT;离线也可交付,不等待通知或发送容量。 * 每轮最多交付一个,应用持有资源数计入下降量,禁止仅用布尔pending判断进展。 */ if (IEC104_FileService_Execute_Next(app->file_service, &example_file_handlers, app) != IEC104_FILE_SERVICE_EXECUTE_OK || !IEC104_FileService_Get_Status(app->file_service, &app->file_status)) { return false; } } file_pending = (app->files.directory.active ? 1U : 0U) + (app->files.read.active ? 1U : 0U) + (app->files.stage.active ? 1U : 0U) + (example_upgrade_device.context == app && example_upgrade_device.file.active ? 1U : 0U); /* 示例每类仅一个应用资源;协议清理标志必须与剩余所有权一致,不能带着悬挂句柄重建。 */ if ((file_pending != 0U) != app->file_status.finish_pending) { return false; } pending += file_pending; } if (app->software_upgrade != NULL) { /* Cancel已清执行FIFO,此处只能交付ABANDON;允许有未读通知时返回EMPTY。 * 文件最终回调与ABANDON任一先完成都不提前放开owner,最后一个义务结束才释放。 */ IEC104_SoftwareUpgradeExecuteResult_t executed = IEC104_SoftwareUpgrade_Execute_Next(app->software_upgrade, Example_Upgrade_Action, app); if ((executed != IEC104_SOFTWARE_UPGRADE_EXECUTE_OK && executed != IEC104_SOFTWARE_UPGRADE_EXECUTE_EMPTY) || !IEC104_SoftwareUpgrade_Get_Status(app->software_upgrade, &app->upgrade_status)) { return false; } pending += app->upgrade_status.abandon_pending ? 1U : 0U; } if (pending == 0U) { return app->gi_station == NULL && app->counter_station == NULL && app->command_station == NULL; } if (pending >= previous) { return false; } previous = pending; } } /** * 功能:协议实例模拟重启:不重启宿主、不操作硬件,只在正常Step返回且应用已取得复位授权后调用。 * 输入参数:app——示例应用上下文;config——初始化配置。 * 输出参数:app——本次操作更新的实例或工作区。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:顺序为Cancel -> 业务终结读空 -> Close -> Slave收尾读空 -> 新业务终结读空 -> 清应用状态 -> Init。 * 全部模块保留对象地址并收到非I帧收尾通知;本函数内不执行业务Step、不重新受理残留I帧。 * config来自main保存的原配置;port=0启动时main已换成实际端口,确保重建后仍在原端口监听。 * false表示某步未完成,主循环进入退出清理;不能绕过失败继续清事务字段或宣称重建成功。 */ static bool Example_Rebuild_Protocol(ExampleApp *app, const IEC104_SlaveConfig_t *config) { #ifdef IEC104_EXAMPLE_DTU_PROFILE static const int32_t initial[EXAMPLE_COUNTER_COUNT] = {0}; #else static const int32_t initial[EXAMPLE_COUNTER_COUNT] = {120000, 345600, 7890, 0, 1, 65535, INT32_MAX, 42}; #endif IEC104_SlaveEvent_t event; IEC104_TcpEventResult_t next; size_t index; /* 短延时可跨多轮;收尾和运行值复位只做一次,后续直接进入激活等待/Init阶段。 */ if (app->restart_quiesced) { goto initialize_protocol; } Example_Cancel(app); /* 此时FINISHED仍可能引用旧事务编号和原站context,先处理完才能关闭/重置应用状态。 */ if (!Example_Drain_Finished(app) || IEC104_Slave_Close(app->slave, NULL) != IEC104_TCP_OK) { return false; } while ((next = IEC104_Slave_NextEvent(app->slave, &event)) == IEC104_TCP_EVENT_READY) { if (event.transport.type != IEC104_TCP_EVENT_I_FRAME && !Example_Handle_Event(app, &event)) { return false; } } if (next != IEC104_TCP_EVENT_EMPTY || !Example_Drain_Finished(app) || !Example_Drain_RemoteParameter(app)) { return false; } /* 105只复位协议和演示运行点;已COMMIT的文件保留,旧暂存/读锁/目录快照已排空。 * faulted不能靠普通协议复位恢复,须结束服务后销毁故障实例。 */ if (app->file_service != NULL && app->file_status.faulted) { return false; } if (app->software_upgrade != NULL && app->upgrade_status.faulted) { return false; } if (app->remote_parameter != NULL) { /* 旧批次和清理义务已结束;持久化模式保留选区和已固化值,RAM模式恢复初值。 * faulted不能靠复位绕过;映像版本/CRC始终不在此清零。 */ if (app->remote_status.faulted) { return false; } if (app->config_path == NULL) { Example_Reset_Remote_Values(app); } Example_Remote_Report_Settings(app, "reset", app->remote_area); } /* Close已经清空发送队列,所有旧事务通知也已处理;以下仅恢复应用运行值与游标。 * 模块统计从Create累计,保留模块对象意味着这些诊断数不会随模拟复位清零。 */ app->business_pending = app->counter_pending = app->command_pending = false; app->command_waiting = app->command_selected = app->command_output = false; app->command_step = 0U; app->session_instance = app->session_request = app->counter_instance = app->counter_request = 0U; app->command_instance = app->command_transaction = 0U; app->command_soe_active = false; app->command_soe_instance = app->command_soe_transaction = 0U; memset(&app->command_soe_ticket, 0, sizeof(app->command_soe_ticket)); memset(&app->gi_data, 0, sizeof(app->gi_data)); app->counter_cursor = app->counter_end = 0U; app->counter_first = false; app->energy_snapshot_instance = app->energy_snapshot_request = 0U; app->publication_count = 0U; app->publication_waiting = app->events_pending = false; /* QRP1从第0拍重新开始,DTU另在下方重设30秒工况起点;保留CLI选择的field/stress * 及采样间隔,下一拍仍等待一个间隔。 * 普通STOP/重连与QRP2不走这里,继续原模拟相位,不能把每次重连当成设备重新上电。 */ app->events_index = 0U; app->events_measurement = false; app->events_last_ms = IEC104_Net_Now_Ms(); app->command_action_called = app->command_has_change = false; app->clock_valid = app->clock_update_pending = false; if (app->command != NULL) { IEC104_Command_Clear_Time_Base(app->command); } IEC104_Spontaneous_Clear_Time_Base(app->spontaneous); /* 模拟重建协议实例时恢复步位置、位串和单/双点初值;旧事务/发布占位已在上方排空。 * 普通STOP/START及重连不走此路径,也不能在每条命令FINISHED时清零运行值。 */ memset(app->step_values, 0, sizeof(app->step_values)); memset(app->bitstring_values, 0, sizeof(app->bitstring_values)); for (index = 0U; index < EXAMPLE_SIGNAL_COUNT; ++index) { app->signal_values[index] = Example_Initial_Signal(index); } for (index = 0U; index < EXAMPLE_DOUBLE_COUNT; ++index) { #ifdef IEC104_EXAMPLE_DTU_PROFILE app->double_values[index] = 2U; #else app->double_values[index] = 1U; #endif } #ifdef IEC104_EXAMPLE_DTU_PROFILE /* 重建重置DTU工况、过流延时与普通模式电量/冻结快照。 * 可选energy服务拥有独立持久计量状态,不在这些演示数组中,也不随此处清零。 */ app->dtu_started_ms = IEC104_Net_Now_Ms(); app->dtu_signal_pending = 0U; Example_Dtu_Reset_Process(app); app->dtu_energy_last_ms = app->dtu_started_ms; memset(app->dtu_energy_wh, 0, sizeof(app->dtu_energy_wh)); memset(app->dtu_energy_frozen_wh, 0, sizeof(app->dtu_energy_frozen_wh)); #endif for (index = 0U; index < EXAMPLE_MEASUREMENT_COUNT; ++index) { app->scaled_values[index] = Example_Initial_Measurement(index); } /* 旧任务已清除。纯内存演示恢复参数初值;有配置文件时QRP1只复位协议与测量状态, * 保留当前运行参数及dirty/退避状态,不能从较旧磁盘值覆盖尚未保存的有效修改。 */ if (app->parameter != NULL) { if (app->config_path == NULL) { Example_Reset_Parameter_Values(app); } else { Example_Reset_Measurements(app); } } /* 周期数组仍被扫描模块借用,逐点setter同时更新内部调度;不能直接改数组或清重试位图。 * 普通STOP/重连保留启停结果,只有本次模拟协议复位按示例策略恢复配置周期。 */ if (app->parameter_cyclic_ms != 0U) { for (index = 0U; index < EXAMPLE_SCAN_POINT_COUNT; ++index) { if ((app->scan_points[index].groups & 1U) != 0U && !IEC104_PeriodicScan_Set_Point_Period(app->periodic_scan, index, app->parameter_cyclic_ms)) { return false; } } } memset(app->counter_frozen, 0, sizeof(app->counter_frozen)); memset(app->counter_snapshot, 0, sizeof(app->counter_snapshot)); memset(app->counter_snapshot_time, 0, sizeof(app->counter_snapshot_time)); for (index = 0U; index < EXAMPLE_COUNTER_COUNT; ++index) { app->counter_current[index] = initial[index]; app->counter_frozen[index].value = initial[index]; Example_Counter_Time(app, &app->counter_frozen_time[index]); } app->restart_quiesced = true; initialize_protocol: /* 普通105没有taken升级任务,不调用Prepare_Boot;协议复位不能被解释为新的试运行启动。 * 达到短延时后一次性安装;之后任何初始化/确认失败都退出,避免第二次Prepare把本次TRIAL回退。 */ if (example_upgrade_device.context == app && example_upgrade_device.taken) { uint64_t now = IEC104_Net_Now_Ms(); if (now < example_upgrade_device.activation.taken_ms) { return false; } /* 监听和连接已关闭;主循环在QUIESCING内有界定时等待,不推进普通业务。 */ if (now - example_upgrade_device.activation.taken_ms < EXAMPLE_UPGRADE_DELAY_MS) { return true; } if (!Example_Upgrade_Prepare_Boot(app)) { return false; } } if (IEC104_Slave_Init(app->slave, config, NULL) != IEC104_TCP_OK || !IEC104_SystemCommand_Set_Initialization(app->system_command, 2U)) { return false; } /* COI2登记在尚未激活的新实例上;下一次ACTIVATED才开始逐站上送初始化结束。 * 新协议初始化全部成功才结清应用激活任务并发布版本/CRC,随后才恢复正常业务。 */ if (!Example_Upgrade_Confirm_Boot(app)) { return false; } Example_Refresh_System_Clock(app, true); Example_Upgrade_Activation_Finished(app, true); Example_User_Log_Append(app, 1U, 1U, IEC104_Net_Now_Ms(), "SIMULATED PROTOCOL_RESTART"); app->restart_requested = app->restart_quiesced = app->quiescing = false; ++app->protocol_restarts; return true; } /** * 功能:统一激活失败出口:保留最后确认的映像值、记录失败并释放内存任务。 * 输入参数:app——示例应用上下文;config——初始化配置。 * 输出参数:无独立输出参数。 * 返回值:true表示本次操作成功,false表示校验拒绝或处理失败。 * 说明:持久AUTH/TRIAL留给下次启动恢复,协议不会二次授权或重发确认。 */ static bool Example_Restart_Protocol(ExampleApp *app, const IEC104_SlaveConfig_t *config) { bool result = Example_Rebuild_Protocol(app, config); if (!result) { Example_Upgrade_Activation_Finished(app, false); } return result && !app->user_log_failed && !app->upgrade_store_failed; } /* ============================================================================ * [COMMON/DESTROY] 初始化失败及正常退出共用的资源释放 * ============================================================================ */ /** * 功能:释放已创建的业务模块并移除应用站点,供初始化回退及正常退出共用。 * 输入参数:app——非NULL,已由Example_Init清零并记录slave;非空业务句柄尚未销毁。 * 输出参数:归还业务模块槽及其站点引用,最后尝试移除仍注册的app->station。 * 返回值:true表示所有需要执行的释放均成功;任一失败返回false,但仍尝试其余释放。 * 说明:本函数不取消事务、不关闭连接,也不消费通知。运行期先Cancel并调用 * Example_Drain_Finished,再Close并分派剩余Slave通知,最后再次调用 * Example_Drain_Finished,确保终结事件读空、应用引用已归还后才进入本函数。 * 初始化失败尚未接收通知,允许部分句柄为NULL,无须走运行期排空流程。 * 扫描不跨调用持有站点引用,Destroy归还静态池槽并结束对app->scan_points的借用,不关闭Slave。 * 运行期仍统一遵守Cancel -> Close并读空通知 -> Destroy,确保扫描收到停用/断线后再结束借用。 * 本函数不清空句柄;即使返回false也可能已部分释放,不可重复调用或继续执行业务。 * Slave由main或测试夹具持有,须由调用方另行销毁;app存储本身仍属于调用方。 */ static bool Example_Destroy(ExampleApp *app) { bool result = true; if (!Example_Startup_Reset(app)) { result = false; } if (app->software_upgrade != NULL && !IEC104_SoftwareUpgrade_Destroy(app->software_upgrade)) { result = false; } if (example_upgrade_device.owned && example_upgrade_device.context == app) { result = false; } if (app->interrogation != NULL && !IEC104_Interrogation_Destroy(app->interrogation)) { result = false; } if (app->counter != NULL && !IEC104_Interrogation_Destroy(app->counter)) { result = false; } if (app->clock != NULL && !IEC104_ClockSynchronization_Destroy(app->clock)) { result = false; } if (app->command != NULL && !IEC104_Command_Destroy(app->command)) { result = false; } if (app->read != NULL && !IEC104_Read_Destroy(app->read)) { result = false; } if (app->parameter != NULL && !IEC104_Parameter_Destroy(app->parameter)) { result = false; } /* Destroy不隐式取消或回调清理;调用方必须先完成RemoteParameter专用排空。 */ if (app->remote_parameter != NULL && !IEC104_RemoteParameter_Destroy(app->remote_parameter)) { result = false; } /* 文件模块Destroy只归还协议池槽;应用目录/读锁/暂存必须已经在原context中完成收尾。 */ if (app->file_service != NULL && !IEC104_FileService_Destroy(app->file_service)) { result = false; } /* 历史和日志存储须晚于文件协议资源收尾关闭;这里释放缓存和文件锁,不清空持久记录。 * 初始化后半段失败也沿用此出口,不能因user_log_failed而遗漏已取得的存储锁。 */ if (app->history != NULL) { Example_History_Close(app->history); app->history = NULL; } if (app->energy != NULL) { IEC60870_EnergyFreezeStatus_t energy_status; if (IEC60870_EnergyFreeze_Get_Status(&app->energy->core, &energy_status)) { printf("ENERGY_FREEZE flowrev=%llu dropped=%llu evicted_unsealed=%lu seal_backlog=%lu faulted=%u\n", (unsigned long long)energy_status.flow_sequence, (unsigned long long)app->energy_meter->flowrev_dropped, (unsigned long)energy_status.evicted_unsealed, (unsigned long)energy_status.seal_backlog, energy_status.faulted ? 1U : 0U); } Example_Energy_Freeze_Close(app->energy); app->energy = NULL; app->energy_meter = NULL; } if (app->user_log != NULL) { Example_User_Log_Close(app->user_log); app->user_log = NULL; } /* 升级最终回调及内存owner已结清后才释放独占目录锁;Close不撤回持久授权或试运行事实。 */ if (app->upgrade_store != NULL) { Example_Upgrade_Store_Close(app->upgrade_store); app->upgrade_store = NULL; } if (app->system_command != NULL && !IEC104_SystemCommand_Destroy(app->system_command)) { result = false; } if (app->spontaneous != NULL && !IEC104_Spontaneous_Destroy(app->spontaneous)) { result = false; } if (app->periodic_scan != NULL && !IEC104_PeriodicScan_Destroy(app->periodic_scan)) { result = false; } if (IEC104_Station_Is_Registered(&app->station) && IEC104_Slave_Remove_Station(app->slave, &app->station) != IEC104_STATION_OK) { result = false; } return result; } /* ============================================================================ * [CLI/HELPERS] 程序入口辅助:平台依赖、退出信号、参数解析与帮助 * ============================================================================ */ #ifndef IEC104_SLAVE_EXAMPLE_NO_MAIN #ifndef _WIN32 #error "This executable uses the Windows network backend" #endif #ifndef _WIN32_WINNT /* GetTickCount64所需的最低Windows API声明;这里只用于示例运行时长,不处理业务时标。 */ #define _WIN32_WINNT 0x0600 #endif #ifndef WIN32_LEAN_AND_MEAN /* 只引入本入口需要的Windows基础声明,socket操作仍全部留在协议库的Net后端。 */ #define WIN32_LEAN_AND_MEAN #endif #include #include #include /* 信号处理器和主循环之间只交换停止标志;静态初始化为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