774 lines
40 KiB
C
774 lines
40 KiB
C
/* 附录 B 历史核心实现:有限容量事件环和 UTC+8 自然日测量记录。
|
|
* 持久记录采用显式小端字段及 CRC32,避免把结构填充、宿主字节序写入介质。
|
|
* 一个逻辑槽的原子替换由存储后端保证;这里负责记录校验、索引推导和保留规则。 */
|
|
#include "IEC60870_History.h"
|
|
|
|
#include <float.h>
|
|
#include <string.h>
|
|
|
|
#define HISTORY_HEADER_SIZE 36U
|
|
#define HISTORY_TRAILER_SIZE 4U
|
|
#define HISTORY_DAY_MS UINT64_C(86400000)
|
|
#define HISTORY_ZONE_MS UINT64_C(28800000)
|
|
#define HISTORY_INTERVAL_MS UINT64_C(900000)
|
|
#define HISTORY_MIN_UTC_MS UINT64_C(946656000000)
|
|
#define HISTORY_MAX_UTC_MS UINT64_C(4102415999999)
|
|
|
|
/**
|
|
* 功能:固定宽度整数逐字节读写;只访问调用方已校验可用的区域,不要求地址对齐。
|
|
* 输入参数:bytes——字节数据。
|
|
* 输出参数:无。
|
|
* 返回值:小端32位无符号整数。
|
|
* 说明:调用方保证源区域可读,不在此辅助入口进行长度检查。
|
|
*/
|
|
static uint32_t Read_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);
|
|
}
|
|
|
|
/**
|
|
* 功能:输出 4 字节小端整数,不依赖宿主整数在内存中的排列。
|
|
* 输入参数:value——待处理数值。
|
|
* 输出参数:bytes——编码或复制结果的目标字节区。
|
|
* 返回值:无。
|
|
* 说明:调用方保证目标区域容量足够;逐字节编码不要求地址对齐。
|
|
*/
|
|
static void Write_U32(uint8_t *bytes, uint32_t value)
|
|
{
|
|
unsigned i;
|
|
for (i = 0U; i < 4U; ++i) { bytes[i] = (uint8_t)(value >> (8U * i)); }
|
|
}
|
|
|
|
/**
|
|
* 功能:低 32 位在前,组合事件序号和 UTC 毫秒使用的 64 位字段。
|
|
* 输入参数:bytes——字节数据。
|
|
* 输出参数:无。
|
|
* 返回值:小端64位无符号整数。
|
|
* 说明:调用方保证源区域可读,不在此辅助入口进行长度检查。
|
|
*/
|
|
static uint64_t Read_U64(const uint8_t *bytes)
|
|
{
|
|
return (uint64_t)Read_U32(bytes) | ((uint64_t)Read_U32(bytes + 4U) << 32);
|
|
}
|
|
|
|
/**
|
|
* 功能:与 Read_U64 对称;序号和时标不经过浮点转换,避免丢失低位。
|
|
* 输入参数:value——待处理数值。
|
|
* 输出参数:bytes——编码或复制结果的目标字节区。
|
|
* 返回值:无。
|
|
* 说明:调用方保证目标区域容量足够;逐字节编码不要求地址对齐。
|
|
*/
|
|
static void Write_U64(uint8_t *bytes, uint64_t value)
|
|
{
|
|
Write_U32(bytes, (uint32_t)value);
|
|
Write_U32(bytes + 4U, (uint32_t)(value >> 32));
|
|
}
|
|
|
|
/**
|
|
* 功能:按位还原 binary32;Init 已检查目标浮点布局,memcpy 避免类型别名违规。
|
|
* 输入参数:bytes——字节数据。
|
|
* 输出参数:无。
|
|
* 返回值:从原始binary32位模式还原的浮点值,不保证有限。
|
|
* 说明:调用方保证源区域可读,不在此辅助入口进行长度检查。
|
|
*/
|
|
static float Read_Float(const uint8_t *bytes)
|
|
{
|
|
uint32_t bits = Read_U32(bytes);
|
|
float value;
|
|
memcpy(&value, &bits, sizeof(value));
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* 功能:将 binary32 位模式保存为小端整数;不做舍入或工程单位换算。
|
|
* 输入参数:value——待处理数值。
|
|
* 输出参数:bytes——编码或复制结果的目标字节区。
|
|
* 返回值:无。
|
|
* 说明:调用方保证目标区域容量足够;逐字节编码不要求地址对齐。
|
|
*/
|
|
static void Write_Float(uint8_t *bytes, float value)
|
|
{
|
|
uint32_t bits;
|
|
memcpy(&bits, &value, sizeof(bits));
|
|
Write_U32(bytes, bits);
|
|
}
|
|
|
|
/**
|
|
* 功能:同时排除 NaN 与正负无穷;失效测量不能进入定点或改变日极值。
|
|
* 输入参数:value——待处理数值。
|
|
* 输出参数:无。
|
|
* 返回值:true表示值既不是NaN也不是无穷,false表示非有限值。
|
|
* 说明:只根据传入数据计算或判定,不改写输入对象。
|
|
*/
|
|
static bool Finite(float value)
|
|
{
|
|
return value == value && value <= FLT_MAX && value >= -FLT_MAX;
|
|
}
|
|
|
|
/**
|
|
* 功能:反射形式 CRC32,覆盖头部及有效载荷,不包含最后的 CRC 字段自身。
|
|
* 输入参数:bytes——字节数据;size——字节数。
|
|
* 输出参数:无。
|
|
* 返回值:输入有效字节的CRC32最终值。
|
|
* 说明:只用于发现记录损坏,不提供来源认证或抗恶意篡改能力。
|
|
*/
|
|
static uint32_t Crc(const uint8_t *bytes, size_t size)
|
|
{
|
|
uint32_t crc = UINT32_MAX;
|
|
size_t i;
|
|
unsigned bit;
|
|
for (i = 0U; i < size; ++i) {
|
|
crc ^= bytes[i];
|
|
for (bit = 0U; bit < 8U; ++bit) {
|
|
crc = (crc >> 1) ^ ((crc & 1U) != 0U ? UINT32_C(0xedb88320) : 0U);
|
|
}
|
|
}
|
|
return ~crc;
|
|
}
|
|
|
|
/**
|
|
* 功能:按固定小端顺序把一个整数并入点表指纹,保证不同宿主得到相同结果。
|
|
* 输入参数:hash——当前点表指纹状态;value——待处理数值。
|
|
* 输出参数:无。
|
|
* 返回值:并入该整数后的32位指纹状态。
|
|
* 说明:校验值只用于内容一致性检查,不提供来源认证。
|
|
*/
|
|
static uint32_t Hash_U32(uint32_t hash, uint32_t value)
|
|
{
|
|
unsigned i;
|
|
for (i = 0U; i < 4U; ++i) { hash = (hash ^ (uint8_t)(value >> (8U * i))) * UINT32_C(16777619); }
|
|
return hash;
|
|
}
|
|
|
|
/**
|
|
* 功能:检查一组借用点表的地址范围和重复项;允许空组,但非空组必须有数组。
|
|
* 输入参数:points——信息对象地址白名单;count——数组项数。
|
|
* 输出参数:无。
|
|
* 返回值:true表示点表数量、地址及唯一性合法,false表示不满足。
|
|
* 说明:只根据传入数据计算或判定,不改写输入对象。
|
|
*/
|
|
static bool Points_Valid(const uint32_t *points, size_t count)
|
|
{
|
|
size_t i, j;
|
|
if ((count != 0U && points == NULL) || count > 65535U) { return false; }
|
|
for (i = 0U; i < count; ++i) {
|
|
if (points[i] == 0U || points[i] > UINT32_C(0xffffff)) { return false; }
|
|
for (j = 0U; j < i; ++j) { if (points[j] == points[i]) { return false; } }
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* 功能:对配置白名单做精确匹配;调用方仅在已通过配置校验的数组上使用。
|
|
* 输入参数:points——信息对象地址白名单;count——数组项数;ioa——信息对象地址。
|
|
* 输出参数:无。
|
|
* 返回值:true表示白名单存在完全相同的IOA,false表示不存在。
|
|
* 说明:只根据传入数据计算或判定,不改写输入对象。
|
|
*/
|
|
static bool Contains(const uint32_t *points, size_t count, uint32_t ioa)
|
|
{
|
|
size_t i;
|
|
for (i = 0U; i < count; ++i) { if (points[i] == ioa) { return true; } }
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* 功能:三组点数、点号及顺序均参与指纹,避免旧测量数组被新点表错误解释。
|
|
* 输入参数:config——配置及调用期间借用的元数据。
|
|
* 输出参数:无。
|
|
* 返回值:按配置内容和顺序计算的32位指纹。
|
|
* 说明:冻结宽限窗口不改变数据结构,故不参与指纹,允许调整后继续读取旧记录。
|
|
*/
|
|
static uint32_t Fingerprint(const IEC60870_HistoryConfig_t *config)
|
|
{
|
|
uint32_t hash = UINT32_C(2166136261);
|
|
size_t i;
|
|
hash = Hash_U32(hash, (uint32_t)config->soe_count);
|
|
for (i = 0U; i < config->soe_count; ++i) { hash = Hash_U32(hash, config->soe_ioas[i]); }
|
|
hash = Hash_U32(hash, (uint32_t)config->co_count);
|
|
for (i = 0U; i < config->co_count; ++i) { hash = Hash_U32(hash, config->co_ioas[i]); }
|
|
hash = Hash_U32(hash, (uint32_t)config->analog_count);
|
|
for (i = 0U; i < config->analog_count; ++i) { hash = Hash_U32(hash, config->analog_ioas[i]); }
|
|
return hash;
|
|
}
|
|
|
|
/**
|
|
* 功能:返回逻辑容量;定点按 32 日各 96 节布局,极值按 32 个日槽布局。
|
|
* 输入参数:kind——记录或文件类别。
|
|
* 输出参数:无。
|
|
* 返回值:该类别的逻辑槽容量;未知类别返回0。
|
|
* 说明:返回逻辑容量,不包含存储后端自行配置的冗余副本。
|
|
*/
|
|
uint32_t IEC60870_History_Slot_Count(IEC60870_HistoryKind_t kind)
|
|
{
|
|
switch (kind) {
|
|
case IEC60870_HISTORY_SOE: return IEC60870_HISTORY_SOE_CAPACITY;
|
|
case IEC60870_HISTORY_CO: return IEC60870_HISTORY_CO_CAPACITY;
|
|
case IEC60870_HISTORY_FIXPT: return IEC60870_HISTORY_DAYS * IEC60870_HISTORY_SLOTS_PER_DAY;
|
|
case IEC60870_HISTORY_EXV: return IEC60870_HISTORY_DAYS;
|
|
default: return 0U;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 功能:先限制可表示的日历,再加固定时区求日序;不使用宿主时区或夏令时设置。
|
|
* 输入参数:utc_ms——UTC纪元毫秒。
|
|
* 输出参数:无。
|
|
* 返回值:固定UTC+8本地日序;超出支持历法范围返回UINT32_MAX。
|
|
* 说明:只根据传入数据计算或判定,不改写输入对象。
|
|
*/
|
|
uint32_t IEC60870_History_Local_Day(uint64_t utc_ms)
|
|
{
|
|
if (utc_ms < HISTORY_MIN_UTC_MS || utc_ms > HISTORY_MAX_UTC_MS) { return UINT32_MAX; }
|
|
return (uint32_t)((utc_ms + HISTORY_ZONE_MS) / HISTORY_DAY_MS);
|
|
}
|
|
|
|
/**
|
|
* 功能:每条均含 36 字节头和 4 字节 CRC:事件载荷 8 字节,定点每点 5 字节, 极值每点 25 字节。
|
|
* 输入参数:self——只读模块实例;kind——记录或文件类别。
|
|
* 输出参数:无。
|
|
* 返回值:该类别按已配置点数计算的完整记录字节数,包含头和CRC。
|
|
* 说明:只编码配置中的实际点数,不保存数组尾部或 C 填充字节。
|
|
*/
|
|
static size_t Wire_Size(const IEC60870_History_t *self, IEC60870_HistoryKind_t kind)
|
|
{
|
|
size_t size = HISTORY_HEADER_SIZE + HISTORY_TRAILER_SIZE;
|
|
if (kind == IEC60870_HISTORY_SOE || kind == IEC60870_HISTORY_CO) { return size + 8U; }
|
|
return size + self->config.analog_count * (kind == IEC60870_HISTORY_FIXPT ? 5U : 25U);
|
|
}
|
|
|
|
/**
|
|
* 功能:构造历史记录公共头并清零保留字节。
|
|
* 输入参数:self——调用方持有的模块实例及当前状态;kind——记录或文件类别;sequence——顺序号;utc_ms——UTC纪元毫秒;day——相对1970-01-01的本地日序;
|
|
* slot——定点节号1..96;事件及极值公共头使用0。
|
|
* 输出参数:self——wire中的记录公共头。
|
|
* 返回值:无。
|
|
* 说明:头部布局:0..3 魔数,4 版本,5 类别,6 遥测点数,7 保留,8..11 点表指纹, 12..19 事件序号,20..27 UTC 毫秒,28..31 归属日,32..33 节号,
|
|
* 34..35 保留。 事件的归属日/节号为零,日记录的事件序号为零;先清头部保证保留位可校验。
|
|
*/
|
|
static void Header(IEC60870_History_t *self, IEC60870_HistoryKind_t kind,
|
|
uint64_t sequence, uint64_t utc_ms, uint32_t day, uint16_t slot)
|
|
{
|
|
memset(self->wire, 0, HISTORY_HEADER_SIZE);
|
|
memcpy(self->wire, "HST1", 4U);
|
|
self->wire[4] = 1U;
|
|
self->wire[5] = (uint8_t)kind;
|
|
self->wire[6] = kind >= IEC60870_HISTORY_FIXPT ? (uint8_t)self->config.analog_count : 0U;
|
|
Write_U32(self->wire + 8U, self->fingerprint);
|
|
Write_U64(self->wire + 12U, sequence);
|
|
Write_U64(self->wire + 20U, utc_ms);
|
|
Write_U32(self->wire + 28U, day);
|
|
self->wire[32] = (uint8_t)slot;
|
|
self->wire[33] = (uint8_t)(slot >> 8);
|
|
}
|
|
|
|
/**
|
|
* 功能:在复用工作区末尾补 CRC 后同步提交一个槽;不在这里推进事件计数或日期。
|
|
* 输入参数:self——调用方持有的模块实例及当前状态;kind——记录或文件类别;index——零基索引。
|
|
* 输出参数:self——本次操作后的运行状态及复用工作区。
|
|
* 返回值:OK表示操作完成;ERROR表示实例不可用、I/O失败或内容损坏。
|
|
* 说明:回调失败可能是最后同步结果不明,必须置故障态,防止用旧内存索引覆盖新数据。
|
|
*/
|
|
static IEC60870_HistoryResult_t Commit(IEC60870_History_t *self,
|
|
IEC60870_HistoryKind_t kind, uint32_t index)
|
|
{
|
|
size_t size = Wire_Size(self, kind);
|
|
Write_U32(self->wire + size - HISTORY_TRAILER_SIZE, Crc(self->wire, size - HISTORY_TRAILER_SIZE));
|
|
if (!self->store.commit(self->store.context, kind, index, self->wire, size)) {
|
|
self->faulted = true;
|
|
return IEC60870_HISTORY_ERROR;
|
|
}
|
|
return IEC60870_HISTORY_OK;
|
|
}
|
|
|
|
/**
|
|
* 功能:将槽读入实例工作区并严格校验:先长度/魔数/版本/CRC,再指纹及业务字段。
|
|
* 输入参数:self——调用方持有的模块实例及当前状态;kind——记录或文件类别;index——零基索引。
|
|
* 输出参数:self——复用工作区及读取校验可能锁存的故障状态。
|
|
* 返回值:OK表示操作完成;EMPTY表示没有所需记录或到期任务;CONFIG表示持久记录与当前配置指纹不符;ERROR表示实例不可用、I/O失败或内容损坏。
|
|
* 说明:EMPTY 仅转交后端无记录状态;损坏与读失败置故障态,点表不同返回 CONFIG。 对日记录还校验物理槽、归属日、节号、数值及时标的一致性,不能只凭 CRC 正确就接受语义不可能的记录。
|
|
* 成功后 wire 有效,下一次读写即覆盖它。
|
|
*/
|
|
static IEC60870_HistoryResult_t Load(IEC60870_History_t *self,
|
|
IEC60870_HistoryKind_t kind, uint32_t index)
|
|
{
|
|
size_t size = 0U, i;
|
|
IEC60870_HistoryResult_t result = self->store.read(self->store.context,
|
|
kind, index, self->wire, sizeof(self->wire), &size);
|
|
uint64_t utc_ms;
|
|
uint32_t day;
|
|
uint16_t slot;
|
|
if (result == IEC60870_HISTORY_EMPTY) { return result; }
|
|
if (result != IEC60870_HISTORY_OK || size < HISTORY_HEADER_SIZE + HISTORY_TRAILER_SIZE ||
|
|
size > sizeof(self->wire) || memcmp(self->wire, "HST1", 4U) != 0 ||
|
|
self->wire[4] != 1U || self->wire[5] != (uint8_t)kind || self->wire[7] != 0U ||
|
|
self->wire[34] != 0U || self->wire[35] != 0U ||
|
|
Read_U32(self->wire + size - HISTORY_TRAILER_SIZE) != Crc(self->wire, size - HISTORY_TRAILER_SIZE)) {
|
|
self->faulted = true;
|
|
return IEC60870_HISTORY_ERROR;
|
|
}
|
|
if (Read_U32(self->wire + 8U) != self->fingerprint) {
|
|
self->faulted = true;
|
|
return IEC60870_HISTORY_CONFIG;
|
|
}
|
|
if (size != Wire_Size(self, kind) ||
|
|
self->wire[6] != (kind >= IEC60870_HISTORY_FIXPT ? self->config.analog_count : 0U)) {
|
|
self->faulted = true;
|
|
return IEC60870_HISTORY_ERROR;
|
|
}
|
|
utc_ms = Read_U64(self->wire + 20U);
|
|
day = Read_U32(self->wire + 28U);
|
|
slot = (uint16_t)((uint16_t)self->wire[32] | ((uint16_t)self->wire[33] << 8));
|
|
if (utc_ms < HISTORY_MIN_UTC_MS || utc_ms > HISTORY_MAX_UTC_MS) { goto corrupt; }
|
|
if (kind == IEC60870_HISTORY_SOE || kind == IEC60870_HISTORY_CO) {
|
|
uint64_t sequence = Read_U64(self->wire + 12U);
|
|
uint32_t ioa = Read_U32(self->wire + HISTORY_HEADER_SIZE);
|
|
const uint8_t *p = self->wire + HISTORY_HEADER_SIZE;
|
|
if (sequence == 0U || (sequence - 1U) % IEC60870_History_Slot_Count(kind) != index ||
|
|
slot != 0U || day != 0U || p[4] > 3U || p[7] > 1U ||
|
|
(kind == IEC60870_HISTORY_SOE && (p[6] != 0U || !Contains(self->config.soe_ioas, self->config.soe_count, ioa))) ||
|
|
(kind == IEC60870_HISTORY_CO && (p[6] > IEC60870_HISTORY_CANCEL || p[5] != 0U ||
|
|
!Contains(self->config.co_ioas, self->config.co_count, ioa)))) { goto corrupt; }
|
|
} else {
|
|
if (Read_U64(self->wire + 12U) != 0U || self->config.analog_count == 0U) { goto corrupt; }
|
|
if (kind == IEC60870_HISTORY_FIXPT) {
|
|
/* 归属按区间终点计算;允许的硬上限固定为 1000 毫秒,不随当前
|
|
* freeze_grace_ms 缩小而拒绝以前合法保存的记录。 */
|
|
uint64_t boundary = utc_ms + HISTORY_ZONE_MS;
|
|
boundary -= boundary % HISTORY_INTERVAL_MS;
|
|
if (boundary == 0U || utc_ms + HISTORY_ZONE_MS - boundary > 1000U ||
|
|
day < (HISTORY_MIN_UTC_MS + HISTORY_ZONE_MS) / HISTORY_DAY_MS ||
|
|
slot == 0U || slot > IEC60870_HISTORY_SLOTS_PER_DAY ||
|
|
day != (uint32_t)((boundary - 1U) / HISTORY_DAY_MS) ||
|
|
slot != (uint16_t)(((boundary - 1U) % HISTORY_DAY_MS) / HISTORY_INTERVAL_MS + 1U) ||
|
|
index != (day % IEC60870_HISTORY_DAYS) * IEC60870_HISTORY_SLOTS_PER_DAY + slot - 1U) { goto corrupt; }
|
|
for (i = 0U; i < self->config.analog_count; ++i) {
|
|
const uint8_t *p = self->wire + HISTORY_HEADER_SIZE + i * 5U;
|
|
if (!Finite(Read_Float(p)) || p[4] != 0U) { goto corrupt; }
|
|
}
|
|
} else {
|
|
if (slot != 0U || day != IEC60870_History_Local_Day(utc_ms) || index != day % IEC60870_HISTORY_DAYS) { goto corrupt; }
|
|
for (i = 0U; i < self->config.analog_count; ++i) {
|
|
const uint8_t *p = self->wire + HISTORY_HEADER_SIZE + i * 25U;
|
|
if (p[0] > 1U) { goto corrupt; }
|
|
if (p[0] != 0U && (!Finite(Read_Float(p + 1U)) || !Finite(Read_Float(p + 5U)) ||
|
|
Read_Float(p + 1U) < Read_Float(p + 5U) ||
|
|
Read_U64(p + 9U) > utc_ms || Read_U64(p + 17U) > utc_ms ||
|
|
IEC60870_History_Local_Day(Read_U64(p + 9U)) != day ||
|
|
IEC60870_History_Local_Day(Read_U64(p + 17U)) != day)) { goto corrupt; }
|
|
}
|
|
}
|
|
}
|
|
return IEC60870_HISTORY_OK;
|
|
corrupt:
|
|
self->faulted = true;
|
|
return IEC60870_HISTORY_ERROR;
|
|
}
|
|
|
|
/**
|
|
* 功能:全量扫描恢复,不依赖另一个易失或可能落后的索引文件。
|
|
* 输入参数:self——调用方持有的模块实例及当前状态;config——配置及调用期间借用的元数据;store——同步存储回调表及其上下文。
|
|
* 输出参数:self——本次操作后的运行状态及复用工作区。
|
|
* 返回值:OK表示操作完成;INVALID表示参数或操作状态非法;CONFIG表示持久记录与当前配置指纹不符;ERROR表示实例不可用、I/O失败或内容损坏。
|
|
* 说明:先暂存输入,兼容使用 self 内配置/回调重新初始化;恢复失败时不置 initialized。
|
|
*/
|
|
IEC60870_HistoryResult_t IEC60870_History_Init(IEC60870_History_t *self,
|
|
const IEC60870_HistoryConfig_t *config, const IEC60870_HistoryStore_t *store)
|
|
{
|
|
unsigned k;
|
|
uint32_t index;
|
|
uint64_t minimum[2] = {UINT64_MAX, UINT64_MAX};
|
|
IEC60870_HistoryConfig_t saved_config;
|
|
IEC60870_HistoryStore_t saved_store;
|
|
if (self == NULL || config == NULL || store == NULL || store->read == NULL || store->commit == NULL ||
|
|
sizeof(float) != 4U || FLT_RADIX != 2 || FLT_MANT_DIG != 24 || FLT_MAX_EXP != 128 ||
|
|
config->analog_count > IEC60870_HISTORY_MAX_ANALOG || config->freeze_grace_ms > 1000U ||
|
|
!Points_Valid(config->soe_ioas, config->soe_count) || !Points_Valid(config->co_ioas, config->co_count) ||
|
|
!Points_Valid(config->analog_ioas, config->analog_count)) { return IEC60870_HISTORY_INVALID; }
|
|
saved_config = *config;
|
|
saved_store = *store;
|
|
memset(self, 0, sizeof(*self));
|
|
self->config = saved_config;
|
|
self->store = saved_store;
|
|
self->fingerprint = Fingerprint(&self->config);
|
|
for (k = IEC60870_HISTORY_SOE; k <= IEC60870_HISTORY_EXV; ++k) {
|
|
IEC60870_HistoryKind_t kind = (IEC60870_HistoryKind_t)k;
|
|
for (index = 0U; index < IEC60870_History_Slot_Count(kind); ++index) {
|
|
IEC60870_HistoryResult_t result = Load(self, kind, index);
|
|
if (result == IEC60870_HISTORY_EMPTY) { continue; }
|
|
if (result != IEC60870_HISTORY_OK) { return result; }
|
|
if (kind <= IEC60870_HISTORY_CO) {
|
|
uint64_t sequence = Read_U64(self->wire + 12U);
|
|
unsigned n = k - 1U;
|
|
++self->event_count[n];
|
|
if (sequence > self->event_sequence[n]) { self->event_sequence[n] = sequence; }
|
|
if (sequence < minimum[n]) { minimum[n] = sequence; }
|
|
} else {
|
|
uint64_t utc_ms = Read_U64(self->wire + 20U);
|
|
uint32_t day = IEC60870_History_Local_Day(utc_ms);
|
|
if (!self->have_day || day > self->latest_day) { self->latest_day = day; }
|
|
if (utc_ms > self->observed_utc_ms) { self->observed_utc_ms = utc_ms; }
|
|
self->have_day = true;
|
|
}
|
|
}
|
|
}
|
|
/* 序号与槽位置已逐条核对;再用数量和最小序号确认保留区间连续。
|
|
* 已写过的中间槽丢失不能被当成“记录不足”静默缩小事件环。 */
|
|
for (k = 0U; k < 2U; ++k) {
|
|
uint32_t capacity = IEC60870_History_Slot_Count((IEC60870_HistoryKind_t)(k + 1U));
|
|
uint64_t expected = self->event_sequence[k] < capacity ? self->event_sequence[k] : capacity;
|
|
if (self->event_count[k] != expected ||
|
|
(expected != 0U && minimum[k] != self->event_sequence[k] - expected + 1U)) {
|
|
self->faulted = true;
|
|
return IEC60870_HISTORY_ERROR;
|
|
}
|
|
}
|
|
self->initialized = true;
|
|
return IEC60870_HISTORY_OK;
|
|
}
|
|
|
|
/**
|
|
* 功能:统一阻断未初始化和故障实例;恢复前连查询也不能暴露不确定索引。
|
|
* 输入参数:self——只读模块实例。
|
|
* 输出参数:无。
|
|
* 返回值:true表示实例非空、已初始化且未故障,false表示不能正常访问。
|
|
* 说明:只根据传入数据计算或判定,不改写输入对象。
|
|
*/
|
|
static bool Ready(const IEC60870_History_t *self)
|
|
{
|
|
return self != NULL && self->initialized && !self->faulted;
|
|
}
|
|
|
|
/**
|
|
* 功能:SOE/遥控共享追加路径。
|
|
* 输入参数:self——调用方持有的模块实例及当前状态;kind——记录或文件类别;ioa——信息对象地址;value——待处理数值;quality——事件品质字节;command——遥控操作阶段;
|
|
* utc_ms——UTC纪元毫秒;time_valid——事件原始时标是否有效。
|
|
* 输出参数:self——本次操作后的运行状态及复用工作区。
|
|
* 返回值:OK表示操作完成;INVALID表示参数或操作状态非法;ERROR表示实例不可用、I/O失败或内容损坏。
|
|
* 说明:序号从 1 起,物理槽=(序号-1)%容量;旧槽原子替换 成功以后才更新内存序号及条数。无自动去重,事件发生与调用次数由应用负责。
|
|
*/
|
|
static IEC60870_HistoryResult_t Append(IEC60870_History_t *self,
|
|
IEC60870_HistoryKind_t kind, uint32_t ioa, uint8_t value, uint8_t quality,
|
|
IEC60870_HistoryCommand_t command, uint64_t utc_ms, bool time_valid)
|
|
{
|
|
unsigned n = (unsigned)kind - 1U;
|
|
uint64_t sequence;
|
|
uint8_t *p;
|
|
uint32_t capacity = IEC60870_History_Slot_Count(kind);
|
|
IEC60870_HistoryResult_t result;
|
|
if (!Ready(self)) { return IEC60870_HISTORY_ERROR; }
|
|
if (utc_ms < HISTORY_MIN_UTC_MS || utc_ms > HISTORY_MAX_UTC_MS || value > 3U ||
|
|
(kind == IEC60870_HISTORY_SOE && !Contains(self->config.soe_ioas, self->config.soe_count, ioa)) ||
|
|
(kind == IEC60870_HISTORY_CO && ((unsigned)command > IEC60870_HISTORY_CANCEL ||
|
|
!Contains(self->config.co_ioas, self->config.co_count, ioa)))) { return IEC60870_HISTORY_INVALID; }
|
|
if (self->event_sequence[n] == UINT64_MAX) { return IEC60870_HISTORY_ERROR; }
|
|
sequence = self->event_sequence[n] + 1U;
|
|
Header(self, kind, sequence, utc_ms, 0U, 0U);
|
|
p = self->wire + HISTORY_HEADER_SIZE;
|
|
Write_U32(p, ioa);
|
|
p[4] = value;
|
|
p[5] = quality;
|
|
p[6] = (uint8_t)command;
|
|
p[7] = time_valid ? 1U : 0U;
|
|
result = Commit(self, kind, (uint32_t)((sequence - 1U) % capacity));
|
|
if (result != IEC60870_HISTORY_OK) { return result; }
|
|
self->event_sequence[n] = sequence;
|
|
if (self->event_count[n] < capacity) { ++self->event_count[n]; }
|
|
return IEC60870_HISTORY_OK;
|
|
}
|
|
|
|
/**
|
|
* 功能:SOE 只使用状态/品质/时标,内部命令字段固定为零以形成唯一规范编码。
|
|
* 输入参数:self——调用方持有的模块实例及当前状态;ioa——信息对象地址;value——待处理数值;quality——事件品质字节;utc_ms——UTC纪元毫秒;
|
|
* time_valid——事件原始时标是否有效。
|
|
* 输出参数:self——本次操作后的运行状态及复用工作区。
|
|
* 返回值:OK表示操作完成;INVALID表示参数或操作状态非法;ERROR表示实例不可用、I/O失败或内容损坏。
|
|
* 说明:每次成功追加占用一个新事件序号,调用方负责避免重复记账。
|
|
*/
|
|
IEC60870_HistoryResult_t IEC60870_History_Append_Soe(IEC60870_History_t *self,
|
|
uint32_t ioa, uint8_t value, uint8_t quality, uint64_t utc_ms, bool time_valid)
|
|
{
|
|
return Append(self, IEC60870_HISTORY_SOE, ioa, value, quality,
|
|
IEC60870_HISTORY_SELECT, utc_ms, time_valid);
|
|
}
|
|
|
|
/**
|
|
* 功能:遥控将操作阶段写入命令字段,未定义的品质字段固定为零。
|
|
* 输入参数:self——调用方持有的模块实例及当前状态;ioa——信息对象地址;command——遥控操作阶段;value——待处理数值;utc_ms——UTC纪元毫秒;
|
|
* time_valid——事件原始时标是否有效。
|
|
* 输出参数:self——本次操作后的运行状态及复用工作区。
|
|
* 返回值:OK表示操作完成;INVALID表示参数或操作状态非法;ERROR表示实例不可用、I/O失败或内容损坏。
|
|
* 说明:操作阶段和状态原样编码;追加成功本身不代表实际遥控动作已完成。
|
|
*/
|
|
IEC60870_HistoryResult_t IEC60870_History_Append_Control(IEC60870_History_t *self,
|
|
uint32_t ioa, IEC60870_HistoryCommand_t command, uint8_t value,
|
|
uint64_t utc_ms, bool time_valid)
|
|
{
|
|
return Append(self, IEC60870_HISTORY_CO, ioa, value, 0U, command, utc_ms, time_valid);
|
|
}
|
|
|
|
/**
|
|
* 功能:仅返回当前内存视图;读取故障后返回零不是“已把持久记录清空”。
|
|
* 输入参数:self——只读模块实例;kind——记录或文件类别。
|
|
* 输出参数:无。
|
|
* 返回值:指定SOE/CO环的保留条数;类别或实例不可用时返回0。
|
|
* 说明:只根据传入数据计算或判定,不改写输入对象。
|
|
*/
|
|
size_t IEC60870_History_Event_Count(const IEC60870_History_t *self,
|
|
IEC60870_HistoryKind_t kind)
|
|
{
|
|
return Ready(self) && kind >= IEC60870_HISTORY_SOE && kind <= IEC60870_HISTORY_CO ?
|
|
self->event_count[(unsigned)kind - 1U] : 0U;
|
|
}
|
|
|
|
/**
|
|
* 功能:从当前最大序号反推指定旧序下标的槽,再确认槽中的序号仍与索引一致。
|
|
* 输入参数:self——调用方持有的模块实例及当前状态;kind——记录或文件类别;oldest_index——按提交顺序从最旧记录起的零基索引。
|
|
* 输出参数:self——复用工作区及读取校验可能锁存的故障状态;out——成功时写入的独立结果副本。
|
|
* 返回值:OK表示操作完成;EMPTY表示没有所需记录或到期任务;INVALID表示参数或操作状态非法;CONFIG表示持久记录与当前配置指纹不符;ERROR表示实例不可用、I/O失败或内容损坏。
|
|
* 说明:成功复制出纯值结构,不把内部工作区指针交给调用方。
|
|
*/
|
|
IEC60870_HistoryResult_t IEC60870_History_Get_Event(IEC60870_History_t *self,
|
|
IEC60870_HistoryKind_t kind, size_t oldest_index, IEC60870_HistoryEvent_t *out)
|
|
{
|
|
uint64_t sequence;
|
|
unsigned n;
|
|
const uint8_t *p;
|
|
IEC60870_HistoryResult_t result;
|
|
if (!Ready(self)) { return IEC60870_HISTORY_ERROR; }
|
|
if (out == NULL || kind < IEC60870_HISTORY_SOE || kind > IEC60870_HISTORY_CO) { return IEC60870_HISTORY_INVALID; }
|
|
n = (unsigned)kind - 1U;
|
|
if (oldest_index >= self->event_count[n]) { return IEC60870_HISTORY_EMPTY; }
|
|
sequence = self->event_sequence[n] - self->event_count[n] + 1U + oldest_index;
|
|
result = Load(self, kind, (uint32_t)((sequence - 1U) % IEC60870_History_Slot_Count(kind)));
|
|
if (result != IEC60870_HISTORY_OK) { return result; }
|
|
if (Read_U64(self->wire + 12U) != sequence) { self->faulted = true; return IEC60870_HISTORY_ERROR; }
|
|
p = self->wire + HISTORY_HEADER_SIZE;
|
|
out->sequence = sequence;
|
|
out->utc_ms = Read_U64(self->wire + 20U);
|
|
out->ioa = Read_U32(p);
|
|
out->value = p[4];
|
|
out->quality = p[5];
|
|
out->command = (IEC60870_HistoryCommand_t)p[6];
|
|
out->time_valid = p[7] != 0U;
|
|
return IEC60870_HISTORY_OK;
|
|
}
|
|
|
|
/**
|
|
* 功能:32 个日槽包含当前日,故保留当前日及此前 31 日;这是存储查询窗口, 对外最新 30 个完整日的更窄窗口由 XML 文件层单独限制。
|
|
* 输入参数:self——只读模块实例;day——相对1970-01-01的本地日序。
|
|
* 输出参数:无。
|
|
* 返回值:true表示日期落在当前保留窗口内;不保证该日期已有记录。
|
|
* 说明:只根据传入数据计算或判定,不改写输入对象。
|
|
*/
|
|
static bool Retained(const IEC60870_History_t *self, uint32_t day)
|
|
{
|
|
return self->have_day && day <= self->latest_day && self->latest_day - day < IEC60870_HISTORY_DAYS;
|
|
}
|
|
|
|
/**
|
|
* 功能:日序模 32 定位一组 96 槽;仍须比对记录归属日,防止将轮转后的同槽认作旧日。
|
|
* 输入参数:self——调用方持有的模块实例及当前状态;day——相对1970-01-01的本地日序;slot——定点节号1..96;事件及极值公共头使用0。
|
|
* 输出参数:self——复用工作区及读取校验可能锁存的故障状态;out——成功时写入的独立结果副本。
|
|
* 返回值:OK表示操作完成;EMPTY表示没有所需记录或到期任务;INVALID表示参数或操作状态非法;CONFIG表示持久记录与当前配置指纹不符;ERROR表示实例不可用、I/O失败或内容损坏。
|
|
* 说明:缺测节保留 EMPTY,不按实际条数把后续节号前移,也不返回旧槽中的其他日期。
|
|
*/
|
|
IEC60870_HistoryResult_t IEC60870_History_Read_Fixed(IEC60870_History_t *self,
|
|
uint32_t day, uint16_t slot, IEC60870_HistoryFixed_t *out)
|
|
{
|
|
IEC60870_HistoryResult_t result;
|
|
size_t i;
|
|
if (!Ready(self)) { return IEC60870_HISTORY_ERROR; }
|
|
if (out == NULL || slot == 0U || slot > IEC60870_HISTORY_SLOTS_PER_DAY) { return IEC60870_HISTORY_INVALID; }
|
|
if (!Retained(self, day)) { return IEC60870_HISTORY_EMPTY; }
|
|
result = Load(self, IEC60870_HISTORY_FIXPT, (day % IEC60870_HISTORY_DAYS) * IEC60870_HISTORY_SLOTS_PER_DAY + slot - 1U);
|
|
if (result != IEC60870_HISTORY_OK) { return result; }
|
|
if (Read_U32(self->wire + 28U) != day) { return IEC60870_HISTORY_EMPTY; }
|
|
memset(out, 0, sizeof(*out));
|
|
out->day = day;
|
|
out->slot = slot;
|
|
out->utc_ms = Read_U64(self->wire + 20U);
|
|
out->count = self->config.analog_count;
|
|
for (i = 0U; i < out->count; ++i) {
|
|
const uint8_t *p = self->wire + HISTORY_HEADER_SIZE + i * 5U;
|
|
out->values[i] = Read_Float(p);
|
|
out->quality[i] = p[4];
|
|
}
|
|
return IEC60870_HISTORY_OK;
|
|
}
|
|
|
|
/**
|
|
* 功能:只解码已由 Load 校验的工作区。
|
|
* 输入参数:self——只读模块实例。
|
|
* 输出参数:out——解码后的独立记录副本。
|
|
* 返回值:无。
|
|
* 说明:每点顺序为 valid、max、min、最大值时间、 最小值时间,长度 1+4+4+8+8;完整清零输出,未配置的数组尾部不残留旧值。
|
|
*/
|
|
static void Decode_Extrema(const IEC60870_History_t *self, IEC60870_HistoryExtrema_t *out)
|
|
{
|
|
size_t i;
|
|
memset(out, 0, sizeof(*out));
|
|
out->day = Read_U32(self->wire + 28U);
|
|
out->utc_ms = Read_U64(self->wire + 20U);
|
|
out->count = self->config.analog_count;
|
|
for (i = 0U; i < out->count; ++i) {
|
|
const uint8_t *p = self->wire + HISTORY_HEADER_SIZE + i * 25U;
|
|
out->points[i].valid = p[0] != 0U;
|
|
out->points[i].max = Read_Float(p + 1U);
|
|
out->points[i].min = Read_Float(p + 5U);
|
|
out->points[i].max_utc_ms = Read_U64(p + 9U);
|
|
out->points[i].min_utc_ms = Read_U64(p + 17U);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 功能:允许查询当前日累计值;是否为已完成日不是存储层的有效性条件。
|
|
* 输入参数:self——调用方持有的模块实例及当前状态;day——相对1970-01-01的本地日序。
|
|
* 输出参数:self——复用工作区及读取校验可能锁存的故障状态;out——成功时写入的独立结果副本。
|
|
* 返回值:OK表示操作完成;EMPTY表示没有所需记录或到期任务;INVALID表示参数或操作状态非法;CONFIG表示持久记录与当前配置指纹不符;ERROR表示实例不可用、I/O失败或内容损坏。
|
|
* 说明:查询会复用核心wire工作区,成功结果为调用方拥有的独立副本。
|
|
*/
|
|
IEC60870_HistoryResult_t IEC60870_History_Read_Extrema(IEC60870_History_t *self,
|
|
uint32_t day, IEC60870_HistoryExtrema_t *out)
|
|
{
|
|
IEC60870_HistoryResult_t result;
|
|
if (!Ready(self)) { return IEC60870_HISTORY_ERROR; }
|
|
if (out == NULL) { return IEC60870_HISTORY_INVALID; }
|
|
if (!Retained(self, day)) { return IEC60870_HISTORY_EMPTY; }
|
|
result = Load(self, IEC60870_HISTORY_EXV, day % IEC60870_HISTORY_DAYS);
|
|
if (result != IEC60870_HISTORY_OK) { return result; }
|
|
if (Read_U32(self->wire + 28U) != day) { return IEC60870_HISTORY_EMPTY; }
|
|
Decode_Extrema(self, out);
|
|
return IEC60870_HISTORY_OK;
|
|
}
|
|
|
|
/**
|
|
* 功能:输出最近测量日;事件环的时间不会改变日记录的保留窗口。
|
|
* 输入参数:self——只读模块实例。
|
|
* 输出参数:day——成功时写入的本地日序。
|
|
* 返回值:true表示已有最近测量日并填写day;false表示实例不可用或尚无测量日。
|
|
* 说明:只读取内存中已恢复的测量日信息,不扫描事件环或介质。
|
|
*/
|
|
bool IEC60870_History_Latest_Day(const IEC60870_History_t *self, uint32_t *day)
|
|
{
|
|
if (!Ready(self) || !self->have_day || day == NULL) { return false; }
|
|
*day = self->latest_day;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* 功能:从持久槽重建当日累计状态,然后只用有效样本更新。
|
|
* 输入参数:self——调用方持有的模块实例及当前状态;utc_ms——UTC纪元毫秒;values——按配置点序排列的值;quality——与值数组同序的品质。
|
|
* 输出参数:self——本次操作后的运行状态及复用工作区。
|
|
* 返回值:OK表示操作完成;CONFIG表示持久记录与当前配置指纹不符;ERROR表示实例不可用、I/O失败或内容损坏。
|
|
* 说明:首次有效值同时初始化 最大/最小值;只有严格变大/变小时更新对应时标,平值保留首次发生时间。 新的一天即使全部样本无效也提交一个空累计状态以记录日推进;同一天没有 极值变化时不重复写盘。
|
|
* 候选工作区不作为下一次调用的可信持久副本。
|
|
*/
|
|
static IEC60870_HistoryResult_t Update_Extrema(IEC60870_History_t *self,
|
|
uint64_t utc_ms, const float *values, const uint8_t *quality)
|
|
{
|
|
uint32_t day = IEC60870_History_Local_Day(utc_ms);
|
|
size_t i;
|
|
bool changed = false;
|
|
IEC60870_HistoryResult_t result = Load(self, IEC60870_HISTORY_EXV, day % IEC60870_HISTORY_DAYS);
|
|
IEC60870_HistoryExtrema_t *out = &self->work_extrema;
|
|
if (result != IEC60870_HISTORY_OK && result != IEC60870_HISTORY_EMPTY) { return result; }
|
|
if (result == IEC60870_HISTORY_OK && Read_U32(self->wire + 28U) == day) {
|
|
Decode_Extrema(self, out);
|
|
} else {
|
|
memset(out, 0, sizeof(*out));
|
|
out->day = day;
|
|
out->count = self->config.analog_count;
|
|
changed = true;
|
|
}
|
|
for (i = 0U; i < out->count; ++i) {
|
|
IEC60870_HistoryExtremePoint_t *point = &out->points[i];
|
|
if (quality[i] != 0U || !Finite(values[i])) { continue; }
|
|
if (!point->valid || values[i] > point->max) {
|
|
point->max = values[i]; point->max_utc_ms = utc_ms; changed = true;
|
|
}
|
|
if (!point->valid || values[i] < point->min) {
|
|
point->min = values[i]; point->min_utc_ms = utc_ms; changed = true;
|
|
}
|
|
point->valid = true;
|
|
}
|
|
if (!changed) { return IEC60870_HISTORY_OK; }
|
|
out->utc_ms = utc_ms;
|
|
Header(self, IEC60870_HISTORY_EXV, 0U, utc_ms, day, 0U);
|
|
for (i = 0U; i < out->count; ++i) {
|
|
uint8_t *p = self->wire + HISTORY_HEADER_SIZE + i * 25U;
|
|
const IEC60870_HistoryExtremePoint_t *point = &out->points[i];
|
|
p[0] = point->valid ? 1U : 0U;
|
|
Write_Float(p + 1U, point->max);
|
|
Write_Float(p + 5U, point->min);
|
|
Write_U64(p + 9U, point->max_utc_ms);
|
|
Write_U64(p + 17U, point->min_utc_ms);
|
|
}
|
|
return Commit(self, IEC60870_HISTORY_EXV, day % IEC60870_HISTORY_DAYS);
|
|
}
|
|
|
|
/**
|
|
* 功能:只在刻钟边界后的宽限窗口内冻结,且必须所有遥测点都有效。
|
|
* 输入参数:self——调用方持有的模块实例及当前状态;utc_ms——UTC纪元毫秒;values——按配置点序排列的值;quality——与值数组同序的品质。
|
|
* 输出参数:self——本次操作后的运行状态及复用工作区。
|
|
* 返回值:OK表示操作完成;CONFIG表示持久记录与当前配置指纹不符;ERROR表示实例不可用、I/O失败或内容损坏。
|
|
* 说明:用 boundary-1 求归属日和节号,使次日零点对应前一天第 96 节;同日同节 已有记录就不覆盖。持久时标仍是实际观测时间,不能伪装为准点采样。
|
|
*/
|
|
static IEC60870_HistoryResult_t Freeze(IEC60870_History_t *self,
|
|
uint64_t utc_ms, const float *values, const uint8_t *quality)
|
|
{
|
|
uint64_t local_ms = utc_ms + HISTORY_ZONE_MS;
|
|
uint64_t boundary = local_ms - local_ms % HISTORY_INTERVAL_MS;
|
|
uint32_t day, index;
|
|
uint16_t slot;
|
|
size_t i;
|
|
IEC60870_HistoryResult_t result;
|
|
if (local_ms % HISTORY_INTERVAL_MS > self->config.freeze_grace_ms || boundary == 0U) { return IEC60870_HISTORY_OK; }
|
|
for (i = 0U; i < self->config.analog_count; ++i) {
|
|
if (quality[i] != 0U || !Finite(values[i])) { return IEC60870_HISTORY_OK; }
|
|
}
|
|
day = (uint32_t)((boundary - 1U) / HISTORY_DAY_MS);
|
|
/* 支持范围起点的零点对应 1999 年末最后一节,超出两位年份可唯一解释
|
|
* 的日历范围;仅跳过该定点,不妨碍建立 2000 年首日的极值累计。 */
|
|
if (day < (HISTORY_MIN_UTC_MS + HISTORY_ZONE_MS) / HISTORY_DAY_MS) { return IEC60870_HISTORY_OK; }
|
|
slot = (uint16_t)(((boundary - 1U) % HISTORY_DAY_MS) / HISTORY_INTERVAL_MS + 1U);
|
|
index = (day % IEC60870_HISTORY_DAYS) * IEC60870_HISTORY_SLOTS_PER_DAY + slot - 1U;
|
|
result = Load(self, IEC60870_HISTORY_FIXPT, index);
|
|
if (result != IEC60870_HISTORY_OK && result != IEC60870_HISTORY_EMPTY) { return result; }
|
|
if (result == IEC60870_HISTORY_OK && Read_U32(self->wire + 28U) == day) { return IEC60870_HISTORY_OK; }
|
|
Header(self, IEC60870_HISTORY_FIXPT, 0U, utc_ms, day, slot);
|
|
for (i = 0U; i < self->config.analog_count; ++i) {
|
|
uint8_t *p = self->wire + HISTORY_HEADER_SIZE + i * 5U;
|
|
Write_Float(p, values[i]); p[4] = quality[i];
|
|
}
|
|
return Commit(self, IEC60870_HISTORY_FIXPT, index);
|
|
}
|
|
|
|
/**
|
|
* 功能:外部一次观测先尝试定点,再更新极值,全部成功后才推进运行时的时间下界。
|
|
* 输入参数:self——调用方持有的模块实例及当前状态;utc_ms——UTC纪元毫秒;values——按配置点序排列的值;quality——与值数组同序的品质;count——数组项数。
|
|
* 输出参数:self——本次操作后的运行状态及复用工作区。
|
|
* 返回值:OK表示操作完成;EMPTY表示没有所需记录或到期任务;INVALID表示参数或操作状态非法;CONFIG表示持久记录与当前配置指纹不符;ERROR表示实例不可用、I/O失败或内容损坏;
|
|
* TIME_REVERSED表示观测时间低于高水位。
|
|
* 说明:两次写入不是一个事务:后一步失败不撤销前一步,重启扫描会恢复已提交部分。 校时回拨只拒绝新观测,不修改既有定点、极值或事件序号。
|
|
*/
|
|
IEC60870_HistoryResult_t IEC60870_History_Observe(IEC60870_History_t *self,
|
|
uint64_t utc_ms, const float *values, const uint8_t *quality, size_t count)
|
|
{
|
|
IEC60870_HistoryResult_t result;
|
|
if (!Ready(self)) { return IEC60870_HISTORY_ERROR; }
|
|
if (utc_ms < HISTORY_MIN_UTC_MS || utc_ms > HISTORY_MAX_UTC_MS || count != self->config.analog_count ||
|
|
(count != 0U && (values == NULL || quality == NULL))) { return IEC60870_HISTORY_INVALID; }
|
|
if (count == 0U) { return IEC60870_HISTORY_EMPTY; }
|
|
if (self->have_day && utc_ms < self->observed_utc_ms) { return IEC60870_HISTORY_TIME_REVERSED; }
|
|
result = Freeze(self, utc_ms, values, quality);
|
|
if (result != IEC60870_HISTORY_OK) { return result; }
|
|
result = Update_Extrema(self, utc_ms, values, quality);
|
|
if (result != IEC60870_HISTORY_OK) { return result; }
|
|
self->observed_utc_ms = utc_ms;
|
|
self->latest_day = IEC60870_History_Local_Day(utc_ms);
|
|
self->have_day = true;
|
|
return IEC60870_HISTORY_OK;
|
|
}
|