#include "BS_ocpp_configuration.h" #include "plat_comm/plat_comm_task.h" #include "bsp_include.h" #include "publicdata/publicdata.h" #include "app_fatfs/fatfs_card.h" #define OCPP_CONFIG_PRINTF_LOG(fmt, ...) \ MYLOG_MSG(OCPP_PRINT_FLAG,fmt, ##__VA_ARGS__) //任务打印 #if BS_OCPP_EN S_OCPP_FLASH_CFG_DATA s_ocpp_flash_cfg_data; OCPP_CONFIG *private_config_data = &s_ocpp_flash_cfg_data.s_ocpp_config_data; //内部指针引用，初始化时赋值全局变量的值 //保存unknown的Key串 char *unknown_tmpbuf[GetConfiguration_NUM] = {NULL}; static const char *phase_to_str(OCPP_CONNECTOR_PHASE phase) { switch (phase) { case ENUM_NotApplicable: return "NotApplicable"; case ENUM_Unknown: return "Unknown"; case ENUM_RST: return "RST"; case ENUM_RTS: return "RTS"; case ENUM_SRT: return "SRT"; case ENUM_STR: return "STR"; case ENUM_TRS: return "TRS"; case ENUM_TSR: return "TSR"; default: return "NotApplicable"; } } static U8_T str_to_phase(const char *value, OCPP_CONNECTOR_PHASE *phase) { if (value == NULL || phase == NULL) return 0; if (strcmp(value, "0") == 0 || strcmp(value, "NotApplicable") == 0) { *phase = ENUM_NotApplicable; return 1; } if (strcmp(value, "1") == 0 || strcmp(value, "Unknown") == 0) { *phase = ENUM_Unknown; return 1; } if (strcmp(value, "RST") == 0) { *phase = ENUM_RST; return 1; } if (strcmp(value, "RTS") == 0) { *phase = ENUM_RTS; return 1; } if (strcmp(value, "SRT") == 0) { *phase = ENUM_SRT; return 1; } if (strcmp(value, "STR") == 0) { *phase = ENUM_STR; return 1; } if (strcmp(value, "TRS") == 0) { *phase = ENUM_TRS; return 1; } if (strcmp(value, "TSR") == 0) { *phase = ENUM_TSR; return 1; } return 0; } static U8_T extract_phase_item(const char *src, char index, char *out, U16_T out_len) { char pattern[4] = {0}; const char *start; U16_T i = 0; if (src == NULL || out == NULL || out_len == 0) return 0; pattern[0] = index; pattern[1] = '.'; pattern[2] = '\0'; start = strstr(src, pattern); if (start == NULL) return 0; start += 2; while (*start && *start != ',' && i < (out_len - 1)) { out[i++] = *start++; } out[i] = '\0'; return (i > 0) ? 1 : 0; } static U8_T parse_connector_phase_rotation(const char *value, OCPP_CONNECTOR_PHASE phase_out[3], const OCPP_CONNECTOR_PHASE phase_curr[3]) { OCPP_CONNECTOR_PHASE p0 = phase_curr[0]; OCPP_CONNECTOR_PHASE p1 = phase_curr[1]; OCPP_CONNECTOR_PHASE p2 = phase_curr[2]; char v0[24] = {0}; char v1[24] = {0}; char v2[24] = {0}; U8_T has_indexed = 0; has_indexed |= extract_phase_item(value, '0', v0, sizeof(v0)); has_indexed |= extract_phase_item(value, '1', v1, sizeof(v1)); has_indexed |= extract_phase_item(value, '2', v2, sizeof(v2)); if (has_indexed) { if ((v0[0] != '\0' && str_to_phase(v0, &p0) == 0) || (v1[0] != '\0' && str_to_phase(v1, &p1) == 0) || (v2[0] != '\0' && str_to_phase(v2, &p2) == 0)) { return 0; } phase_out[0] = p0; phase_out[1] = p1; phase_out[2] = p2; return 1; } if (str_to_phase(value, &p1) == 0) return 0; phase_out[0] = p1; phase_out[1] = p1; phase_out[2] = p1; return 1; } /** 去掉字符串首尾空格/制表（就地） */ static void str_trim_inplace(char *s) { size_t len; size_t start = 0; if (s == NULL || s[0] == '\0') return; len = strlen(s); while (start < len && (s[start] == ' ' || s[start] == '\t')) start++; if (start > 0) memmove(s, s + start, len - start + 1); len = strlen(s); while (len > 0 && (s[len - 1] == ' ' || s[len - 1] == '\t' || s[len - 1] == '\r' || s[len - 1] == '\n')) s[--len] = '\0'; } /** 逗号分隔 CSL 中与 measurand 完全一致的 token 是否存在（避免 strstr 子串误匹配，如 Current.Import 命中 Current.Offered） */ static U8_T meter_values_csl_has_token(const char *value_csl, const char *measurand_str) { const char *p; char token[160]; U16_T ti; if (value_csl == NULL || measurand_str == NULL || measurand_str[0] == '\0') return 0; p = value_csl; while (*p != '\0') { while (*p == ' ' || *p == '\t') p++; ti = 0; while (*p != '\0' && *p != ',' && ti + 1 < sizeof(token)) token[ti++] = *p++; token[ti] = '\0'; str_trim_inplace(token); if (token[0] != '\0' && strcmp(token, measurand_str) == 0) return 1; if (*p == ',') p++; } return 0; } /** 统计逗号分隔列表中非空 token 数量（去首尾空格后） */ static U16_T meter_values_csl_count_nonempty_tokens(const char *value_csl) { const char *p; char token[160]; U16_T ti; U16_T n = 0; if (value_csl == NULL) return 0; p = value_csl; while (*p != '\0') { while (*p == ' ' || *p == '\t') p++; ti = 0; while (*p != '\0' && *p != ',' && ti + 1 < sizeof(token)) token[ti++] = *p++; token[ti] = '\0'; str_trim_inplace(token); if (token[0] != '\0') n++; if (*p == ',') p++; } return n; } // MeterValues测量项 串数组（标准字符串 只读不可修改。顺序对应枚举顺序，固定不可变更） const char *OCPP_measurand_str[] = { // ------------------- 能量累计类（Register）- 文档7.31 核心计费累计项 ------------------- /*{ENUM_EnergyActiveExportRegister, */OCPP_STR_EnergyActiveExportRegister ,//}, /*{ENUM_EnergyActiveImportRegister, */OCPP_STR_EnergyActiveImportRegister ,//}, /*{ENUM_EnergyReactiveExportRegister, */OCPP_STR_EnergyReactiveExportRegister ,//}, /*{ENUM_EnergyReactiveImportRegister, */OCPP_STR_EnergyReactiveImportRegister ,//}, // ------------------- 能量时段类（Interval）- 文档7.31 时钟对齐时段项 ------------------- /*{ENUM_EnergyActiveExportInterval, */OCPP_STR_EnergyActiveExportInterval ,//}, /*{ENUM_EnergyActiveImportInterval, */OCPP_STR_EnergyActiveImportInterval ,//}, /*{ENUM_EnergyReactiveExportInterval, */OCPP_STR_EnergyReactiveExportInterval ,//}, /*{ENUM_EnergyReactiveImportInterval, */OCPP_STR_EnergyReactiveImportInterval ,//}, // ------------------- 功率类 - 文档7.31 实时功率监控项 ------------------- /*{ENUM_PowerActiveExport, */OCPP_STR_PowerActiveExport ,//}, /*{ENUM_PowerActiveImport, */OCPP_STR_PowerActiveImport ,//}, /*{ENUM_PowerOffered, */OCPP_STR_PowerOffered ,//}, /*{ENUM_PowerReactiveExport, */OCPP_STR_PowerReactiveExport ,//}, /*{ENUM_PowerReactiveImport, */OCPP_STR_PowerReactiveImport ,//}, /*{ENUM_PowerFactor, */OCPP_STR_PowerFactor ,//}, // ------------------- 电流类 - 文档7.31 实时电流监控项 ------------------- /*{ENUM_CurrentImport, */OCPP_STR_CurrentImport ,//}, /*{ENUM_CurrentExport, */OCPP_STR_CurrentExport ,//}, /*{ENUM_CurrentOffered, */OCPP_STR_CurrentOffered ,//}, // ------------------- 电气参数类 - 文档7.31 基础电气特性项 ------------------- /*{ENUM_Voltage, */OCPP_STR_Voltage ,//}, /*{ENUM_Frequency, */OCPP_STR_Frequency ,//}, // ------------------- 物理/状态量类 - 文档7.31 非电气计量项 ------------------- /*{ENUM_Temperature, */OCPP_STR_Temperature ,//}, /*{ENUM_SoC, */OCPP_STR_SOC ,//}, /*{ENUM_RPM, */OCPP_STR_RPM ,//}, }; //OCPP可配置参数结构体数组 const OCPP_CONFIG_INFO OCPP_config_info[] = { {ENUM_NULL, ENUM_SUPPORT_NOT, ENUM_TYPE_INT, "NULL"}, // -------------------------------------------------------- // 核心配置参数（数据类型与功能说明） // -------------------------------------------------------- {ENUM_ALLOW_OFFLINE_TX_FOR_UNKNOWN_ID, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_ALLOW_OFFLINE_TX_FOR_UNKNOWN_ID}, /* 可选 允许未知用户ID的离线交易 (布尔: 0/1) */ {ENUM_AUTHORIZATION_CACHE_ENABLED, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_AUTHORIZATION_CACHE_ENABLED}, /* 可选 启用本地授权缓存 (布尔: 0/1) */ {ENUM_AUTHORIZE_REMOTE_TX_REQUESTS, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_AUTHORIZE_REMOTE_TX_REQUESTS}, /* 必选 允许远程启动充电事务 (布尔: 0/1) */ {ENUM_BLINK_REPEAT, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_BLINK_REPEAT}, /* 可选 充电桩指示灯闪烁次数 (整数: 次数) */ {ENUM_CLOCK_ALIGNED_DATA_INTERVAL, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_CLOCK_ALIGNED_DATA_INTERVAL}, /* 必选 时钟对齐的数据上报间隔 (整数: 秒) */ {ENUM_CONNECTION_TIME_OUT, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_CONNECTION_TIMEOUT}, /* 必选 TCP连接超时时间 (整数: 秒) */ {ENUM_CONNECTOR_PHASE_ROTATION, ENUM_SUPPORT_YES, ENUM_TYPE_CSL, KEY_CONNECTOR_PHASE_ROTATION}, /* 必选 连接器相位旋转配置 (字符串: L1/L2/L3顺序) */ {ENUM_CONNECTOR_PHASE_ROTATION_MAX_LENGTH, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_CONNECTOR_PHASE_ROTATION_MAX_LENGTH}, /* 可选 相位旋转配置最大长度 (整数: 字节数) */ {ENUM_GET_CONFIGURATION_MAX_KEYS, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_GET_CONFIGURATION_MAX_KEYS}, /* 必选 GetConfiguration请求最大返回Key数 (整数: 数量) */ {ENUM_HEARTBEAT_INTERVAL, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_HEARTBEAT_INTERVAL}, /* 必选 心跳间隔 (整数: 秒) */ {ENUM_LIGHT_INTENSITY, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_LIGHT_INTENSITY}, /* 可选 充电桩灯光亮度 (整数: 百分比) */ {ENUM_LOCAL_AUTHORIZE_OFFLINE, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_LOCAL_AUTHORIZE_OFFLINE}, /* 必选 本地离线授权模式 (布尔: 0/1) */ {ENUM_LOCAL_PRE_AUTHORIZE, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_LOCAL_PRE_AUTHORIZE}, /* 必选 本地预授权模式 (布尔: 0/1) */ {ENUM_MAX_ENERGY_ON_INVALID_ID, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_MAX_ENERGY_ON_INVALID_ID}, /* 可选 无效ID用户的最大允许充电能量 (整数: Wh) */ {ENUM_METER_VALUES_ALIGNED_DATA, ENUM_SUPPORT_YES, ENUM_TYPE_CSL, KEY_METER_VALUES_ALIGNED_DATA}, /* 必选 对齐数据上报的测量项列表 (字符串: 逗号分隔的measurand值) */ {ENUM_METER_VALUES_ALIGNED_DATA_MAX_LENGTH, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_METER_VALUES_ALIGNED_DATA_MAX_LENGTH}, /* 可选 对齐数据列表最大长度 (整数: 字符数) */ {ENUM_METER_VALUES_SAMPLED_DATA, ENUM_SUPPORT_YES, ENUM_TYPE_CSL, KEY_METER_VALUES_SAMPLED_DATA}, /* 必选 采样数据上报的测量项列表 (字符串: 逗号分隔的measurand值) */ {ENUM_METER_VALUES_SAMPLED_DATA_MAX_LENGTH, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_METER_VALUES_SAMPLED_DATA_MAX_LENGTH}, /* 可选 采样数据列表最大长度 (整数: 字符数) */ {ENUM_METER_VALUE_SAMPLE_INTERVAL, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_METER_VALUE_SAMPLE_INTERVAL}, /* 必选 采样间隔 (整数: 秒) */ {ENUM_MINIMUM_STATUS_DURATION, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_MINIMUM_STATUS_DURATION}, /* 可选 状态最小持续时间 (整数: 秒) */ {ENUM_NUMBER_OF_CONNECTORS, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_NUMBER_OF_CONNECTORS}, /* 必选 充电桩连接器数量 (整数: 数量) */ {ENUM_RESET_RETRIES, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_RESET_RETRIES}, /* 必选 复位重试次数 (整数: 次数) */ {ENUM_STOP_TRANSACTION_ON_EV_SIDE_DISCONNECT, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_STOP_TXN_ON_EV_SIDE_DISCONNECT}, /* 必选 EV端断开时停止事务 (布尔: 0/1) */ {ENUM_STOP_TRANSACTION_ON_INVALID_ID, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_STOP_TXN_ON_INVALID_ID}, /* 必选 无效ID时停止事务 (布尔: 0/1) */ {ENUM_STOP_TXN_ALIGNED_DATA, ENUM_SUPPORT_YES, ENUM_TYPE_CSL, KEY_STOP_TXN_ALIGNED_DATA}, /* 必选 事务停止时的对齐数据项 (字符串: 逗号分隔的measurand值) */ {ENUM_STOP_TXN_ALIGNED_DATA_MAX_LENGTH, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_STOP_TXN_ALIGNED_DATA_MAX_LENGTH}, /* 可选 停止事务对齐数据最大长度 (整数: 字符数) */ {ENUM_STOP_TXN_SAMPLED_DATA, ENUM_SUPPORT_YES, ENUM_TYPE_CSL, KEY_STOP_TXN_SAMPLED_DATA}, /* 必选 停止事务时的采样数据项 (字符串: 逗号分隔的measurand值) */ {ENUM_STOP_TXN_SAMPLED_DATA_MAX_LENGTH, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_STOP_TXN_SAMPLED_DATA_MAX_LENGTH}, /* 可选 停止事务采样数据最大长度 (整数: 字符数) */ {ENUM_SUPPORTED_FEATURE_PROFILES, ENUM_SUPPORT_YES, ENUM_TYPE_CSL, KEY_SUPPORTED_FEATURE_PROFILES}, /* 必选 支持的功能配置文件 (字符串: 逗号分隔的FeatureProfile值) */ {ENUM_SUPPORTED_FEATURE_PROFILES_MAX_LENGTH, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_SUPPORTED_FEATURE_PROFILES_MAX_LENGTH}, /* 可选 功能配置文件列表最大长度 (整数: 字符数) */ {ENUM_TRANSACTION_MESSAGE_ATTEMPTS, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_TRANSACTION_MESSAGE_ATTEMPTS}, /* 必选 事务消息重试次数 (整数: 次数) */ {ENUM_TRANSACTION_MESSAGE_RETRY_INTERVAL, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_TRANSACTION_MESSAGE_RETRY_INTERVAL}, /* 必选 事务消息重试间隔 (整数: 秒) */ {ENUM_UNLOCK_CONNECTOR_ON_EV_SIDE_DISCONNECT, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_UNLOCK_CONNECTOR_ON_EV_DISCONNECT}, /* 必选 EV端断开时解锁连接器 (布尔: 0/1) */ {ENUM_WEB_SOCKET_PING_INTERVAL, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_WEBSOCKET_PING_INTERVAL}, /* 可选 WebSocket Ping间隔 (整数: 秒) */ // -------------------------------------------------------- // 本地授权与充电配置管理 // -------------------------------------------------------- {ENUM_LOCAL_AUTH_LIST_ENABLED, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_LOCAL_AUTH_LIST_ENABLED}, /* 必选 启用本地授权列表 (布尔: 0/1) */ {ENUM_LOCAL_AUTH_LIST_MAX_LENGTH, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_LOCAL_AUTH_LIST_MAX_LENGTH}, /* 必选 本地授权列表的最大条目数 (整数) */ {ENUM_SEND_LOCAL_LIST_MAX_LENGTH, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_SEND_LOCAL_LIST_MAX_LENGTH}, /* 必选 发送本地列表的最大条目数 (整数) */ // -------------------------------------------------------- // 连接器与充电行为控制 // -------------------------------------------------------- {ENUM_RESERVE_CONNECTOR_ZERO_SUPPORTED, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_RESERVE_CONNECTOR_ZERO_SUPPORTED}, /* 可选 是否支持预留连接器0 (布尔: 0/1) */ // -------------------------------------------------------- // 充电计划与配置限制 // -------------------------------------------------------- {ENUM_CHARGE_PROFILE_MAX_STACK_LEVEL, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_CHARGE_PROFILE_MAX_STACK_LEVEL}, /* 必选 充电配置最大堆叠层级 (整数) */ {ENUM_CHARGING_SCHEDULE_ALLOWED_RATE_UNIT, ENUM_SUPPORT_YES, ENUM_TYPE_CSL, KEY_CHARGING_SCHEDULE_ALLOWED_RATE_UNIT}, /* 必选 充电速率允许单位 (字符串: "A"或"W") */ {ENUM_CHARGING_SCHEDULE_MAX_PERIODS, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_CHARGING_SCHEDULE_MAX_PERIODS}, /* 必选 充电计划最大时段数 (整数) */ {ENUM_CONNECTOR_SWITCH_3TO1_PHASE_SUPPORTED, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_CONNECTOR_SWITCH_3TO1_PHASE_SUPPORTED}, /* 可选 是否支持三相切单相充电 (布尔: 0/1) */ {ENUM_MAX_CHARGING_PROFILES_INSTALLED, ENUM_SUPPORT_YES, ENUM_TYPE_INT, KEY_MAX_CHARGING_PROFILES_INSTALLED}, /* 必选 最大可安装充电配置数 (整数) */ // -------------------------------------------------------- // 各平台私有配置 // -------------------------------------------------------- {ENUM_QRCODE_TEXT_CONNECTOR1, ENUM_SUPPORT_YES, ENUM_TYPE_CSL, KEY_QRCODE_TEXT_CONNECTOR1}, /* 枪1二维码 */ {ENUM_QRCODE_TEXT_CONNECTOR2, ENUM_SUPPORT_YES, ENUM_TYPE_CSL, KEY_QRCODE_TEXT_CONNECTOR2}, /* 枪2二维码 */ }; /******************************************************************************* * 名称: u8_find_OCPP_configID * 功能: 根据字符串查找对应OCPP配置参数的枚举变量 * 参数: *mag OCPP配置参数的键的字符串 * 返回: 返回该键在OCPP_CONFIG_KEY_ID的对应枚举量，若返回ENUM_NULL则未找到该键 * 说明: ******************************************************************************/ OCPP_CONFIG_KEY_ID u8_find_OCPP_configID(const char *mag) { if(mag == NULL) return ENUM_NULL; OCPP_CONFIG_KEY_ID ret = ENUM_NULL; for(U8_T i = 1; i < ENUM_OCPP_CONFIG; i++) { if(strcmp(OCPP_config_info[i].str_data, mag) == 0) { ret = OCPP_config_info[i].u8_keyID; break; } } return ret; } /******************************************************************************* * 名称: find_OCPP_configMag * 功能: 根据配置参数的枚举号 找对应字符串 并赋值 * 参数: keyID 配置参数的枚举号 * *mag 要赋值串的指针头 * u16_len 被赋值的key串最大长度 * 返回: - * 说明: ******************************************************************************/ void find_OCPP_configMag(OCPP_CONFIG_KEY_ID keyID, char *mag, U16_T u16_len) { if(mag == NULL) return; for(U8_T i = 1; i < ENUM_OCPP_CONFIG; i++) { if(OCPP_config_info[i].u8_keyID == keyID) { memset(mag , 0, u16_len); snprintf(mag , u16_len , "%s" , OCPP_config_info[i].str_data); break; } } return; } /******************************************************************************* * 名称: u8_check_OCPP_configSupport * 功能: 根据配置参数的枚举号 找是否支持 * 参数: keyID 配置参数的枚举号 * 返回: 是否支持标志 * 说明: ******************************************************************************/ OCPP_CONFIG_SUPPORT u8_check_OCPP_configSupport(OCPP_CONFIG_KEY_ID keyID) { OCPP_CONFIG_SUPPORT ret = ENUM_SUPPORT_NOT; for(U8_T i = 1; i < ENUM_OCPP_CONFIG; i++) { if(OCPP_config_info[i].u8_keyID == keyID) { ret = OCPP_config_info[i].u8_support; break; } } return ret; } /******************************************************************************* * 名称: u8_get_bool_value * 功能: 根据字符串查找对应bool值 * 参数: *mag bool字符串 * 返回: 0-false，1-true，0xff-非bool值 * 说明: ******************************************************************************/ U8_T u8_get_bool_value(const char *mag) { if(strcmp(STR_TRUE, mag) == 0) return 1; if(strcmp(STR_true, mag) == 0) return 1; if(strcmp(STR_1 , mag) == 0) return 1; if(strcmp(STR_FALSE, mag) == 0) return 0; if(strcmp(STR_false, mag) == 0) return 0; if(strcmp(STR_0 , mag) == 0) return 0; return 0xff; } /******************************************************************************* * 名称: operate_get_bool * 功能: bool类型键的获取值操作，将键值转为字符串，并赋值到应答value串 * 参数: value 键值 * *value_mag 配置参数值的字符串 * u16_len 配置参数值的字符串的最大长度 * 返回: * 说明: ******************************************************************************/ void operate_get_bool(U8_T value, char *value_mag , U16_T u16_len) { // 将布尔值（U8_T）转化为字符串并赋值给应答value memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%s" , value ? STR_true : STR_false); } /******************************************************************************* * 名称: operate_set_bool * 功能: bool类型键的修改值操作，将字符串转为bool值，并赋值到value * 参数: *value 需要被修改的参数 * *value_mag bool字符串 * ocpp_key 被修改的键 * 返回: 参数修改结果 0-Rejected 1-Accepted 2-RebootRequired 3-NotSupported * 说明: ******************************************************************************/ OCPP_SETCONFIG_RET operate_set_bool(U8_T *value, char *value_mag, OCPP_CONFIG_KEY_ID ocpp_key) { // 布尔值解析，0=false，1=true，0xff=非布尔值 U8_T res_data = u8_get_bool_value(value_mag); //无效bool值，无法修改参数，返回0-Rejected if(res_data == 0xff) { OCPP_CONFIG_PRINTF_LOG("Set keyID(%d): invalid bool (%s), reject\n", ocpp_key, value_mag); return ENUM_Rejected; } // 赋值 *value = res_data; OCPP_CONFIG_PRINTF_LOG("Set keyID(%d): bool=%d\n", ocpp_key, res_data); return ENUM_Accepted; } /******************************************************************************* * 名称: operate_set_integer * 功能: integer类型键的修改值操作，将字符串转为integer值，并赋值到value * 参数: *value 需要被修改的参数 * *value_mag integer字符串 * ocpp_key 被修改的键 * 返回: 参数修改结果 0-Rejected 1-Accepted 2-RebootRequired 3-NotSupported * 说明: ******************************************************************************/ OCPP_SETCONFIG_RET operate_set_integer(U16_T *value, char *value_mag, OCPP_CONFIG_KEY_ID ocpp_key) { //将字符串转化为整数 int res_data = atoi(value_mag); //判断有效性 if(res_data < 0 || res_data > 0xffff) { OCPP_CONFIG_PRINTF_LOG("Set keyID(%d): invalid int (%d), reject\n", ocpp_key, res_data); return ENUM_Rejected; } //赋值 *value = res_data; OCPP_CONFIG_PRINTF_LOG("Set keyID(%d): int=%d\n", ocpp_key, res_data); return ENUM_Accepted; } /******************************************************************************* * 名称: u8_OCPP_config_operate * 功能: 对OCPP配置参数进行读或写 * 参数: operate_type 操作类型，ENUM_TYPE_GET--获取参数，ENUM_TYPE_GET--设置参数 * *key_mag 配置参数键的字符串 * *value_mag 配置参数值的字符串 * u16_len 配置参数值的字符串的最大长度 * 返回: 参数修改时：0-Rejected 1-Accepted 2-RebootRequired 3-NotSupported * 参数获取时 0-readonly-false 1-readonly-ture * 说明: ******************************************************************************/ U8_T u8_OCPP_config_operate(OCPP_CONFIG_OPERATE operate_type, const char *key_mag, char *value_mag , U16_T u16_len) { //空指针 或 操作类型不存在 则return 3 if(key_mag == NULL || value_mag == NULL || (operate_type != ENUM_TYPE_GET && operate_type != ENUM_TYPE_SET)) return ENUM_NotSupported; OCPP_CONFIG_KEY_ID ocpp_key = u8_find_OCPP_configID(key_mag); //获取键 //ENUM_TYPE_SET:未找到键或不支持键则return 3 if(operate_type == ENUM_TYPE_SET && OCPP_config_info[ocpp_key].u8_support == ENUM_SUPPORT_NOT) return ENUM_NotSupported; int res_data; U8_T ret = ENUM_Accepted; switch (ocpp_key) { //////////////////////////////////////////////////////////////// //必选 bool类型 //////////////////////////////////////////////////////////////// case ENUM_AUTHORIZE_REMOTE_TX_REQUESTS: // 必选 远程启动交易是否需要预授权 (布尔: 0=不需要/1=需要) { if(operate_type == ENUM_TYPE_GET) // 获取值 { //bool类型键的获取值操作 operate_get_bool(private_config_data->u8_AuthorizeRemoteTxRequests, value_mag, u16_len); ret = ENUM_RnW; //可读写 } else // 修改值 { //bool类型键的修改值操作 ret = operate_set_bool(&(private_config_data->u8_AuthorizeRemoteTxRequests), value_mag, ocpp_key); } } break; case ENUM_LOCAL_AUTHORIZE_OFFLINE: // 必选 离线时是否允许本地授权启动交易 (布尔: 0=不允许/1=允许) { if(operate_type == ENUM_TYPE_GET) // 获取值 { //bool类型键的获取值操作 operate_get_bool(private_config_data->u8_LocalAuthorizeOffline, value_mag, u16_len); ret = ENUM_RnW; //可读写 } else // 修改值 { //bool类型键的修改值操作 ret = operate_set_bool(&(private_config_data->u8_LocalAuthorizeOffline), value_mag, ocpp_key); } } break; case ENUM_LOCAL_PRE_AUTHORIZE: // 必选 在线时是否无需等待中央系统授权即可本地启动交易 (布尔: 0=需要等待/1=无需等待) { if(operate_type == ENUM_TYPE_GET) // 获取值 { //bool类型键的获取值操作 operate_get_bool(private_config_data->u8_LocalPreAuthorize, value_mag, u16_len); ret = ENUM_RnW; //可读写 } else // 修改值 { //bool类型键的修改值操作 ret = operate_set_bool(&(private_config_data->u8_LocalPreAuthorize), value_mag, ocpp_key); } } break; case ENUM_STOP_TRANSACTION_ON_EV_SIDE_DISCONNECT: // 必选 EV端断开时是否自动停止交易 (布尔: 0=不自动停止/1=自动停止) { if(operate_type == ENUM_TYPE_GET) // 获取值 { //bool类型键的获取值操作 operate_get_bool(private_config_data->u8_StopTransactionOnEVSideDisconnect, value_mag, u16_len); ret = ENUM_RnW; //可读写 } else // 修改值 { //bool类型键的修改值操作 ret = operate_set_bool(&(private_config_data->u8_StopTransactionOnEVSideDisconnect), value_mag, ocpp_key); } } break; case ENUM_STOP_TRANSACTION_ON_INVALID_ID: // 必选 收到无效授权状态时是否停止当前交易 (布尔: 0=不停止/1=停止) { if(operate_type == ENUM_TYPE_GET) // 获取值 { //bool类型键的获取值操作 operate_get_bool(private_config_data->u8_StopTransactionOnInvalidId, value_mag, u16_len); ret = ENUM_RnW; //可读写 } else // 修改值 { //bool类型键的修改值操作 ret = operate_set_bool(&(private_config_data->u8_StopTransactionOnInvalidId), value_mag, ocpp_key); } } break; case ENUM_UNLOCK_CONNECTOR_ON_EV_SIDE_DISCONNECT: // 必选 EV端断开时是否解锁充电点侧连接器 (布尔: 0=不解锁/1=解锁) { if(operate_type == ENUM_TYPE_GET) // 获取值 { //bool类型键的获取值操作 operate_get_bool(private_config_data->u8_UnlockConnectorOnEVSideDisconnect, value_mag, u16_len); ret = ENUM_RnW; //可读写 } else // 修改值 { //bool类型键的修改值操作 ret = operate_set_bool(&(private_config_data->u8_UnlockConnectorOnEVSideDisconnect), value_mag, ocpp_key); } } break; case ENUM_LOCAL_AUTH_LIST_ENABLED: // 必选 是否启用本地授权列表 (布尔: 0=不启用/1=启用) { if(operate_type == ENUM_TYPE_GET) // 获取值 { //bool类型键的获取值操作 operate_get_bool(private_config_data->u8_LocalAuthListEnabled, value_mag, u16_len); ret = ENUM_RnW; //可读写 } else // 修改值 { //bool类型键的修改值操作 ret = operate_set_bool(&(private_config_data->u8_LocalAuthListEnabled), value_mag, ocpp_key); } } break; //////////////////////////////////////////////////////////////// //必选 integer类型 //////////////////////////////////////////////////////////////// case ENUM_CLOCK_ALIGNED_DATA_INTERVAL: // 必选 时钟对齐数据间隔 (整数: 秒) { if(operate_type == ENUM_TYPE_GET) //获取值 { //获取 赋值给value_mag res_data = private_config_data->u16_ClockAlignedDataInterval; //将整数转化为字符串并赋值给应答value memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%d" , res_data); ret = ENUM_RnW; //可读写 } else //修改值 { //integer类型键的修改值操作 ret = operate_set_integer(&(private_config_data->u16_ClockAlignedDataInterval), value_mag, ocpp_key); } } break; case ENUM_CONNECTION_TIME_OUT: // 必选 准备状态超时自动取消交易时间 (整数: 秒) { if(operate_type == ENUM_TYPE_GET) //获取值 { //获取 赋值给value_mag res_data = private_config_data->u16_ConnectionTimeOut; //将整数转化为字符串并赋值给应答value memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%d" , res_data); ret = ENUM_RnW; //可读写 } else //修改值 { //integer类型键的修改值操作 ret = operate_set_integer(&(private_config_data->u16_ConnectionTimeOut), value_mag, ocpp_key); } } break; case ENUM_GET_CONFIGURATION_MAX_KEYS: // 必选 单个GetConfiguration请求最大键数量 (整数: 个) { if(operate_type == ENUM_TYPE_GET) //获取值 { //获取 赋值给value_mag res_data = private_config_data->u16_GetConfigurationMaxKeys; //将整数转化为字符串并赋值给应答value memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%d" , res_data); ret = ENUM_R_Only; //只读 } else //修改值 { //只读键不支持修改 OCPP_CONFIG_PRINTF_LOG("RO keyId:%d, set NS\n",ocpp_key); ret = ENUM_NotSupported; } } break; case ENUM_HEARTBEAT_INTERVAL: // 必选 心跳间隔 (整数: 秒) { if(operate_type == ENUM_TYPE_GET) //获取值 { //获取 赋值给value_mag res_data = private_config_data->u16_HeartbeatInterval; //将整数转化为字符串并赋值给应答value memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%d" , res_data); ret = ENUM_RnW; //可读写 } else //修改值 { //integer类型键的修改值操作 ret = operate_set_integer(&(private_config_data->u16_HeartbeatInterval), value_mag, ocpp_key); } } break; case ENUM_METER_VALUE_SAMPLE_INTERVAL: // 必选 计量数据采样间隔 (整数: 秒) { if(operate_type == ENUM_TYPE_GET) //获取值 { //获取 赋值给value_mag res_data = private_config_data->u16_MeterValueSampleInterval; //将整数转化为字符串并赋值给应答value memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%d" , res_data); ret = ENUM_RnW; //可读写 } else //修改值 { //integer类型键的修改值操作 ret = operate_set_integer(&(private_config_data->u16_MeterValueSampleInterval), value_mag, ocpp_key); } } break; case ENUM_NUMBER_OF_CONNECTORS: // 必选 充电点物理连接器数量 (整数: 个) { if(operate_type == ENUM_TYPE_GET) //获取值 { //获取 赋值给value_mag res_data = private_config_data->u16_NumberOfConnectors; //将整数转化为字符串并赋值给应答value memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%d" , res_data); ret = ENUM_R_Only; //只读 } else //修改值 { //只读键不支持修改 OCPP_CONFIG_PRINTF_LOG("RO keyId:%d, set NS\n",ocpp_key); ret = ENUM_NotSupported; } } break; case ENUM_RESET_RETRIES: // 必选 充电点复位失败后重试次数 (整数: 次) { if(operate_type == ENUM_TYPE_GET) //获取值 { //获取 赋值给value_mag res_data = private_config_data->u16_ResetRetries; //将整数转化为字符串并赋值给应答value memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%d" , res_data); ret = ENUM_RnW; //可读写 } else //修改值 { //integer类型键的修改值操作 ret = operate_set_integer(&(private_config_data->u16_ResetRetries), value_mag, ocpp_key); } } break; case ENUM_TRANSACTION_MESSAGE_ATTEMPTS: // 必选 交易消息提交失败后重试次数 (整数: 次) { if(operate_type == ENUM_TYPE_GET) //获取值 { //获取 赋值给value_mag res_data = private_config_data->u16_TransactionMessageAttempts; //将整数转化为字符串并赋值给应答value memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%d" , res_data); ret = ENUM_RnW; //可读写 } else //修改值 { //integer类型键的修改值操作 ret = operate_set_integer(&(private_config_data->u16_TransactionMessageAttempts), value_mag, ocpp_key); } } break; case ENUM_TRANSACTION_MESSAGE_RETRY_INTERVAL: // 必选 交易消息重试间隔 (整数: 秒) { if(operate_type == ENUM_TYPE_GET) //获取值 { //获取 赋值给value_mag res_data = private_config_data->u16_TransactionMessageRetryInterval; //将整数转化为字符串并赋值给应答value memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%d" , res_data); ret = ENUM_RnW; //可读写 } else //修改值 { //integer类型键的修改值操作 ret = operate_set_integer(&(private_config_data->u16_TransactionMessageRetryInterval), value_mag, ocpp_key); } } break; case ENUM_LOCAL_AUTH_LIST_MAX_LENGTH: // 必选 本地授权列表最大存储条目数 (整数: 条) { if(operate_type == ENUM_TYPE_GET) //获取值 { //获取 赋值给value_mag res_data = private_config_data->u16_LocalAuthListMaxLength; //将整数转化为字符串并赋值给应答value memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%d" , res_data); ret = ENUM_R_Only; //只读 } else //修改值 { //只读键不支持修改 OCPP_CONFIG_PRINTF_LOG("RO keyId:%d, set NS\n",ocpp_key); ret = ENUM_NotSupported; } } break; case ENUM_SEND_LOCAL_LIST_MAX_LENGTH: // 必选 单个SendLocalList请求最大发送条目数 (整数: 条) { if(operate_type == ENUM_TYPE_GET) //获取值 { //获取 赋值给value_mag res_data = private_config_data->u16_SendLocalListMaxLength; //将整数转化为字符串并赋值给应答value memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%d" , res_data); ret = ENUM_R_Only; //只读 } else //修改值 { //只读键不支持修改 OCPP_CONFIG_PRINTF_LOG("RO keyId:%d, set NS\n",ocpp_key); ret = ENUM_NotSupported; } } break; case ENUM_CHARGE_PROFILE_MAX_STACK_LEVEL: // 必选 充电配置最大堆叠层级 (整数: 层) { if(operate_type == ENUM_TYPE_GET) //获取值 { //获取 赋值给value_mag res_data = private_config_data->u16_ChargeProfileMaxStackLevel; //将整数转化为字符串并赋值给应答value memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%d" , res_data); ret = ENUM_R_Only; //只读 } else //修改值 { //只读键不支持修改 OCPP_CONFIG_PRINTF_LOG("RO keyId:%d, set NS\n",ocpp_key); ret = ENUM_NotSupported; } } break; case ENUM_CHARGING_SCHEDULE_MAX_PERIODS: // 必选 单个充电计划最大时段数 (整数: 个) { if(operate_type == ENUM_TYPE_GET) //获取值 { //获取 赋值给value_mag res_data = private_config_data->u16_ChargingScheduleMaxPeriods; //将整数转化为字符串并赋值给应答value memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%d" , res_data); ret = ENUM_R_Only; //只读 } else //修改值 { //只读键不支持修改 OCPP_CONFIG_PRINTF_LOG("RO keyId:%d, set NS\n",ocpp_key); ret = ENUM_NotSupported; } } break; case ENUM_MAX_CHARGING_PROFILES_INSTALLED: // 必选 同时可安装的充电配置最大数量 (整数: 个) { if(operate_type == ENUM_TYPE_GET) //获取值 { //获取 赋值给value_mag res_data = private_config_data->u16_MaxChargingProfilesInstalled; //将整数转化为字符串并赋值给应答value memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%d" , res_data); ret = ENUM_R_Only; //只读 } else //修改值 { //只读键不支持修改 OCPP_CONFIG_PRINTF_LOG("RO keyId:%d, set NS\n",ocpp_key); ret = ENUM_NotSupported; } } break; //////////////////////////////////////////////////////////////// //必选 CSL类型 //////////////////////////////////////////////////////////////// case ENUM_CONNECTOR_PHASE_ROTATION: // 必选 停止事务时的采样数据项 (字符串: 逗号分隔的measurand值) { if(operate_type == ENUM_TYPE_GET) //获取值 { memset(value_mag , 0, u16_len); snprintf(value_mag, u16_len, "0.%s,1.%s,2.%s", phase_to_str(private_config_data->enum_ConnectorPhaseRotation[0]), phase_to_str(private_config_data->enum_ConnectorPhaseRotation[1]), phase_to_str(private_config_data->enum_ConnectorPhaseRotation[2])); ret = ENUM_RnW; //可读写 } else //修改值 { OCPP_CONNECTOR_PHASE phase_new[3] = {0}; if (parse_connector_phase_rotation(value_mag, phase_new, private_config_data->enum_ConnectorPhaseRotation)) { private_config_data->enum_ConnectorPhaseRotation[0] = phase_new[0]; private_config_data->enum_ConnectorPhaseRotation[1] = phase_new[1]; private_config_data->enum_ConnectorPhaseRotation[2] = phase_new[2]; ret = ENUM_Accepted; } else { OCPP_CONFIG_PRINTF_LOG("Set meter phase seq unsupported(%s), reject\n", value_mag); ret = ENUM_Rejected; } } } break; case ENUM_METER_VALUES_ALIGNED_DATA: // 必选 对齐数据上报的测量项列表 (字符串: 逗号分隔的measurand值) case ENUM_METER_VALUES_SAMPLED_DATA: // 必选 采样数据上报的测量项列表 (字符串: 逗号分隔的measurand值) case ENUM_STOP_TXN_ALIGNED_DATA: // 必选 事务停止时的对齐数据项 (字符串: 逗号分隔的measurand值) case ENUM_STOP_TXN_SAMPLED_DATA: // 必选 停止事务时的采样数据项 (字符串: 逗号分隔的measurand值) { //不同数据单元对应不同bit位 计算对应bit是哪一位 U8_T p_bit = 0; switch(ocpp_key) { case ENUM_METER_VALUES_ALIGNED_DATA: p_bit = 0; break; case ENUM_METER_VALUES_SAMPLED_DATA: p_bit = 1; break; case ENUM_STOP_TXN_ALIGNED_DATA: p_bit = 2; break; case ENUM_STOP_TXN_SAMPLED_DATA: p_bit = 3; break; default: break; } if(operate_type == ENUM_TYPE_GET) //获取值 { //遍历所有测量项 遇到需要的则拼接字符串 for(U8_T i = 0; i < ENUM_measurand_Num; i++) { //当前遍历到的测量项 需要包含在该数据单元 if(private_config_data->u8_MeterValuesMeasurandNeed[i] & (1 << p_bit)) { U16_T value_len = strlen(value_mag); //已拼接过字符串，从后面加逗号继续拼接 if(value_len) { snprintf(value_mag + value_len, u16_len - value_len , ",%s" , OCPP_measurand_str[i]); } else //第一次 直接赋值 { memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%s" , OCPP_measurand_str[i]); } } } ret = ENUM_RnW; //可读写 } else //修改值 { U16_T max_allowed = 0; if (ocpp_key == ENUM_METER_VALUES_SAMPLED_DATA) max_allowed = private_config_data->u16_MeterValuesSampledDataMaxLength; else if (ocpp_key == ENUM_METER_VALUES_ALIGNED_DATA) max_allowed = private_config_data->u16_MeterValuesAlignedDataMaxLength; else if (ocpp_key == ENUM_STOP_TXN_SAMPLED_DATA) max_allowed = private_config_data->u16_StopTxnSampledDataMaxLength; else if (ocpp_key == ENUM_STOP_TXN_ALIGNED_DATA) max_allowed = private_config_data->u16_StopTxnAlignedDataMaxLength; if (max_allowed > 0) { U16_T tok_cnt = meter_values_csl_count_nonempty_tokens(value_mag); if (tok_cnt > max_allowed) { OCPP_CONFIG_PRINTF_LOG("CSL key %d: measurand cnt %u > MaxLength %u, reject\n", ocpp_key, (unsigned)tok_cnt, (unsigned)max_allowed); ret = ENUM_Rejected; break; } } OCPP_CONFIG_PRINTF_LOG("Set cfg: ENUM_measurand_Num list:\n"); for (U8_T i = 0, str_find; i < ENUM_measurand_Num; i++) { str_find = meter_values_csl_has_token(value_mag, OCPP_measurand_str[i]) ? 1 : 0; private_config_data->u8_MeterValuesMeasurandNeed[i] &= ~(1 << p_bit); if (str_find) { private_config_data->u8_MeterValuesMeasurandNeed[i] |= (1 << p_bit); OCPP_CONFIG_PRINTF_LOG("%d, ", i); } } OCPP_CONFIG_PRINTF_LOG("\n"); } } break; case ENUM_SUPPORTED_FEATURE_PROFILES: // 必选 停止事务时的采样数据项 (字符串: 逗号分隔的measurand值) { if(operate_type == ENUM_TYPE_GET) //获取值 { //只读键 固定回复 memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%s" , "Core,FirmwareManagement,LocalAuthListManagement,Reservation,SmartCharging,RemoteTrigger"); ret = ENUM_R_Only; //只读 } else //修改值 { //只读键不支持修改 OCPP_CONFIG_PRINTF_LOG("RO keyId:%d, set NS\n",ocpp_key); ret = ENUM_NotSupported; } } break; case ENUM_CHARGING_SCHEDULE_ALLOWED_RATE_UNIT: // 必选 停止事务时的采样数据项 (字符串: 逗号分隔的measurand值) { if(operate_type == ENUM_TYPE_GET) //获取值 { //只读键 固定回复 memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%s" , "Power"); ret = ENUM_R_Only; //只读 } else //修改值 { //只读键不支持修改 OCPP_CONFIG_PRINTF_LOG("RO keyId:%d, set NS\n",ocpp_key); ret = ENUM_NotSupported; } } break; //////////////////////////////////////////////////// //可选 bool类型 //////////////////////////////////////////////////// case ENUM_ALLOW_OFFLINE_TX_FOR_UNKNOWN_ID: // 可选 是否允许未知ID用户离线启动交易 (布尔: 0=不允许/1=允许) { if(operate_type == ENUM_TYPE_GET) // 获取值 { //bool类型键的获取值操作 operate_get_bool(private_config_data->u8_AllowOfflineTxForUnknownId, value_mag, u16_len); ret = ENUM_RnW; //可读写 } else // 修改值 { //bool类型键的修改值操作 ret = operate_set_bool(&(private_config_data->u8_AllowOfflineTxForUnknownId), value_mag, ocpp_key); } } break; case ENUM_AUTHORIZATION_CACHE_ENABLED: // 可选 是否启用本地授权缓存 (布尔: 0=不启用/1=启用) { if(operate_type == ENUM_TYPE_GET) // 获取值 { //bool类型键的获取值操作 operate_get_bool(private_config_data->u8_AuthorizationCacheEnabled, value_mag, u16_len); ret = ENUM_RnW; //可读写 } else // 修改值 { //bool类型键的修改值操作 ret = operate_set_bool(&(private_config_data->u8_AuthorizationCacheEnabled), value_mag, ocpp_key); } } break; case ENUM_RESERVE_CONNECTOR_ZERO_SUPPORTED: // 可选 是否支持对0号连接器进行预约 (布尔: 0=不支持/1=支持) { if(operate_type == ENUM_TYPE_GET) // 获取值 { //bool类型键的获取值操作 operate_get_bool(private_config_data->u8_ReserveConnectorZeroSupported, value_mag, u16_len); ret = ENUM_R_Only; //只读 } else //修改值 { //只读键不支持修改 OCPP_CONFIG_PRINTF_LOG("RO keyId:%d, set NS\n",ocpp_key); ret = ENUM_NotSupported; } } break; case ENUM_CONNECTOR_SWITCH_3TO1_PHASE_SUPPORTED: // 可选 是否支持交易期间三相切单相充电 (布尔: 0=不支持/1=支持) { if(operate_type == ENUM_TYPE_GET) // 获取值 { //bool类型键的获取值操作 operate_get_bool(private_config_data->u8_ConnectorSwitch3to1PhaseSupported, value_mag, u16_len); ret = ENUM_R_Only; //只读 } else //修改值 { //只读键不支持修改 OCPP_CONFIG_PRINTF_LOG("RO keyId:%d, set NS\n",ocpp_key); ret = ENUM_NotSupported; } } break; //////////////////////////////////////////////////// //可选 integer类型 //////////////////////////////////////////////////// case ENUM_BLINK_REPEAT: // 可选 充电点指示灯闪烁次数 (整数: 次) { if(operate_type == ENUM_TYPE_GET) //获取值 { //获取 赋值给value_mag res_data = private_config_data->u16_BlinkRepeat; //将整数转化为字符串并赋值给应答value memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%d" , res_data); ret = ENUM_RnW; //可读写 } else //修改值 { //integer类型键的修改值操作 ret = operate_set_integer(&(private_config_data->u16_BlinkRepeat), value_mag, ocpp_key); } } break; case ENUM_CONNECTOR_PHASE_ROTATION_MAX_LENGTH: // 可选 相位旋转配置最大条目数 (整数: 条) { if(operate_type == ENUM_TYPE_GET) //获取值 { //获取 赋值给value_mag res_data = private_config_data->u16_ConnectorPhaseRotationMaxLength; //将整数转化为字符串并赋值给应答value memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%d" , res_data); ret = ENUM_R_Only; //只读 } else //修改值 { //只读键不支持修改 OCPP_CONFIG_PRINTF_LOG("RO keyId:%d, set NS\n",ocpp_key); ret = ENUM_NotSupported; } } break; case ENUM_LIGHT_INTENSITY: // 可选 充电点灯光亮度 (整数: 百分比) { if(operate_type == ENUM_TYPE_GET) //获取值 { //获取 赋值给value_mag res_data = private_config_data->u16_LightIntensity; //将整数转化为字符串并赋值给应答value memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%d" , res_data); ret = ENUM_RnW; //可读写 } else //修改值 { //integer类型键的修改值操作 ret = operate_set_integer(&(private_config_data->u16_LightIntensity), value_mag, ocpp_key); } } break; case ENUM_MAX_ENERGY_ON_INVALID_ID: // 可选 无效ID用户最大允许充电能量 (整数: Wh) { if(operate_type == ENUM_TYPE_GET) //获取值 { //获取 赋值给value_mag res_data = private_config_data->u16_MaxEnergyOnInvalidId; //将整数转化为字符串并赋值给应答value memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%d" , res_data); ret = ENUM_RnW; //可读写 } else //修改值 { //integer类型键的修改值操作 ret = operate_set_integer(&(private_config_data->u16_MaxEnergyOnInvalidId), value_mag, ocpp_key); } } break; case ENUM_METER_VALUES_ALIGNED_DATA_MAX_LENGTH: // 可选 时钟对齐计量项列表最大长度 (整数: 条) { if(operate_type == ENUM_TYPE_GET) //获取值 { res_data = private_config_data->u16_MeterValuesAlignedDataMaxLength; memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%d" , res_data); ret = ENUM_RnW; } else { ret = operate_set_integer(&(private_config_data->u16_MeterValuesAlignedDataMaxLength), value_mag, ocpp_key); if (ret == ENUM_Accepted) { if (private_config_data->u16_MeterValuesAlignedDataMaxLength > MeterValuesRequest_SV_NUM) private_config_data->u16_MeterValuesAlignedDataMaxLength = MeterValuesRequest_SV_NUM; if (private_config_data->u16_MeterValuesAlignedDataMaxLength == 0) private_config_data->u16_MeterValuesAlignedDataMaxLength = MeterValuesRequest_SV_NUM; } } } break; case ENUM_METER_VALUES_SAMPLED_DATA_MAX_LENGTH: // 可选 采样计量项列表最大长度 (整数: 条) { if(operate_type == ENUM_TYPE_GET) //获取值 { res_data = private_config_data->u16_MeterValuesSampledDataMaxLength; memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%d" , res_data); ret = ENUM_RnW; } else { ret = operate_set_integer(&(private_config_data->u16_MeterValuesSampledDataMaxLength), value_mag, ocpp_key); if (ret == ENUM_Accepted) { if (private_config_data->u16_MeterValuesSampledDataMaxLength > MeterValuesRequest_SV_NUM) private_config_data->u16_MeterValuesSampledDataMaxLength = MeterValuesRequest_SV_NUM; if (private_config_data->u16_MeterValuesSampledDataMaxLength == 0) private_config_data->u16_MeterValuesSampledDataMaxLength = MeterValuesRequest_SV_NUM; } } } break; case ENUM_MINIMUM_STATUS_DURATION: // 可选 状态稳定后发送通知的最短持续时间 (整数: 秒) { if(operate_type == ENUM_TYPE_GET) //获取值 { //获取 赋值给value_mag res_data = private_config_data->u16_MinimumStatusDuration; //将整数转化为字符串并赋值给应答value memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%d" , res_data); ret = ENUM_RnW; //可读写 } else //修改值 { //integer类型键的修改值操作 ret = operate_set_integer(&(private_config_data->u16_MinimumStatusDuration), value_mag, ocpp_key); } } break; case ENUM_STOP_TXN_ALIGNED_DATA_MAX_LENGTH: // 可选 交易停止时对齐计量项最大长度 (整数: 条) { if(operate_type == ENUM_TYPE_GET) //获取值 { //获取 赋值给value_mag res_data = private_config_data->u16_StopTxnAlignedDataMaxLength; //将整数转化为字符串并赋值给应答value memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%d" , res_data); ret = ENUM_R_Only; //只读 } else //修改值 { //只读键不支持修改 OCPP_CONFIG_PRINTF_LOG("RO keyId:%d, set NS\n",ocpp_key); ret = ENUM_NotSupported; } } break; case ENUM_STOP_TXN_SAMPLED_DATA_MAX_LENGTH: // 可选 交易停止时采样计量项最大长度 (整数: 条) { if(operate_type == ENUM_TYPE_GET) //获取值 { //获取 赋值给value_mag res_data = private_config_data->u16_StopTxnSampledDataMaxLength; //将整数转化为字符串并赋值给应答value memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%d" , res_data); ret = ENUM_R_Only; //只读 } else //修改值 { //只读键不支持修改 OCPP_CONFIG_PRINTF_LOG("RO keyId:%d, set NS\n",ocpp_key); ret = ENUM_NotSupported; } } break; case ENUM_SUPPORTED_FEATURE_PROFILES_MAX_LENGTH: // 可选 支持功能配置文件列表最大长度 (整数: 条) { if(operate_type == ENUM_TYPE_GET) //获取值 { //获取 赋值给value_mag res_data = private_config_data->u16_SupportedFeatureProfilesMaxLength; //将整数转化为字符串并赋值给应答value memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%d" , res_data); ret = ENUM_R_Only; //只读 } else //修改值 { //只读键不支持修改 OCPP_CONFIG_PRINTF_LOG("RO keyId:%d, set NS\n",ocpp_key); ret = ENUM_NotSupported; } } break; case ENUM_WEB_SOCKET_PING_INTERVAL: // 可选 WebSocket Ping间隔 (整数: 秒) { if(operate_type == ENUM_TYPE_GET) //获取值 { //获取 赋值给value_mag res_data = private_config_data->u16_WebSocketPingInterval; //将整数转化为字符串并赋值给应答value memset(value_mag , 0, u16_len); snprintf(value_mag , u16_len , "%d" , res_data); ret = ENUM_RnW; //可读写 } else //修改值 { //integer类型键的修改值操作 ret = operate_set_integer(&(private_config_data->u16_WebSocketPingInterval), value_mag, ocpp_key); } } break; // //私有 // case ENUM_QRCODE_TEXT_CONNECTOR1: // 私有 枪1二维码 { if(operate_type == ENUM_TYPE_GET) //获取值 { //将二维码字符串赋值给应答value snprintf(value_mag , NUM_64 , "%s" , private_config_data->QRCodeConnector1); ret = ENUM_RnW; //可读写 } else //修改值 { //将二维码字符串赋值 snprintf(private_config_data->QRCodeConnector1 , NUM_64 , "%s" , value_mag); ret = ENUM_Accepted; } } break; case ENUM_QRCODE_TEXT_CONNECTOR2: // 私有 枪2二维码 { if(operate_type == ENUM_TYPE_GET) //获取值 { //将二维码字符串赋值给应答value snprintf(value_mag , NUM_64 , "%s" , private_config_data->QRCodeConnector2); ret = ENUM_RnW; //可读写 } else //修改值 { //将二维码字符串赋值 snprintf(private_config_data->QRCodeConnector2 , NUM_64 , "%s" , value_mag); ret = ENUM_Accepted; } } break; default: break; } return ret; } /** * ************************************************************************ * @brief - OCPP flash 存储数据 写入 * * * * @author jiankalka * @date 2026-01-15 * ************************************************************************ */ void v_flash_save_ocpp_cfg_data(void) { U8_T u8_head[8],err; U16_T u16_len, u16_crc, i, j; U32_T u32_addr = DATAFLASH_OCPP_CFG_DATA_ADDR; u16_len = sizeof(S_OCPP_FLASH_CFG_DATA); //数据长度 u8_head[0] = 0x55; u8_head[1] = 0xAA; u8_head[2] = CFG_DATA_VERSION_H; u8_head[3] = CFG_DATA_VERSION_L; u8_head[4] = (U8_T)(u16_len >> 8); u8_head[5] = (U8_T)u16_len; s32_flash_dataflash_erase_sector(u32_addr); //清空扇区 mSleep(10); GetCurrentTime(&s_ocpp_flash_cfg_data.time); //获取当前时间 u16_crc = u16_crc_checksum((U8_T *)(&(s_ocpp_flash_cfg_data)), u16_len); u8_head[6] = (U8_T)(u16_crc >> 8); u8_head[7] = (U8_T)u16_crc; for (j=0; j<3; j++) //如果写失败，则重试3次 { if ((s32_flash_dataflash_write(u32_addr, u8_head, 8) != 0) || (s32_flash_dataflash_write(u32_addr+8, (U8_T *)(&(s_ocpp_flash_cfg_data)), u16_len) != 0)) { continue; } else { break; } } } S32_T s32_flash_read_ocpp_cfg_data(void) { U8_T u8_head[8],err; U16_T u16_len, i, j, k; U32_T u32_addr = DATAFLASH_OCPP_CFG_DATA_ADDR; u16_len = sizeof(S_OCPP_FLASH_CFG_DATA); for (i=0; i<3; i++) { if ((s32_flash_dataflash_read(u32_addr, u8_head, 8) == 0) && (s32_flash_dataflash_read(u32_addr+8, (U8_T *)(&(s_ocpp_flash_cfg_data)), u16_len) == 0)) { if ((u8_head[0] == 0x55) && (u8_head[1] == 0xAA) &&(u8_head[2] == CFG_DATA_VERSION_H) //版本相同 && (u8_head[3] == CFG_DATA_VERSION_L) && (u16_len == ((u8_head[4]<<8) | u8_head[5])) //长度相同 && (((u8_head[6]<<8) | u8_head[7]) == u16_crc_checksum((U8_T *)(&(s_ocpp_flash_cfg_data)), u16_len))) //CRC校验正确 { break; } } } if (i >= 3) //三份配置数据都没有读取成功，则退出 { return -1; } return 0; } void v_flash_ocpp_data_restore() { s_ocpp_flash_cfg_data.s_ocpp_charge_data.card_ver = 0; s_ocpp_flash_cfg_data.s_ocpp_charge_data.s8_ChangeAvailability[0] = 0; s_ocpp_flash_cfg_data.s_ocpp_charge_data.s8_ChangeAvailability[1] = 0; strncpy(s_ocpp_flash_cfg_data.s_ocpp_charge_data.chargePointVendor,"iECharge", sizeof(s_ocpp_flash_cfg_data.s_ocpp_charge_data.chargePointVendor)-1); // ------------------- 必选boolean类型（U8_T） ------------------- private_config_data->u8_AuthorizeRemoteTxRequests = 0; // 只读 远程启动交易是否需要预授权 private_config_data->u8_LocalAuthorizeOffline = 1; // ! 离线时是否允许本地授权启动交易 private_config_data->u8_LocalPreAuthorize = 0; // ！在线时是否无需等待中央系统授权即可本地启动交易 private_config_data->u8_StopTransactionOnEVSideDisconnect = 1; // - EV端断开时是否自动停止交易 private_config_data->u8_StopTransactionOnInvalidId = 1; // ! √ 收到无效授权状态时是否停止当前交易 private_config_data->u8_UnlockConnectorOnEVSideDisconnect = 0; // - EV端断开时是否解锁充电点侧连接器 private_config_data->u8_LocalAuthListEnabled = 1; // ! 是否启用本地授权列表 // ------------------- 必选integer类型（U16_T） ------------------- private_config_data->u16_ClockAlignedDataInterval = 0; // - 时钟对齐数据间隔（秒） private_config_data->u16_ConnectionTimeOut = 0; // - 准备状态超时自动取消交易时间（秒） private_config_data->u16_GetConfigurationMaxKeys = GetConfiguration_NUM;// 只读 单个GetConfiguration请求最大键数量 private_config_data->u16_HeartbeatInterval = 30; // ！ 心跳间隔（秒） private_config_data->u16_MeterValueSampleInterval = 30; // ! 计量数据采样间隔（秒） private_config_data->u16_NumberOfConnectors = g_t_share_data.t_sys_fix_cfg.u8_gunCnt; // 只读 充电点物理连接器数量 private_config_data->u16_ResetRetries = 0; // - 充电点复位失败后重试次数 private_config_data->u16_TransactionMessageAttempts = 0; // - 交易消息提交失败后重试次数 private_config_data->u16_TransactionMessageRetryInterval = 20; // - 交易消息重试间隔（秒） private_config_data->u16_LocalAuthListMaxLength = CARD_MAX_COUNT; // 只读 本地授权列表最大存储条目数 private_config_data->u16_SendLocalListMaxLength = 10; //只读 单个SendLocalList请求最大发送条目数 private_config_data->u16_ChargeProfileMaxStackLevel = 0; // - 充电配置最大堆叠层级 private_config_data->u16_ChargingScheduleMaxPeriods = 0; // - 单个充电计划最大时段数 private_config_data->u16_MaxChargingProfilesInstalled = 0; // - 同时可安装的充电配置最大数量 // ------------------- 必选CSL类型 ------------------------------- //OCPP_CONNECTOR_PHASE enum_ConnectorPhaseRotation[3]; //各枪电表的连接相序 0整桩 1枪A 2枪B private_config_data->enum_ConnectorPhaseRotation[0] = ENUM_NotApplicable; // 不适用（单相交流/直流充电桩，非三相场景） private_config_data->enum_ConnectorPhaseRotation[1] = ENUM_NotApplicable; private_config_data->enum_ConnectorPhaseRotation[2] = ENUM_NotApplicable; /*合并 MeterValuesAlignedData、 MeterValuesSampledData、 StopTxnAlignedData、 StopTxnSampledData MeterValues测量项在以上数据单元是否需要 bit 0 ：MeterValuesAlignedData是否需要 时钟定点上送 bit 1 ：MeterValuesSampledData是否需要 周期上送 bit 2 ：StopTxnAlignedData是否需要 时钟定点上送 bit 3 ：StopTxnSampledData是否需要 周期上送 */ // U8_T u8_MeterValuesMeasurandNeed[ENUM_measurand_Num]; // ! private_config_data->u8_MeterValuesMeasurandNeed[ENUM_EnergyActiveExportRegister ] = 0; // 有功电能输出累计值（Wh）- 设备向电网输出的总有功电能累计 private_config_data->u8_MeterValuesMeasurandNeed[ENUM_EnergyActiveImportRegister ] = E_CFG_MVMN_MeterValuesAlignedData | E_CFG_MVMN_MeterValuesSampledData; // 有功电能输入累计值（Wh）- 电网向设备输入的总有功电能累计 private_config_data->u8_MeterValuesMeasurandNeed[ENUM_EnergyReactiveExportRegister ] = 0; // 无功电能输出累计值（VARh）- 设备向电网输出的总无功电能累计 private_config_data->u8_MeterValuesMeasurandNeed[ENUM_EnergyReactiveImportRegister ] = 0; // 无功电能输入累计值（VARh）- 电网向设备输入的总无功电能累计 // ------------------- 能量时段值（Interval）- 文档7.31时段能量类 ------------------- private_config_data->u8_MeterValuesMeasurandNeed[ENUM_EnergyActiveExportInterval ] = 0; // 有功电能输出时段值（Wh）- 单个时钟对齐时段内输出的有功电能 private_config_data->u8_MeterValuesMeasurandNeed[ENUM_EnergyActiveImportInterval ] = 0; // 有功电能输入时段值（Wh）- 单个时钟对齐时段内输入的有功电能 private_config_data->u8_MeterValuesMeasurandNeed[ENUM_EnergyReactiveExportInterval ] = 0; // 无功电能输出时段值（VARh）- 单个时钟对齐时段内输出的无功电能 private_config_data->u8_MeterValuesMeasurandNeed[ENUM_EnergyReactiveImportInterval ] = 0; // 无功电能输入时段值（VARh）- 单个时钟对齐时段内输入的无功电能 // ------------------- 功率类 - 文档7.31功率计量类 ------------------- private_config_data->u8_MeterValuesMeasurandNeed[ENUM_PowerActiveExport ] = 0; // 有功功率输出（W）- 设备向电网输出的实时有功功率 private_config_data->u8_MeterValuesMeasurandNeed[ENUM_PowerActiveImport ] = E_CFG_MVMN_MeterValuesAlignedData | E_CFG_MVMN_MeterValuesSampledData; // 有功功率输入（W）- 电网向设备输入的实时有功功率 private_config_data->u8_MeterValuesMeasurandNeed[ENUM_PowerOffered ] = 0; // 提供的功率（W）- 充电桩可向EV提供的最大可用有功功率 private_config_data->u8_MeterValuesMeasurandNeed[ENUM_PowerReactiveExport ] = 0; // 无功功率输出（VAR）- 设备向电网输出的实时无功功率 private_config_data->u8_MeterValuesMeasurandNeed[ENUM_PowerReactiveImport ] = 0; // 无功功率输入（VAR）- 电网向设备输入的实时无功功率 private_config_data->u8_MeterValuesMeasurandNeed[ENUM_PowerFactor ] = 0; // 功率因数（无单位，0~1）- 实时有功功率与视在功率的比值 // ------------------- 电流类 - 文档7.31电流计量类 ------------------- private_config_data->u8_MeterValuesMeasurandNeed[ENUM_CurrentImport ] = E_CFG_MVMN_MeterValuesAlignedData | E_CFG_MVMN_MeterValuesSampledData; // 输入电流（A）- 电网向设备输入的实时电流 private_config_data->u8_MeterValuesMeasurandNeed[ENUM_CurrentExport ] = 0; // 输出电流（A）- 设备向电网输出的实时电流 private_config_data->u8_MeterValuesMeasurandNeed[ENUM_CurrentOffered ] = 0; // 提供的电流（A）- 充电桩可向EV提供的最大可用电流 // ------------------- 电气参数类 - 文档7.31基础电气参数 ------------------- private_config_data->u8_MeterValuesMeasurandNeed[ENUM_Voltage ] = E_CFG_MVMN_MeterValuesAlignedData | E_CFG_MVMN_MeterValuesSampledData; // 电压（V）- 充电桩输出端的实时线电压 private_config_data->u8_MeterValuesMeasurandNeed[ENUM_Frequency ] = 0; // 电网频率（Hz）- 接入电网的实时频率（50/60Hz） // ------------------- 物理/状态量类 - 文档7.31非电气计量项 ------------------- private_config_data->u8_MeterValuesMeasurandNeed[ENUM_Temperature ] = 0; // 温度（℃）- 充电桩/EV电池的实时温度（文档标注为℃/℉，默认℃） private_config_data->u8_MeterValuesMeasurandNeed[ENUM_SoC ] = E_CFG_MVMN_MeterValuesAlignedData | E_CFG_MVMN_MeterValuesSampledData | E_CFG_MVMN_StopTxnAlignedData | E_CFG_MVMN_StopTxnSampledData; // 电池剩余电量（%）- EV电池的State of Charge，0~100% private_config_data->u8_MeterValuesMeasurandNeed[ENUM_RPM ] = 0; // 转速（转/分钟）- 冷却风扇/泵等设备的实时转速 /*支持的功能配置文件列表 bit 0 ：Core（核心） 是否支持 bit 1 ：FirmwareManagement（固件管理） 是否支持 bit 2 ：LocalAuthListManagement（本地授权列表管理） 是否支持 bit 3 ：Reservation（预约） 是否支持 bit 4 ：SmartCharging（智能充电） 是否支持 bit 5 ：RemoteTrigger（远程触发） 是否支持 */ private_config_data->u8_SupportedFeatureProfiles = 0; // - 只读 默认获取时写死 /*充电调度支持的物理量列表 bit 0 ：'Current'（电流） 是否支持 bit 1 ：'Power'（功率） 是否支持 */ private_config_data->ChargingScheduleAllowedChargingRateUnit = 0; // - // ------------------- 可选boolean类型（U8_T：0=false，非0=true） ------------------- private_config_data->u8_AllowOfflineTxForUnknownId = 0; //！ 是否允许未知ID用户离线启动交易 -离线时直接启动不鉴权 private_config_data->u8_AuthorizationCacheEnabled = 0; //- 是否启用本地授权缓存 （一次充电成功自动在授权缓存保存ID） private_config_data->u8_ReserveConnectorZeroSupported = 0; //- 是否支持对0号连接器进行预约 private_config_data->u8_ConnectorSwitch3to1PhaseSupported = 0; //- 是否支持交易期间三相切单相充电 // ------------------- 可选integer类型（U16_T，单位见注释） ------------------- private_config_data->u16_BlinkRepeat = 0; //- 充电点指示灯闪烁次数 private_config_data->u16_ConnectorPhaseRotationMaxLength = 0; //- 相位旋转配置最大条目数（补充：可选核心项） private_config_data->u16_LightIntensity = 0; //- 充电点灯光亮度（百分比） private_config_data->u16_MaxEnergyOnInvalidId = 0; //- 无效ID用户最大允许充电能量（Wh） private_config_data->u16_MeterValuesAlignedDataMaxLength = 0; //- 时钟对齐计量项列表最大长度（可选） private_config_data->u16_MeterValuesSampledDataMaxLength = MeterValuesRequest_SV_NUM; //! 采样计量项列表最大长度（可选） private_config_data->u16_MinimumStatusDuration = 0; //- 状态稳定后发送通知的最短持续时间（秒） private_config_data->u16_StopTxnAlignedDataMaxLength = MeterValuesRequest_SV_NUM; //- 交易停止时对齐计量项最大长度（可选） private_config_data->u16_StopTxnSampledDataMaxLength = MeterValuesRequest_SV_NUM; //- 交易停止时采样计量项最大长度（可选） private_config_data->u16_SupportedFeatureProfilesMaxLength = 0; //- 支持功能配置文件列表最大长度（可选） private_config_data->u16_WebSocketPingInterval = 0; //- WebSocket Ping间隔（秒，0表示禁用） //------------------私有配置------------------------ strncpy(&private_config_data->QRCodeConnector1[0] ,&g_t_share_data.t_sys_var_cfg.QRDisplay[0][0], NUM_64); //√ strncpy(&private_config_data->QRCodeConnector2[0] ,&g_t_share_data.t_sys_var_cfg.QRDisplay[1][0], NUM_64); //√ v_flash_save_ocpp_cfg_data(); //保存参数到flash } static void v_ocpp_fix_legacy_meter_values_default(void) { U8_T sampled_energy = (private_config_data->u8_MeterValuesMeasurandNeed[ENUM_EnergyActiveImportRegister] & E_CFG_MVMN_MeterValuesSampledData) ? 1 : 0; U8_T sampled_power = (private_config_data->u8_MeterValuesMeasurandNeed[ENUM_PowerActiveImport] & E_CFG_MVMN_MeterValuesSampledData) ? 1 : 0; U8_T sampled_current = (private_config_data->u8_MeterValuesMeasurandNeed[ENUM_CurrentImport] & E_CFG_MVMN_MeterValuesSampledData) ? 1 : 0; U8_T sampled_voltage = (private_config_data->u8_MeterValuesMeasurandNeed[ENUM_Voltage] & E_CFG_MVMN_MeterValuesSampledData) ? 1 : 0; U8_T sampled_soc = (private_config_data->u8_MeterValuesMeasurandNeed[ENUM_SoC] & E_CFG_MVMN_MeterValuesSampledData) ? 1 : 0; // 兼容历史固件仅默认上送3项的情况：自动补齐Voltage和SoC if(sampled_energy && sampled_power && sampled_current && !sampled_voltage && !sampled_soc) { private_config_data->u8_MeterValuesMeasurandNeed[ENUM_Voltage] |= (E_CFG_MVMN_MeterValuesAlignedData | E_CFG_MVMN_MeterValuesSampledData); private_config_data->u8_MeterValuesMeasurandNeed[ENUM_SoC] |= (E_CFG_MVMN_MeterValuesAlignedData | E_CFG_MVMN_MeterValuesSampledData); v_flash_save_ocpp_cfg_data(); OCPP_CONFIG_PRINTF_LOG("Fix legacy MeterValues default: add Voltage,SoC\n"); } } /**************************************************** *函数名称： v_ocpp_init_config_data() *功能说明： 程序运行前 配置参数初始化 *参数说明： * 输入参数： * 输出参数： ****************************************************/ void v_ocpp_init_config_data() { memset(&s_ocpp_flash_cfg_data,0,sizeof(S_OCPP_FLASH_CFG_DATA)); private_config_data = &s_ocpp_flash_cfg_data.s_ocpp_config_data; //指针数据初始化 必选配置参数 //读可变配置参数 //v_flash_ocpp_data_restore();//默认使用初始化参数 if (s32_flash_read_ocpp_cfg_data() == -1) { v_flash_ocpp_data_restore(); printf("ocpp flash fail,read new\n"); } else { v_ocpp_fix_legacy_meter_values_default(); } } #endif