765 lines
33 KiB
C
765 lines
33 KiB
C
/**
|
||
* @file BS_ocpp_mv_offline_bridge.c
|
||
* @brief OCPP 离线 MeterValues 桥接实现：落盘（未连接/未登录）+ 未结订单联网后顺序补发
|
||
*
|
||
* @details **产品需求（明确）**\n
|
||
* 1. **离线周期存储**：TCP 未连接或已连接但未登录 CSMS 时，充电过程中按配置周期将当前测量快照写入 SPI Flash 池，\n
|
||
* 并在 FRAM 建立「本笔充电」与序号区间的映射。\n
|
||
* 2. **离线订单上送**：未结订单在联网并完成 **Authorize → StartTransaction** 取得平台 **transactionId（流水号）** 后，\n
|
||
* 在发送 `StopTransaction` 之前，须检查 Flash 中是否存有 **本次充电** 的离线 MeterValues。\n
|
||
* 3. **如何认定「本次充电」的 MV**：落盘与补发使用 **同一规则** —— 以订单日志中的 **开始充电时间** `StartChargeTime`（`Comm_Time`）\n
|
||
* 经 `xDate2Seconds` 得到 **32 位**开始充电秒 `u32_charge_start_sec`，并与 **枪号** 一起在 FRAM 映射中查找（落盘 API 第二参为兼容保留，恒传 0）。\n
|
||
* 未结内存中的 `S_LOG_DATA` 与离线采样时 `v_meterlog_put_char_log_data` 取到的订单为同一会话时，**开始时间一致**则键一致，\n
|
||
* `u8_ocpp_mv_offline_map_get` 命中的区间即为本笔充电的 MV，按序号逐条补发后再 `StopTransaction`。\n
|
||
*
|
||
* @details **实现划分**\n
|
||
* 1. **键空间**：见上；离线时设备流水号常为空，故不以设备单号做键。\n
|
||
* 2. **负载内容**：`S_OCPP_MV_OFFLINE_MV` 与 `BS_ocpp_ctrl.c` 中 `u8_get_ocpp_measurand_data` 口径对齐，补发由 `s32_ocpp_send_meter_values_replay` 组 JSON。\n
|
||
* 3. **模块上下文**：文件内单一静态结构体 `s_ocpp_mv_bridge_ctx` 统一管理「每枪落盘节流时间戳、未结补发状态机」。\n
|
||
* `v_ocpp_mv_offline_init` 在 **`v_ocpp_init_data`**（`BS_ocpp_ctrl.c`）中调用以装载 FRAM 管理块；`v_ocpp_mv_offline_bridge_private_logic` 不触发 Flash 层 init。\n
|
||
* 释放未结订单内存前须 `v_ocpp_mv_offline_unsettled_abort()`，避免状态机与已释放 `S_LOG_DATA` 不一致。\n
|
||
* 4. **两类时间源**：`get_current_seconds()` 为 **上电起单调秒**（`public_func.c`），只宜做间隔/节流；**OCPP 报文与 Flash 内 `u32_timestamp_unix`** 须用 **`GetCurrentTime` + `xDate2Seconds`**，与在线 `MeterValues_mag` 及 `StartChargeTime` 映射键同一套日历 epoch。
|
||
*/
|
||
|
||
#include "BS_ocpp_mv_offline_bridge.h"
|
||
|
||
#if BS_OCPP_EN
|
||
|
||
#include <string.h>
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
|
||
#include "BS_ocpp_ctrl.h"
|
||
#include "publicdata/public_define.h"
|
||
#include "publicdata/publicdata.h"
|
||
#include "plat_comm/impl/bs_public_impl.h"
|
||
#include "flash_file_mgr/ocpp_mv_offline_flash_impl.h"
|
||
#include "plat_comm/plat_comm_task.h"
|
||
#include "BS_ocpp_configuration.h"
|
||
#include "app_rtc/app_rtc.h"
|
||
#include "bs_ocpp_json_data.h"
|
||
|
||
#define OCPP_OFFLINE_LOG(fmt, ...) \
|
||
MYLOG_MSG(OCPP_PRINT_FLAG,fmt, ##__VA_ARGS__) //任务打印
|
||
|
||
extern int32_t s32_ocpp_send_meter_values_replay(int gunNo, int transactionId,
|
||
const S_OCPP_MV_OFFLINE_MV *mv);
|
||
|
||
/* 与 BS_ocpp_ctrl.c 中 `v_ocpp_timestamp_to_str` 口径一致（离线 MV 时间戳由 unix 秒经本文件内 helper 转换） */
|
||
static void v_mv_offline_timestamp_to_str(Comm_Time *ctTime, char *time_str)
|
||
{
|
||
Comm_Time time;
|
||
|
||
if (ctTime == NULL) {
|
||
GetCurrentTime(&time);
|
||
ctTime = &time;
|
||
}
|
||
#if (OCPP_TIMESTAMP_UTC_OUTPUT)
|
||
else {
|
||
memcpy(&time, ctTime, sizeof(Comm_Time));
|
||
ctTime = &time;
|
||
}
|
||
v_adjust_time_with_timezone((Comm_Time *)ctTime, -8, 0);
|
||
(void)snprintf(time_str, (size_t)OCPP_DATE_LEN, "%04u-%02u-%02uT%02u:%02u:%02uZ",
|
||
(unsigned)ctTime->iYear, (unsigned)ctTime->ucMonth, (unsigned)ctTime->ucDay,
|
||
(unsigned)ctTime->ucHour, (unsigned)ctTime->ucMin, (unsigned)ctTime->ucSec);
|
||
#else
|
||
(void)snprintf(time_str, (size_t)OCPP_DATE_LEN, "%04u-%02u-%02uT%02u:%02u:%02u+08:00",
|
||
(unsigned)ctTime->iYear, (unsigned)ctTime->ucMonth, (unsigned)ctTime->ucDay,
|
||
(unsigned)ctTime->ucHour, (unsigned)ctTime->ucMin, (unsigned)ctTime->ucSec);
|
||
#endif
|
||
}
|
||
|
||
static void v_mv_offline_timestamp_unix_to_str(U32_T unix_sec, char *time_str)
|
||
{
|
||
Comm_Time ct;
|
||
|
||
xSeconds2Date((unsigned long)unix_sec, &ct);
|
||
v_mv_offline_timestamp_to_str(&ct, time_str);
|
||
}
|
||
|
||
/** 将离线 32B 快照填到单个 SampledValue（与 `u8_get_ocpp_measurand_data` 口径一致） */
|
||
static U8_T u8_offline_mv_to_sampled(SampledValue *sv, OCPP_MEASURAND_ID e_type, const S_OCPP_MV_OFFLINE_MV *mv)
|
||
{
|
||
char data_str[24] = {0};
|
||
|
||
if (sv == NULL || mv == NULL) {
|
||
return 0u;
|
||
}
|
||
switch (e_type) {
|
||
case ENUM_EnergyActiveImportRegister:
|
||
(void)snprintf(data_str, sizeof(data_str), "%lu", (unsigned long)mv->u32_meter_import_wh);
|
||
memcpy(sv->value, data_str, strlen(data_str));
|
||
memcpy(sv->context, OCPP_STR_SamplePeriodic, strlen(OCPP_STR_SamplePeriodic));
|
||
memcpy(sv->format, OCPP_STR_Raw, strlen(OCPP_STR_Raw));
|
||
memcpy(sv->measurand, OCPP_STR_EnergyActiveImportRegister, strlen(OCPP_STR_EnergyActiveImportRegister));
|
||
memcpy(sv->location, OCPP_STR_Outlet, strlen(OCPP_STR_Outlet));
|
||
memcpy(sv->unit, OCPP_STR_Wh, strlen(OCPP_STR_Wh));
|
||
return 1u;
|
||
case ENUM_EnergyActiveImportInterval:
|
||
(void)snprintf(data_str, sizeof(data_str), "%lu", (unsigned long)mv->u32_energy_interval_wh);
|
||
memcpy(sv->value, data_str, strlen(data_str));
|
||
memcpy(sv->context, OCPP_STR_SamplePeriodic, strlen(OCPP_STR_SamplePeriodic));
|
||
memcpy(sv->format, OCPP_STR_Raw, strlen(OCPP_STR_Raw));
|
||
memcpy(sv->measurand, OCPP_STR_EnergyActiveImportInterval, strlen(OCPP_STR_EnergyActiveImportInterval));
|
||
memcpy(sv->location, OCPP_STR_Outlet, strlen(OCPP_STR_Outlet));
|
||
memcpy(sv->unit, OCPP_STR_Wh, strlen(OCPP_STR_Wh));
|
||
return 1u;
|
||
case ENUM_PowerActiveImport:
|
||
(void)snprintf(data_str, sizeof(data_str), "%.3f", (F32_T)mv->u16_power_active_w);
|
||
memcpy(sv->value, data_str, strlen(data_str));
|
||
memcpy(sv->context, OCPP_STR_SamplePeriodic, strlen(OCPP_STR_SamplePeriodic));
|
||
memcpy(sv->format, OCPP_STR_Raw, strlen(OCPP_STR_Raw));
|
||
memcpy(sv->measurand, OCPP_STR_PowerActiveImport, strlen(OCPP_STR_PowerActiveImport));
|
||
memcpy(sv->location, OCPP_STR_Outlet, strlen(OCPP_STR_Outlet));
|
||
memcpy(sv->unit, OCPP_STR_W, strlen(OCPP_STR_W));
|
||
return 1u;
|
||
case ENUM_PowerOffered:
|
||
(void)snprintf(data_str, sizeof(data_str), "%.3f", (F32_T)mv->u16_power_offered_01kw * 100.0f);
|
||
memcpy(sv->value, data_str, strlen(data_str));
|
||
memcpy(sv->context, OCPP_STR_SamplePeriodic, strlen(OCPP_STR_SamplePeriodic));
|
||
memcpy(sv->format, OCPP_STR_Raw, strlen(OCPP_STR_Raw));
|
||
memcpy(sv->measurand, OCPP_STR_PowerOffered, strlen(OCPP_STR_PowerOffered));
|
||
memcpy(sv->location, OCPP_STR_Outlet, strlen(OCPP_STR_Outlet));
|
||
memcpy(sv->unit, OCPP_STR_W, strlen(OCPP_STR_W));
|
||
return 1u;
|
||
case ENUM_CurrentImport:
|
||
(void)snprintf(data_str, sizeof(data_str), "%.3f", (F32_T)mv->u16_current_import_a_x100 / 100.0f);
|
||
memcpy(sv->value, data_str, strlen(data_str));
|
||
memcpy(sv->context, OCPP_STR_SamplePeriodic, strlen(OCPP_STR_SamplePeriodic));
|
||
memcpy(sv->format, OCPP_STR_Raw, strlen(OCPP_STR_Raw));
|
||
memcpy(sv->measurand, OCPP_STR_CurrentImport, strlen(OCPP_STR_CurrentImport));
|
||
memcpy(sv->location, OCPP_STR_Outlet, strlen(OCPP_STR_Outlet));
|
||
memcpy(sv->unit, OCPP_STR_A, strlen(OCPP_STR_A));
|
||
return 1u;
|
||
case ENUM_CurrentOffered:
|
||
(void)snprintf(data_str, sizeof(data_str), "%.3f", (F32_T)mv->u16_current_offered_a_x100 / 100.0f);
|
||
memcpy(sv->value, data_str, strlen(data_str));
|
||
memcpy(sv->context, OCPP_STR_SamplePeriodic, strlen(OCPP_STR_SamplePeriodic));
|
||
memcpy(sv->format, OCPP_STR_Raw, strlen(OCPP_STR_Raw));
|
||
memcpy(sv->measurand, OCPP_STR_CurrentOffered, strlen(OCPP_STR_CurrentOffered));
|
||
memcpy(sv->location, OCPP_STR_Outlet, strlen(OCPP_STR_Outlet));
|
||
memcpy(sv->unit, OCPP_STR_A, strlen(OCPP_STR_A));
|
||
return 1u;
|
||
case ENUM_Voltage:
|
||
(void)snprintf(data_str, sizeof(data_str), "%.3f", (F32_T)mv->u16_voltage_v_x10 / 10.0f);
|
||
memcpy(sv->value, data_str, strlen(data_str));
|
||
memcpy(sv->context, OCPP_STR_SamplePeriodic, strlen(OCPP_STR_SamplePeriodic));
|
||
memcpy(sv->format, OCPP_STR_Raw, strlen(OCPP_STR_Raw));
|
||
memcpy(sv->measurand, OCPP_STR_Voltage, strlen(OCPP_STR_Voltage));
|
||
memcpy(sv->location, OCPP_STR_Outlet, strlen(OCPP_STR_Outlet));
|
||
memcpy(sv->unit, OCPP_STR_V, strlen(OCPP_STR_V));
|
||
return 1u;
|
||
case ENUM_SoC:
|
||
(void)snprintf(data_str, sizeof(data_str), "%u", (unsigned)mv->u8_soc);
|
||
memcpy(sv->value, data_str, strlen(data_str));
|
||
memcpy(sv->format, OCPP_STR_Raw, strlen(OCPP_STR_Raw));
|
||
memcpy(sv->measurand, OCPP_STR_SOC, strlen(OCPP_STR_SOC));
|
||
memcpy(sv->location, OCPP_STR_EV, strlen(OCPP_STR_EV));
|
||
memcpy(sv->unit, OCPP_STR_Percent, strlen(OCPP_STR_Percent));
|
||
if (mv->u8_soc_data_type == 1u) {
|
||
memcpy(sv->context, OCPP_STR_TransactionBegin, strlen(OCPP_STR_TransactionBegin));
|
||
} else if (mv->u8_soc_data_type == 2u) {
|
||
memcpy(sv->context, OCPP_STR_TransactionEnd, strlen(OCPP_STR_TransactionEnd));
|
||
} else {
|
||
memcpy(sv->context, OCPP_STR_SamplePeriodic, strlen(OCPP_STR_SamplePeriodic));
|
||
}
|
||
return 1u;
|
||
default:
|
||
return 0u;
|
||
}
|
||
}
|
||
|
||
cJSON *MeterValues_mag_offline_replay(int gunNo, int transactionId, const S_OCPP_MV_OFFLINE_MV *mv)
|
||
{
|
||
MeterValuesRequest json_data;
|
||
char time_str[30] = {0};
|
||
U8_T i;
|
||
U8_T u8_data_num = 0;
|
||
|
||
if (mv == NULL) {
|
||
return NULL;
|
||
}
|
||
(void)memset(&json_data, 0, sizeof(json_data));
|
||
json_data.connectorId = gunNo + 1;
|
||
json_data.transactionId = transactionId;
|
||
v_mv_offline_timestamp_unix_to_str(mv->u32_timestamp_unix, time_str);
|
||
(void)memcpy(json_data.meterValue[0].timestamp, time_str, strlen(time_str));
|
||
|
||
for (i = 0; i < (U8_T)ENUM_measurand_Num; i++) {
|
||
if ((s_ocpp_flash_cfg_data.s_ocpp_config_data.u8_MeterValuesMeasurandNeed[i] & E_CFG_MVMN_MeterValuesSampledData)
|
||
== E_CFG_MVMN_MeterValuesSampledData) {
|
||
if (u8_offline_mv_to_sampled(&json_data.meterValue[0].sampledValue[u8_data_num], (OCPP_MEASURAND_ID)i, mv) != 0u) {
|
||
if (++u8_data_num >= MeterValuesRequest_SV_NUM) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (u8_data_num == 0u) {
|
||
return NULL;
|
||
}
|
||
return j_get_ocpp_json(OCPP_MeterValues, &json_data);
|
||
}
|
||
|
||
/**
|
||
* @brief 离线 MV 桥接模块级 RAM 上下文（本文件内静态单例）
|
||
* @details 集中存放：\n
|
||
* - `last_mv_save_sec[]`：每枪上次**成功**落盘的单调秒，用于 `MeterValueSampleInterval` 节流；\n
|
||
* - `unsettled`：未结订单补发 MV 时的状态机（与 `s_unsettled_order_data` 生命周期独立，释放订单前须 abort）。
|
||
*/
|
||
/** 离线 MV 顺序补发状态（未结补单 / 在线会话内补发共用） */
|
||
typedef struct {
|
||
U8_T active; /**< 非 0：正处于某笔单的补发区间 `[seq_next, seq_end]` 内 */
|
||
U8_T gun; /**< 当前补发枪号 */
|
||
U32_T u32_charge_start_sec; /**< `xDate2Seconds(StartChargeTime)`，与 FRAM `u32_tx_sn_lo` 一致 */
|
||
int i32_txid; /**< 本笔 OCPP transactionId（会话补发在读订单失败时沿用） */
|
||
U32_T seq_start;
|
||
U32_T seq_next;
|
||
U32_T seq_end;
|
||
} S_OCPP_MV_REPLAY_CTX;
|
||
|
||
typedef struct {
|
||
U32_T last_mv_save_sec[GUN_MAX_CNT]; /**< 每枪上次成功落盘时的 `get_current_seconds()`（单调秒），仅用于采样周期节流 */
|
||
S_OCPP_MV_REPLAY_CTX unsettled; /**< 未结订单 StopTx 前补发 */
|
||
S_OCPP_MV_REPLAY_CTX session; /**< 在线起充、中途离线再上线：用已有 transactionId 补发 */
|
||
} S_OCPP_MV_OFFLINE_BRIDGE_CTX;
|
||
|
||
/** 模块唯一静态上下文；静态存储期整体零初始化 */
|
||
static S_OCPP_MV_OFFLINE_BRIDGE_CTX s_ocpp_mv_bridge_ctx;
|
||
/** 每枪当前是否已为本笔充电完成起充准备（flow 离开充电后清零） */
|
||
static U8_T s_u8_mv_charge_session_armed[GUN_MAX_CNT];
|
||
/** 上一周期 BMS flow，用于停充边沿补写一条 MV */
|
||
static U8_T s_u8_mv_prev_bs_flow[GUN_MAX_CNT];
|
||
/** map full 日志节流（单调秒） */
|
||
static U32_T s_u32_mv_map_full_log_sec[GUN_MAX_CNT];
|
||
/**
|
||
* @fn v_ocpp_mv_charge_start_sec_from_time
|
||
* @brief 用订单「开始充电时间」得到与 FRAM 映射一致的 **单路** 32 位键（`xDate2Seconds`）
|
||
* @param[in] ct 指向 `S_LOG_DATA.StartChargeTime` 的日历时间（与未结订单 `log` 中字段同源）
|
||
* @param[out] out_sec 成功时为 `xDate2Seconds(ct)`；无效日历或未写入时为 0
|
||
* @details 双枪在同一秒启动时 `*out_sec` 可能相同，依赖 `S_OCPP_MV_OFFLINE_MAP_ROW.u8_gun_no` 区分；\n
|
||
* 调用 `u8_ocpp_mv_offline_mv_save` / `map_get` 时第二参固定传 0（与 FRAM 行 `u32_tx_sn_hi` 约定一致，非 64 位拆分）。\n
|
||
* 对 `ct` 做简单范围检查（年月日非全零、月 1–12、日 1–31），避免未刷新的日志参与映射。
|
||
*/
|
||
static void v_ocpp_mv_charge_start_sec_from_time(const Comm_Time *ct, U32_T *out_sec)
|
||
{
|
||
unsigned int sec;
|
||
|
||
if (out_sec != NULL) {
|
||
*out_sec = 0u;
|
||
}
|
||
if (ct == NULL || out_sec == NULL) {
|
||
return;
|
||
}
|
||
if (ct->iYear == 0u && ct->ucMonth == 0u && ct->ucDay == 0u) {
|
||
return;
|
||
}
|
||
if (ct->ucMonth == 0u || ct->ucMonth > 12u) {
|
||
return;
|
||
}
|
||
if (ct->ucDay == 0u || ct->ucDay > 31u) {
|
||
return;
|
||
}
|
||
sec = xDate2Seconds((Comm_Time *)ct);
|
||
*out_sec = (U32_T)sec;
|
||
}
|
||
|
||
/**
|
||
* @fn u8_ocpp_mv_fill_snapshot
|
||
* @brief 从实时系统数据填充一条待写入 Flash 的 `S_OCPP_MV_OFFLINE_MV` 快照
|
||
* @param[in] gun 枪索引 `0..GUN_MAX_CNT-1`，与 `u8_ocpp_mv_offline_mv_save` 的 `u8_gun_no` 一致
|
||
* @param[out] out 输出快照；成功时魔数、版本、时间戳及测量字段均写入
|
||
* @return 1 成功；0 参数非法或枪号越界
|
||
* @details 各字段数据源与 `u8_get_ocpp_measurand_data` 对齐说明：\n
|
||
* - `u32_timestamp_unix`：`GetCurrentTime` + `xDate2Seconds`，与在线 `MeterValues_mag` 的日历时间同源，供补发时 `v_mv_offline_timestamp_unix_to_str` 组 ISO8601（**勿用** `get_current_seconds()`，其为上电起算单调秒）。\n
|
||
* - `u32_meter_import_wh`：电表累计 Wh（`E_BS_GET_SYS_DATA_MEMTER_ELECT`/10 截断 U32）\n
|
||
* - `u32_energy_interval_wh`：本事务段增量 Wh（当前累计 − `E_BS_GET_SYS_DATA_LOG_ENERGY` type=1）\n
|
||
* - `u16_voltage_v_x10` / 电流：`METER_VOL`、`METER_CUR`（电流存 0.01A：原 0.1A×10）\n
|
||
* - `u16_power_active_w`：由本快照已写入的 `u16_voltage_v_x10`（0.1V）与 `u16_current_import_a_x100`（0.01A）整数估算：`W = vol×cur / 1000`，饱和 65535\n
|
||
* - `u16_power_offered_01kw` / `u16_current_offered_a_x100`：桩额定功率 0.1kW 单位、桩最大输出电流\n
|
||
* - SOC：`E_BS_GET_SYS_DATA_SOC_DATA` 当前值，`u8_soc_data_type` 固定 0（周期采样）
|
||
*/
|
||
static U8_T u8_ocpp_mv_fill_snapshot(U8_T gun, S_OCPP_MV_OFFLINE_MV *out)
|
||
{
|
||
U64_T u64_wh; /**< 电表累计能量 Wh（64 位中间量，避免乘除溢出） */
|
||
U32_T start_wh; /**< 事务起始电表累计 Wh，来自日志能量 type=1 */
|
||
U64_T delta; /**< 事务段内增量 Wh = 当前累计 − 起始 */
|
||
Comm_Time now_ct; /**< 当前 RTC 日历（东八区），与 `BS_ocpp_ctrl.c` 中 `v_ocpp_timestamp_to_str(NULL,…)` 一致 */
|
||
|
||
if (out == NULL || gun >= GUN_MAX_CNT) {
|
||
return 0u;
|
||
}
|
||
(void)memset(out, 0, sizeof(*out)); //清空快照
|
||
out->u32_magic = OCPP_MV_OFFLINE_FLASH_MAGIC; //魔数
|
||
out->u16_version = (U16_T)OCPP_MV_OFFLINE_FLASH_VER; //版本
|
||
GetCurrentTime(&now_ct);
|
||
out->u32_timestamp_unix = (U32_T)xDate2Seconds(&now_ct); /* 日历 epoch 秒，非 get_current_seconds 上电秒 */
|
||
|
||
u64_wh = u64_bs_get_sys_data(gun, E_BS_GET_SYS_DATA_MEMTER_ELECT) / 10u; //电表累计能量 Wh
|
||
out->u32_meter_import_wh = (U32_T)((u64_wh > 0xFFFFFFFFULL) ? 0xFFFFFFFFu : u64_wh); //电表累计能量 Wh 截断
|
||
|
||
start_wh = u32_bs_get_sys_data(gun, E_BS_GET_SYS_DATA_LOG_ENERGY, 1u); //事务起始电表累计 Wh
|
||
delta = (out->u32_meter_import_wh > start_wh) ? ((U64_T)out->u32_meter_import_wh - (U64_T)start_wh) : 0u; //事务段内增量 Wh
|
||
out->u32_energy_interval_wh = (U32_T)((delta > 0xFFFFFFFFULL) ? 0xFFFFFFFFu : delta); //事务段内增量 Wh 截断
|
||
|
||
out->u16_voltage_v_x10 = u32_bs_get_sys_data(gun, E_BS_GET_SYS_DATA_METER_VOL, 0u); //输出电压 0.1V
|
||
out->u16_current_import_a_x100 = (U16_T)(u32_bs_get_sys_data(gun, E_BS_GET_SYS_DATA_METER_CUR, 0u) * 10u); //输出电流 0.01A
|
||
{
|
||
U32_T p_w; /**< `W = (0.1V×值)×(0.01A×值) = u16_voltage_v_x10 * u16_current_import_a_x100 / 1000` */
|
||
|
||
p_w = (U32_T)out->u16_voltage_v_x10 * (U32_T)out->u16_current_import_a_x100 / 1000u;
|
||
if (p_w > 65535u) {
|
||
p_w = 65535u;
|
||
}
|
||
out->u16_power_active_w = (U16_T)p_w;
|
||
}
|
||
out->u16_power_offered_01kw = (U16_T)u32_bs_get_sys_data(gun, E_BS_GET_SYS_DATA_RATED_POWER, 0u); //额定功率 0.1kW
|
||
out->u16_current_offered_a_x100 = (U16_T)u32_bs_get_sys_data(gun, E_BS_GET_SYS_DATA_PILE_PUT_PARA, 1u); //最大输出电流 0.01A
|
||
|
||
out->u8_soc = (U8_T)u32_bs_get_sys_data(gun, E_BS_GET_SYS_DATA_SOC_DATA, 0u); //SOC%
|
||
out->u8_soc_data_type = 0u; //SOC 上下文：0 当前 / 1 Transaction.Begin / 2 Transaction.End
|
||
out->u8_connector_id = (U8_T)(gun + 1u); //连接器号
|
||
out->u8_evse_id = gun; //EVSE/枪逻辑号
|
||
return 1u;
|
||
}
|
||
|
||
/**
|
||
* @fn v_ocpp_mv_offline_bridge_private_logic
|
||
* @brief 参见头文件声明；按枪轮询落盘离线 MV
|
||
*/
|
||
static U8_T u8_mv_pre_trade_no_pending(const U8_T *p)
|
||
{
|
||
if (p == NULL || p[0] == '\0' || p[0] == (U8_T)0xFF) {
|
||
return 1u;
|
||
}
|
||
return 0u;
|
||
}
|
||
|
||
/**
|
||
* @brief 将当前枪订单快照写入 Flash（不检查 flow，供停充边沿补一条）
|
||
* @return 1 成功；0 跳过或失败
|
||
*/
|
||
static U8_T u8_ocpp_mv_offline_persist_snapshot(U8_T gun, U32_T *seq_out)
|
||
{
|
||
S_LOG_DATA s_log;
|
||
U32_T charge_start_sec;
|
||
S_OCPP_MV_OFFLINE_MV mv;
|
||
U32_T seq_local;
|
||
U8_T sav_ret;
|
||
|
||
if (gun >= (U8_T)GUN_MAX_CNT) {
|
||
return 0u;
|
||
}
|
||
if (seq_out == NULL) {
|
||
seq_out = &seq_local;
|
||
}
|
||
(void)memset(&s_log, 0, sizeof(s_log));
|
||
v_meterlog_put_char_log_data(gun, &s_log);
|
||
v_ocpp_mv_charge_start_sec_from_time(&s_log.StartChargeTime, &charge_start_sec);
|
||
if (charge_start_sec == 0u) {
|
||
return 0u;
|
||
}
|
||
if (u8_ocpp_mv_fill_snapshot(gun, &mv) == 0u) {
|
||
return 0u;
|
||
}
|
||
sav_ret = u8_ocpp_mv_offline_mv_save(gun, charge_start_sec, 0u, &mv, seq_out);
|
||
if (sav_ret == 0u) {
|
||
s_ocpp_mv_bridge_ctx.last_mv_save_sec[gun] = (U32_T)get_current_seconds();
|
||
return 1u;
|
||
}
|
||
return 0u;
|
||
}
|
||
|
||
void v_ocpp_mv_offline_on_charge_start(U8_T gun)
|
||
{
|
||
if (gun >= (U8_T)GUN_MAX_CNT) {
|
||
return;
|
||
}
|
||
if (s_ocpp_mv_bridge_ctx.session.active != 0u
|
||
&& s_ocpp_mv_bridge_ctx.session.gun == gun) {
|
||
(void)memset(&s_ocpp_mv_bridge_ctx.session, 0, sizeof(s_ocpp_mv_bridge_ctx.session));
|
||
}
|
||
/* 勿清 FRAM 映射：同枪连续多笔离线充（A→B→A）须各自保留 StartChargeTime 键，上线后逐笔补 MV */
|
||
s_ocpp_mv_bridge_ctx.last_mv_save_sec[gun] = 0u;
|
||
s_u32_mv_map_full_log_sec[gun] = 0u;
|
||
s_u8_mv_charge_session_armed[gun] = 1u;
|
||
OCPP_OFFLINE_LOG("MV offline: charge start gun=%u (keep pending maps)\r\n", (unsigned)gun);
|
||
}
|
||
|
||
void v_ocpp_mv_offline_bridge_private_logic(U8_T bs_id)
|
||
{
|
||
U8_T i; /**< 枪循环变量 `0..GUN_MAX_CNT-1` */
|
||
U16_T interval_s; /**< 采样周期（秒），来自 OCPP 配置 `MeterValueSampleInterval` */
|
||
U32_T now; /**< `get_current_seconds()`：上电起单调秒，仅用于与 `MeterValueSampleInterval` 比较节流 */
|
||
|
||
(void)bs_id;
|
||
|
||
interval_s = (U16_T)60; /* 配置为 0 或未加载时的保守默认，避免除零或过频写 Flash */
|
||
if (s_ocpp_flash_cfg_data.s_ocpp_config_data.u16_MeterValueSampleInterval != 0u) {
|
||
interval_s = s_ocpp_flash_cfg_data.s_ocpp_config_data.u16_MeterValueSampleInterval;
|
||
}
|
||
|
||
now = (U32_T)get_current_seconds();
|
||
for (i = 0u; i < (U8_T)GUN_MAX_CNT; i++) {
|
||
S_LOG_DATA s_log; /**< 当前枪订单日志快照，含 `StartChargeTime` */
|
||
U32_T charge_start_sec; /**< `xDate2Seconds(StartChargeTime)`，与 FRAM `u32_tx_sn_lo` 一致 */
|
||
S_OCPP_MV_OFFLINE_MV mv; /**< 单条待写入 Flash 的 32B 负载 + 帧头由底层封装 */
|
||
U32_T seq_out; /**< 本笔分配到的该枪单调序号（调试用，此处未回传上层） */
|
||
U8_T sav_ret; /**< `u8_ocpp_mv_offline_mv_save` 返回值：0 成功，2 映射满，3 Flash，4 FRAM，5 序号不连续等 */
|
||
|
||
{
|
||
U8_T bs_flow = u8_bs_get_flow_state(i);
|
||
|
||
/* 停充边沿：补写结束时刻 MV，避免最后一采样周期未落盘 */
|
||
if (s_u8_mv_prev_bs_flow[i] == 2u && bs_flow != 2u) {
|
||
U32_T seq_end = 0u;
|
||
|
||
if (u8_ocpp_mv_offline_persist_snapshot(i, &seq_end) != 0u) {
|
||
OCPP_OFFLINE_LOG("MV offline: stop snap gun=%u seq=%lu\r\n",
|
||
(unsigned)i, (unsigned long)seq_end);
|
||
}
|
||
}
|
||
s_u8_mv_prev_bs_flow[i] = bs_flow;
|
||
if (bs_flow != 2u) { //枪未充电 跳过
|
||
s_u8_mv_charge_session_armed[i] = 0u;
|
||
continue;
|
||
}
|
||
}
|
||
if (s_u8_mv_charge_session_armed[i] == 0u) {
|
||
U32_T resume_key = 0u;
|
||
U32_T resume_seq = 0u;
|
||
U16_T resume_cnt = 0u;
|
||
|
||
(void)memset(&s_log, 0, sizeof(s_log));
|
||
v_meterlog_put_char_log_data(i, &s_log);
|
||
v_ocpp_mv_charge_start_sec_from_time(&s_log.StartChargeTime, &resume_key);
|
||
if (resume_key != 0u
|
||
&& u8_ocpp_mv_offline_map_get(i, resume_key, 0u, &resume_seq, &resume_cnt) == 0u
|
||
&& resume_cnt > 0u) {
|
||
/* 链路抖动/TCP 重连：同一笔充电勿清 map，避免补发从 seq 头反复上送 */
|
||
s_u8_mv_charge_session_armed[i] = 1u;
|
||
OCPP_OFFLINE_LOG("MV offline: gun=%u link resume, keep map (%u条) key=0x%08lX\r\n",
|
||
(unsigned)i, (unsigned)resume_cnt, (unsigned long)resume_key);
|
||
} else {
|
||
v_ocpp_mv_offline_on_charge_start(i);
|
||
}
|
||
}
|
||
if (interval_s != 0u && s_ocpp_mv_bridge_ctx.last_mv_save_sec[i] != 0u
|
||
&& (now - s_ocpp_mv_bridge_ctx.last_mv_save_sec[i]) < (U32_T)interval_s) { //时间间隔未到 跳过
|
||
continue;
|
||
}
|
||
|
||
(void)memset(&s_log, 0, sizeof(s_log));
|
||
v_meterlog_put_char_log_data(i, &s_log); //获取订单日志
|
||
v_ocpp_mv_charge_start_sec_from_time(&s_log.StartChargeTime, &charge_start_sec);
|
||
if (charge_start_sec == 0u) { /* 开始充电时间无效或未写入，无法建立稳定键 */
|
||
continue;
|
||
}
|
||
if (u8_ocpp_mv_fill_snapshot(i, &mv) == 0u) { //填充快照失败 跳过
|
||
continue;
|
||
}
|
||
sav_ret = u8_ocpp_mv_offline_mv_save(i, charge_start_sec, 0u, &mv, &seq_out);
|
||
if (sav_ret == 0u) {
|
||
s_ocpp_mv_bridge_ctx.last_mv_save_sec[i] = now;
|
||
OCPP_OFFLINE_LOG("MV offline: write ok gun=%u seq=%lu key_sec=0x%08lX unix_ts=%lu Wh=%lu Ival=%lu\r\n",
|
||
(unsigned)i,
|
||
(unsigned long)seq_out,
|
||
(unsigned long)charge_start_sec,
|
||
(unsigned long)mv.u32_timestamp_unix,
|
||
(unsigned long)mv.u32_meter_import_wh,
|
||
(unsigned long)mv.u32_energy_interval_wh);
|
||
} else if (sav_ret == 2u) {
|
||
U32_T now_log = (U32_T)get_current_seconds();
|
||
if (s_u32_mv_map_full_log_sec[i] == 0u
|
||
|| (now_log - s_u32_mv_map_full_log_sec[i]) >= 30u) {
|
||
s_u32_mv_map_full_log_sec[i] = now_log;
|
||
OCPP_OFFLINE_LOG("MV offline: map full gun=%u (FRAM rows=%u)\r\n",
|
||
(unsigned)i, (unsigned)OCPP_MV_OFFLINE_MAP_ROWS);
|
||
}
|
||
} else if (sav_ret != 5u) {
|
||
OCPP_OFFLINE_LOG("MV offline: save err=%u gun=%u\r\n", (unsigned)sav_ret, (unsigned)i);
|
||
}
|
||
}
|
||
}
|
||
|
||
void v_ocpp_mv_offline_snap_gun_now(U8_T gun)
|
||
{
|
||
U32_T seq_out = 0u;
|
||
|
||
if (gun >= (U8_T)GUN_MAX_CNT) {
|
||
return;
|
||
}
|
||
if (u8_bs_get_flow_state(gun) != 2u) {
|
||
return;
|
||
}
|
||
if (s_u8_mv_charge_session_armed[gun] == 0u) {
|
||
v_ocpp_mv_offline_on_charge_start(gun);
|
||
}
|
||
if (u8_ocpp_mv_offline_persist_snapshot(gun, &seq_out) != 0u) {
|
||
OCPP_OFFLINE_LOG("MV offline: ws-fail snap gun=%u seq=%lu\r\n",
|
||
(unsigned)gun, (unsigned long)seq_out);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @fn v_ocpp_mv_offline_unsettled_abort
|
||
* @brief 参见头文件；将 `s_ocpp_mv_bridge_ctx.unsettled` 整块清零
|
||
*/
|
||
void v_ocpp_mv_offline_unsettled_abort(void)
|
||
{
|
||
(void)memset(&s_ocpp_mv_bridge_ctx.unsettled, 0, sizeof(s_ocpp_mv_bridge_ctx.unsettled));
|
||
}
|
||
|
||
U8_T u8_ocpp_mv_offline_map_pending_for_log(const S_LOG_DATA *log)
|
||
{
|
||
U32_T charge_start_sec;
|
||
U32_T seq_start;
|
||
U16_T count;
|
||
U8_T gun;
|
||
|
||
if (log == NULL) {
|
||
return 0u;
|
||
}
|
||
gun = log->u8_gunNo;
|
||
if (gun >= (U8_T)GUN_MAX_CNT) {
|
||
gun = 0u;
|
||
}
|
||
v_ocpp_mv_charge_start_sec_from_time(&log->StartChargeTime, &charge_start_sec);
|
||
if (charge_start_sec == 0u) {
|
||
return 0u;
|
||
}
|
||
if (u8_ocpp_mv_offline_map_get(gun, charge_start_sec, 0u, &seq_start, &count) != 0u
|
||
|| count == 0u) {
|
||
return 0u;
|
||
}
|
||
return 1u;
|
||
}
|
||
|
||
void v_ocpp_mv_offline_session_replay_abort(void)
|
||
{
|
||
(void)memset(&s_ocpp_mv_bridge_ctx.session, 0, sizeof(s_ocpp_mv_bridge_ctx.session));
|
||
}
|
||
|
||
/**
|
||
* @brief 单步推进指定补发上下文，最多发送一条 MeterValues
|
||
* @return 1 本周期已发或需重试；0 无映射/已全部完成
|
||
*/
|
||
static U8_T u8_ocpp_mv_replay_step_ctx(S_OCPP_MV_REPLAY_CTX *rp, U8_T gun, U32_T charge_start_sec, int txid,
|
||
const char *tag)
|
||
{
|
||
U32_T seq_start;
|
||
U16_T count;
|
||
S_OCPP_MV_OFFLINE_MV mv;
|
||
|
||
if (rp == NULL || charge_start_sec == 0u || txid < 0) {
|
||
return 0u;
|
||
}
|
||
|
||
if (rp->active == 0u) {
|
||
if (u8_ocpp_mv_offline_map_get(gun, charge_start_sec, 0u, &seq_start, &count) != 0u || count == 0u) {
|
||
return 0u;
|
||
}
|
||
rp->active = 1u;
|
||
rp->gun = gun;
|
||
rp->u32_charge_start_sec = charge_start_sec;
|
||
rp->i32_txid = txid;
|
||
rp->seq_start = seq_start;
|
||
rp->seq_next = seq_start;
|
||
rp->seq_end = seq_start + (U32_T)count - 1u;
|
||
OCPP_OFFLINE_LOG("MV offline: %s queue gun=%u txId=%d key_sec=0x%08lX seq %lu-%lu (%u条)\r\n",
|
||
tag, (unsigned)gun, txid,
|
||
(unsigned long)charge_start_sec,
|
||
(unsigned long)seq_start,
|
||
(unsigned long)rp->seq_end,
|
||
(unsigned)count);
|
||
} else if (rp->gun != gun || rp->u32_charge_start_sec != charge_start_sec) {
|
||
(void)memset(rp, 0, sizeof(*rp));
|
||
return 0u;
|
||
}
|
||
|
||
if (rp->seq_next > rp->seq_end) {
|
||
(void)u8_ocpp_mv_offline_map_remove(rp->gun, rp->u32_charge_start_sec, 0u);
|
||
(void)memset(rp, 0, sizeof(*rp));
|
||
return 0u;
|
||
}
|
||
|
||
if (u8_ocpp_mv_offline_mv_read_by_seq(rp->gun, rp->seq_next, &mv) != 0u) {
|
||
OCPP_OFFLINE_LOG("MV offline: %s read fail gun=%u seq=%lu slot=%lu\r\n",
|
||
tag, (unsigned)rp->gun, (unsigned long)rp->seq_next,
|
||
(unsigned long)(rp->seq_next % (U32_T)OCPP_MV_OFFLINE_POOL_MAX_PER_GUN));
|
||
rp->seq_next++;
|
||
return 1u;
|
||
}
|
||
if (u8_ocpp_mv_offline_mv_is_valid(&mv) == 0u) {
|
||
OCPP_OFFLINE_LOG("MV offline: %s read skip invalid gun=%u seq=%lu\r\n",
|
||
tag, (unsigned)rp->gun, (unsigned long)rp->seq_next);
|
||
rp->seq_next++;
|
||
return 1u;
|
||
}
|
||
if (s32_ocpp_send_meter_values_replay((int)rp->gun, txid, &mv) <= 0) {
|
||
OCPP_OFFLINE_LOG("MV offline: %s send fail gun=%u seq=%lu\r\n",
|
||
tag, (unsigned)rp->gun, (unsigned long)rp->seq_next);
|
||
return 1u;
|
||
}
|
||
|
||
{
|
||
U32_T total = rp->seq_end - rp->seq_start + 1u;
|
||
U32_T done;
|
||
|
||
rp->seq_next++;
|
||
done = rp->seq_next - rp->seq_start;
|
||
OCPP_OFFLINE_LOG("MV offline: %s send ok gun=%u %lu/%lu seq=%lu ts=%lu Wh=%lu\r\n",
|
||
tag, (unsigned)rp->gun,
|
||
(unsigned long)done, (unsigned long)total,
|
||
(unsigned long)(rp->seq_next - 1u),
|
||
(unsigned long)mv.u32_timestamp_unix,
|
||
(unsigned long)mv.u32_meter_import_wh);
|
||
if (rp->seq_next > rp->seq_end) {
|
||
OCPP_OFFLINE_LOG("MV offline: %s replay done gun=%u total=%lu\r\n",
|
||
tag, (unsigned)rp->gun, (unsigned long)total);
|
||
(void)u8_ocpp_mv_offline_map_remove(rp->gun, rp->u32_charge_start_sec, 0u);
|
||
(void)memset(rp, 0, sizeof(*rp));
|
||
return 0u;
|
||
}
|
||
}
|
||
return 1u;
|
||
}
|
||
|
||
U8_T u8_ocpp_mv_offline_session_replay_pending(U8_T gun)
|
||
{
|
||
S_LOG_DATA log;
|
||
U32_T charge_start_sec;
|
||
U32_T seq_start;
|
||
U16_T count;
|
||
|
||
if (gun >= (U8_T)GUN_MAX_CNT) {
|
||
return 0u;
|
||
}
|
||
if (s_ocpp_mv_bridge_ctx.session.active != 0u) {
|
||
return (gun == s_ocpp_mv_bridge_ctx.session.gun) ? 1u : 0u;
|
||
}
|
||
if (s_ocpp_mv_bridge_ctx.unsettled.active != 0u) {
|
||
return 0u;
|
||
}
|
||
(void)memset(&log, 0, sizeof(log));
|
||
if (u8_plat_get_real_order(&log, gun) == 0u) {
|
||
return 0u;
|
||
}
|
||
if (u8_mv_pre_trade_no_pending(log.u8_preTradeNo) != 0u) {
|
||
return 0u;
|
||
}
|
||
v_ocpp_mv_charge_start_sec_from_time(&log.StartChargeTime, &charge_start_sec);
|
||
if (charge_start_sec == 0u) {
|
||
return 0u;
|
||
}
|
||
if (u8_ocpp_mv_offline_map_get(gun, charge_start_sec, 0u, &seq_start, &count) != 0u || count == 0u) {
|
||
return 0u;
|
||
}
|
||
return 1u;
|
||
}
|
||
|
||
U8_T u8_ocpp_mv_offline_session_replay_step(U8_T gun)
|
||
{
|
||
S_LOG_DATA log;
|
||
U32_T charge_start_sec;
|
||
U8_T flow;
|
||
int txid;
|
||
|
||
if (gun >= (U8_T)GUN_MAX_CNT) {
|
||
return 0u;
|
||
}
|
||
if (s_ocpp_mv_bridge_ctx.unsettled.active != 0u) {
|
||
return 0u;
|
||
}
|
||
|
||
/* 已在补发：仅在本枪推进；其它枪轮询项直接跳过，避免 gun0 空订单 pending 占满发送队列（session_0013） */
|
||
if (s_ocpp_mv_bridge_ctx.session.active != 0u) {
|
||
if (gun != s_ocpp_mv_bridge_ctx.session.gun) {
|
||
return 0u;
|
||
}
|
||
txid = s_ocpp_mv_bridge_ctx.session.i32_txid;
|
||
(void)memset(&log, 0, sizeof(log));
|
||
if (u8_plat_get_real_order(&log, gun) != 0u) {
|
||
int live_tx = atoi((const char *)log.u8_preTradeNo);
|
||
if (live_tx > 0) {
|
||
s_ocpp_mv_bridge_ctx.session.i32_txid = live_tx;
|
||
txid = live_tx;
|
||
}
|
||
}
|
||
return u8_ocpp_mv_replay_step_ctx(&s_ocpp_mv_bridge_ctx.session,
|
||
s_ocpp_mv_bridge_ctx.session.gun,
|
||
s_ocpp_mv_bridge_ctx.session.u32_charge_start_sec,
|
||
txid, "session");
|
||
}
|
||
|
||
(void)memset(&log, 0, sizeof(log));
|
||
if (u8_plat_get_real_order(&log, gun) == 0u) {
|
||
return 0u;
|
||
}
|
||
if (u8_mv_pre_trade_no_pending(log.u8_preTradeNo) != 0u) {
|
||
return 0u;
|
||
}
|
||
v_ocpp_mv_charge_start_sec_from_time(&log.StartChargeTime, &charge_start_sec);
|
||
if (charge_start_sec == 0u) {
|
||
return 0u;
|
||
}
|
||
txid = atoi((const char *)log.u8_preTradeNo);
|
||
|
||
flow = u8_bs_get_flow_state(gun);
|
||
if (flow != 2u && flow != 9u && flow != 10u) {
|
||
return 0u;
|
||
}
|
||
|
||
return u8_ocpp_mv_replay_step_ctx(&s_ocpp_mv_bridge_ctx.session, gun, charge_start_sec, txid, "session");
|
||
}
|
||
|
||
/**
|
||
* @fn u8_ocpp_mv_offline_unsettled_step
|
||
* @brief 参见头文件；单步推进补发状态机并最多发送一条 WS MeterValues
|
||
*/
|
||
U8_T u8_ocpp_mv_offline_unsettled_step(S_LOG_DATA *log)
|
||
{
|
||
U32_T charge_start_sec;
|
||
U8_T gun;
|
||
int txid;
|
||
|
||
if (log == NULL) {
|
||
return 0u;
|
||
}
|
||
if (u8_ocpp_unsettled_is_live_charging_session(log) != 0u) {
|
||
return 0u;
|
||
}
|
||
gun = log->u8_gunNo;
|
||
if (gun >= GUN_MAX_CNT) {
|
||
gun = 0u;
|
||
}
|
||
v_ocpp_mv_charge_start_sec_from_time(&log->StartChargeTime, &charge_start_sec);
|
||
if (charge_start_sec == 0u) {
|
||
return 0u;
|
||
}
|
||
if (u8_mv_pre_trade_no_pending(log->u8_preTradeNo) != 0u) {
|
||
return 0u;
|
||
}
|
||
txid = atoi((const char *)log->u8_preTradeNo);
|
||
if (txid < 0) {
|
||
return 0u;
|
||
}
|
||
if (u8_ocpp_mv_offline_map_pending_for_log(log) == 0u) {
|
||
OCPP_OFFLINE_LOG("MV offline: unsettled no map gun=%u key_sec=0x%08lX txId=%d\r\n",
|
||
(unsigned)gun, (unsigned long)charge_start_sec, txid);
|
||
return 0u;
|
||
}
|
||
if (s_ocpp_mv_bridge_ctx.session.active != 0u
|
||
&& s_ocpp_mv_bridge_ctx.session.gun == gun) {
|
||
/* 同枪在线会话 MV 补发中：勿 abort session 走未结 StopTx（session_0012） */
|
||
if (u8_ocpp_unsettled_is_live_charging_session(log) != 0u) {
|
||
return 0u;
|
||
}
|
||
v_ocpp_mv_offline_session_replay_abort();
|
||
}
|
||
return u8_ocpp_mv_replay_step_ctx(&s_ocpp_mv_bridge_ctx.unsettled, gun, charge_start_sec, txid, "unsettled");
|
||
}
|
||
|
||
#endif /* BS_OCPP_EN */
|