PowLu/BR_YKC
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Release:5.20灰测

Browse Source
This commit is contained in:
路淮
2026-05-21 10:01:28 +08:00
parent 8a5a32b139
commit fd65e9c6a2
68 changed files with 4329 additions and 1489 deletions
Download Patch File Download Diff File Expand all files Collapse all files

187
Core/User/Protocol/Ykc/charger_to_server.c Normal file
View File

@@ -0,0 +1,187 @@
/**
* @file charger_to_server.c
* @brief 充电桩通信协议处理模块 上行数据
* @details 处理充电桩与服务器之间的通信协议，包括登录验证、心跳请求、计费模型验证请求、
* 数据上报等功能。支持字节码格式的数据交互，通过串口协议与服务器通信。
* @date 2025-01-09 14:32:15
* @version 1.0.0
* @copyright Copyright (c) 2026
*/
#include "global.h"
#include "charger_to_server.h"
uint16_t pack_serial = 0;
// 充电桩登录认证
void charger_to_server_0X01(uint8_t stake_index)
{
PACK_DATA_0X01 data = {0};
ChargerPile *point = &g_charger_manager.charger_piles[stake_index - 1];
load_charger_serial(stake_index, data.charger_serial); // 加载充电桩序列号
data.charger_type = g_charger_manager.charger_piles[stake_index - 1].login_info.charger_type;
data.gun_num = g_charger_manager.charger_piles[stake_index - 1].login_info.gun_num;
data.protocol_ver = g_charger_manager.charger_piles[stake_index - 1].login_info.protocol_ver;
memcpy(data.software_ver, g_charger_manager.charger_piles[stake_index - 1].login_info.software_ver, 8);
data.net_conn_type = g_charger_manager.charger_piles[stake_index - 1].login_info.net_conn_type;
data.tele_factory = g_charger_manager.charger_piles[stake_index - 1].login_info.tele_factory;
memcpy(data.sim, g_charger_manager.charger_piles[stake_index - 1].login_info.sim, 10);
printf("北向：对电桩 %d 发送登录认证，序列号：%s\r\n", stake_index, data.charger_serial);
pack_and_send_server_data(FRAME_TYPE_0X01, (uint8_t *)&data, sizeof(PACK_DATA_0X01), stake_index);
}
void charger_to_server_0X03(uint8_t stake_index, uint8_t gun_index)
{
PACK_DATA_0X03 data = {0};
load_charger_serial(stake_index, data.charger_serial); // 加载充电桩序列号
data.gun_index = ((gun_index / 10) << 4) | (gun_index % 10);
data.gun_status = g_charger_manager.charger_piles[stake_index - 1].guns[gun_index - 1].heartbeat_status_data.gun_status;
printf("北向：对电桩 %d 发送心跳请求，枪号：%d，状态：%d\r\n", stake_index, gun_index, data.gun_status);
pack_and_send_server_data(FRAME_TYPE_0X03, (uint8_t *)&data, sizeof(PACK_DATA_0X03), stake_index);
}
// 计费模型验证请求
void charger_to_server_0X05(uint16_t num, uint8_t stake_index)
{
PACK_DATA_0X05 data = {0};
load_charger_serial(stake_index, data.charger_serial); // 加载充电桩序列号
data.fee_model_no = num;
printf("北向：对电桩 %d 计费模型验证请求，模型号：%d\r\n", stake_index, num);
pack_and_send_server_data(FRAME_TYPE_0X05, (uint8_t *)&data, sizeof(PACK_DATA_0X05), stake_index);
}
// 充电桩计费模型请求
void charger_to_server_0X09(uint8_t stake_index)
{
PACK_DATA_0X09 data = {0};
load_charger_serial(stake_index, data.charger_serial); // 加载充电桩序列号
printf("北向：对电桩 %d 计费模型请求，序列号：%s\r\n", stake_index, data.charger_serial);
pack_and_send_server_data(FRAME_TYPE_0X09, (uint8_t *)&data, sizeof(PACK_DATA_0X09), stake_index);
}
// 上传实时监测数据
void charger_to_server_0X13(uint8_t stake_index, uint8_t gun_index)
{
PACK_DATA_0X13 data = {0};
ChargerGun *gun = &g_charger_manager.charger_piles[stake_index - 1].guns[gun_index - 1]; // 获取枪指针
data = gun->real_time_data; // 复制结构体
// 覆盖需要重新加载的字段
load_charger_serial(stake_index, data.charger_serial);
load_trade_serial(stake_index, gun_index, data.trade_serial);
data.gun_index = ((gun_index / 10) << 4) | (gun_index % 10);
// 根据状态清零特定字段
if (data.status == 0x01 || data.status == 0x02 || data.status == 0x00)
{
memset(data.trade_serial, 0, sizeof(data.trade_serial));
data.out_voltage = 0;
data.out_current = 0;
data.charge_energy = 0;
data.charge_time = 0;
data.charge_money = 0;
data.hard_fault = 0;
}
pack_and_send_server_data(FRAME_TYPE_0X13, (uint8_t *)&data, sizeof(PACK_DATA_0X13), stake_index);
}
// 充电结束上报
void charger_to_server_0X19(uint8_t stake_index, uint8_t gun_index)
{
PACK_DATA_0X19 data = {0};
load_charger_serial(stake_index, data.charger_serial);
load_trade_serial(stake_index, gun_index, data.trade_serial);
pack_and_send_server_data(FRAME_TYPE_0X19, (uint8_t *)&data, sizeof(PACK_DATA_0X19), stake_index);
}
// 平台启动回复
void charger_to_server_0X33(uint8_t stake_index, uint8_t gun_index, uint8_t result, uint8_t err_code)
{
PACK_DATA_0X33 data = {0};
load_charger_serial(stake_index, data.charger_serial);
load_trade_serial(stake_index, gun_index, data.trade_serial);
data.gun_index = ((gun_index / 10) << 4) | (gun_index % 10);
data.result = result;
data.err_code = err_code;
printf(" └── 网关向云快充发送 [%s] 电桩 %d 枪 %d的平台启动回复，结果：%d，错误码：%d\r\n",result == 0 ? "error" : "success", stake_index, gun_index, result, err_code);
pack_and_send_server_data(FRAME_TYPE_0X33, (uint8_t *)&data, sizeof(PACK_DATA_0X33), stake_index);
}
// 平台停机回复
void charger_to_server_0X35(uint8_t stake_index, uint8_t gun_index, uint8_t result, uint8_t err_code)
{
PACK_DATA_0X35 data = {0};
load_charger_serial(stake_index, data.charger_serial);
data.gun_index = ((gun_index / 10) << 4) | (gun_index % 10);
data.result = result;
data.err_code = err_code;
printf("北向：对电桩 %d 的平台停机回复，结果：%d，错误码：%d\r\n", stake_index, result, err_code);
pack_and_send_server_data(FRAME_TYPE_0X35, (uint8_t *)&data, sizeof(PACK_DATA_0X35), stake_index);
}
// 上传交易记录
void charger_to_server_0X3B(uint8_t stake_index, uint8_t gun_index)
{
PACK_DATA_0X3B data = {0};
ChargerGun *gun = &g_charger_manager.charger_piles[stake_index - 1].guns[gun_index - 1];
load_charger_serial(stake_index, data.charger_serial); // 加载电桩编号
load_trade_serial(stake_index, gun_index, data.trade_serial); // 加载交易记录
data.gun_index = ((gun_index / 10) << 4) | (gun_index % 10); // 枪索引
memcpy(data.start_time, gun->fee_data.start_time, 7); // 充电开始时间戳
memcpy(data.end_time, gun->fee_data.end_time, 7); // 充电结束时间戳
data.shark_price = gun->fee_data.shark_price; // 尖单价
data.shark_energy = gun->fee_data.shark_energy; // 尖电量
data.loss_shark_energy = gun->fee_data.loss_shark_energy; // 尖损失电量
data.shark_money = gun->fee_data.shark_money; // 尖金额
data.peak_price = gun->fee_data.peak_price; // 峰单价
data.peak_energy = gun->fee_data.peak_energy; // 峰电量
data.loss_peak_energy = gun->fee_data.loss_peak_energy; // 峰损失电量
data.peak_money = gun->fee_data.peak_money; // 峰金额
data.flat_price = gun->fee_data.flat_price; // 平单价
data.flat_energy = gun->fee_data.flat_energy; // 平电量
data.loss_flat_energy = gun->fee_data.loss_flat_energy; // 平损失电量
data.flat_money = gun->fee_data.flat_money; // 平金额
data.valley_price = gun->fee_data.valley_price; // 谷单价
data.valley_energy = gun->fee_data.valley_energy; // 谷电量
data.loss_valley_energy = gun->fee_data.loss_valley_energy; // 谷损失电量
data.valley_money = gun->fee_data.valley_money; // 谷金额
memcpy(data.meter_start_value, gun->fee_data.meter_start_value, 4); // 电表充电开始值
memcpy(data.meter_end_value, gun->fee_data.meter_end_value, 4); // 电表充电结束值
data.total_energy = gun->fee_data.total_energy; // 充电电量
data.loss_total_energy = gun->fee_data.loss_total_energy; // 损失电量
data.consumption = gun->fee_data.consumption; // 金额
data.trade_flag = 0x01;
data.stop_reason = gun->fee_data.stop_reason; // 停机原因
memcpy(data.trade_time, gun->fee_data.trade_time, 7); // 交易时间
memcpy(data.vin, gun->fee_data.vin, 17); // VIN码
memcpy(data.phy_cardid, gun->fee_data.phy_cardid, 8); // 物理卡号
printf("========================================\r\n");
printf("北向：对电桩 %d 枪 %d 上传交易记录(0x3B)，电量：%.2f，金额：%.2f\r\n",
stake_index, gun_index, data.total_energy / 10000.0f, data.consumption / 10000.0f);
printf("\r\n========================================\r\n");
pack_and_send_server_data(FRAME_TYPE_0X3B, (uint8_t *)&data, sizeof(PACK_DATA_0X3B), stake_index);
}
// 计费模型主动更新回复
void charger_to_server_0x57(uint8_t stake_index)
{
PACK_DATA_0X57 data = {0};
load_charger_serial(stake_index, data.charger_serial);
data.result = 0x01;
printf("北向：对电桩 %d 的计费模型主动更新回复\r\n", stake_index);
pack_and_send_server_data(FRAME_TYPE_0X57, (uint8_t *)&data, sizeof(PACK_DATA_0X57), stake_index);
}

56
Core/User/Protocol/Ykc/charger_to_server.h Normal file
View File

@@ -0,0 +1,56 @@
#ifndef __CHARGER_TO_SERVER_H__
#define __CHARGER_TO_SERVER_H__
#include <stdint.h>
#include "server_common.h"
extern uint16_t pack_serial;
uint32_t get_current_rtc_sec();
//充电桩登录认证请求
extern void charger_to_server_0X01(uint8_t stake_index);
//充电桩心跳包
extern void charger_to_server_0X03(uint8_t stake_index,uint8_t gun_index);
//计费模型验证请求
extern void charger_to_server_0X05(uint16_t num,uint8_t stake_index);
//充电桩计费模型请求
extern void charger_to_server_0X09(uint8_t stake_index);
//上传实时监测数据
extern void charger_to_server_0X13(uint8_t stake_index,uint8_t gun_index);
// 充电结束
extern void charger_to_server_0X19(uint8_t stake_index,uint8_t gun_index);
// 报文被改为A5，A8
extern void charger_to_server_0X33(uint8_t stake_index,uint8_t gun_index, uint8_t result, uint8_t err_code);
extern void charger_to_server_0X35(uint8_t stake_index, uint8_t gun_index, uint8_t result, uint8_t err_code);
extern void charger_to_server_0X3B(uint8_t stake_index, uint8_t gun_index);
//余额更新应答
void charger_to_server_0X41(uint8_t * card_id, uint8_t result) ;
//对时设置应答
extern void charger_to_server_0X55(uint32_t time);
//计费模型应答
extern void charger_to_server_0X57(uint8_t stake_index);
extern uint8_t get_real_status_for_server(uint8_t idx);
//远程启机命令回复
extern void charger_to_server_0XA7(uint8_t gun_index,uint8_t start_result,uint8_t fail_reson);
//交易记录
void charger_to_server_0x3D(uint8_t gun_index,uint32_t card_id,uint8_t trade_flag,uint8_t stop_reason);
//远程重启应答
void charger_to_server_0X91(uint8_t result);
#endif

327
Core/User/Protocol/Ykc/server_common.c Normal file
View File

@@ -0,0 +1,327 @@
#if 1
#include "global.h"
#include "server_common.h"
#include "time.h"
#include <string.h>
uint8_t trade_serial[2][TRADE_SERIAL_LENGTH] = {0};
static FEE_MODEL current_setting_fee_model = {0};
typedef struct
{
uint32_t phy_num;
uint32_t logic_num;
} CARD_NUM;
static CARD_NUM card_num[2] = {0};
void set_card_phy_logic_num(uint8_t idx, uint8_t type, uint32_t num)
{
idx = idx - 1;
if (idx >= 2)
{
return;
}
if (type == 0)
{
card_num[idx].phy_num = num;
}
else if (type == 1)
{
card_num[idx].logic_num = num;
}
}
uint32_t get_card_phy_num(uint8_t idx)
{
idx = idx - 1;
if (idx >= 2)
{
return 0;
}
return card_num[idx].phy_num;
}
uint32_t get_card_logic_num(uint8_t idx)
{
if (idx >= 2)
{
return 0;
}
return card_num[idx].logic_num;
}
void load_charger_serial(uint8_t stake_mark, uint8_t *serial)
{
if (stake_mark > MAX_CHARGER_COUNT)
{
return;
}
memcpy(serial, g_charger_manager.charger_piles[stake_mark - 1].charger_serial, CHARGER_SERIAL_LENGTH);
}
void set_trade_serial(uint8_t stake_mark, uint8_t idx, uint8_t *serial)
{
if (stake_mark > MAX_CHARGER_COUNT)
{
return;
}
if (idx > MAX_GUN_PER_CHARGER)
{
return;
}
memcpy(g_charger_manager.charger_piles[stake_mark - 1].guns[idx - 1].real_time_data.trade_serial, serial, TRADE_SERIAL_LENGTH);
}
void load_trade_serial(uint8_t stake_mark, uint8_t idx, uint8_t *serial)
{
if (stake_mark > MAX_CHARGER_COUNT)
{
return;
}
if (idx > MAX_GUN_PER_CHARGER)
{
return;
}
memcpy(serial, g_charger_manager.charger_piles[stake_mark - 1].guns[idx - 1].real_time_data.trade_serial, TRADE_SERIAL_LENGTH);
}
uint8_t is_my_charger_serial(uint8_t stake_mark, uint8_t *serial)
{
uint8_t ret = 0;
if (!memcmp(&g_charger_manager.charger_piles[stake_mark - 1].login_info.charger_serial, serial, CHARGER_SERIAL_LENGTH))
{
ret = 1;
}
return ret;
}
// CRC 计算
const uint8_t gabyCRCHi[] =
{
0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0,
0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41,
0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0,
0x80, 0x41, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40,
0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1,
0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41,
0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1,
0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41,
0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0,
0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40,
0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1,
0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40,
0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0,
0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40,
0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0,
0x80, 0x41, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40,
0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0,
0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41,
0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0,
0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41,
0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0,
0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40,
0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1,
0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41,
0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0,
0x80, 0x41, 0x00, 0xc1, 0x81, 0x40};
const uint16_t gabyCRCLo[] =
{
0x00, 0xc0, 0xc1, 0x01, 0xc3, 0x03, 0x02, 0xc2, 0xc6, 0x06,
0x07, 0xc7, 0x05, 0xc5, 0xc4, 0x04, 0xcc, 0x0c, 0x0d, 0xcd,
0x0f, 0xcf, 0xce, 0x0e, 0x0a, 0xca, 0xcb, 0x0b, 0xc9, 0x09,
0x08, 0xc8, 0xd8, 0x18, 0x19, 0xd9, 0x1b, 0xdb, 0xda, 0x1a,
0x1e, 0xde, 0xdf, 0x1f, 0xdd, 0x1d, 0x1c, 0xdc, 0x14, 0xd4,
0xd5, 0x15, 0xd7, 0x17, 0x16, 0xd6, 0xd2, 0x12, 0x13, 0xd3,
0x11, 0xd1, 0xd0, 0x10, 0xf0, 0x30, 0x31, 0xf1, 0x33, 0xf3,
0xf2, 0x32, 0x36, 0xf6, 0xf7, 0x37, 0xf5, 0x35, 0x34, 0xf4,
0x3c, 0xfc, 0xfd, 0x3d, 0xff, 0x3f, 0x3e, 0xfe, 0xfa, 0x3a,
0x3b, 0xfb, 0x39, 0xf9, 0xf8, 0x38, 0x28, 0xe8, 0xe9, 0x29,
0xeb, 0x2b, 0x2a, 0xea, 0xee, 0x2e, 0x2f, 0xef, 0x2d, 0xed,
0xec, 0x2c, 0xe4, 0x24, 0x25, 0xe5, 0x27, 0xe7, 0xe6, 0x26,
0x22, 0xe2, 0xe3, 0x23, 0xe1, 0x21, 0x20, 0xe0, 0xa0, 0x60,
0x61, 0xa1, 0x63, 0xa3, 0xa2, 0x62, 0x66, 0xa6, 0xa7, 0x67,
0xa5, 0x65, 0x64, 0xa4, 0x6c, 0xac, 0xad, 0x6d, 0xaf, 0x6f,
0x6e, 0xae, 0xaa, 0x6a, 0x6b, 0xab, 0x69, 0xa9, 0xa8, 0x68,
0x78, 0xb8, 0xb9, 0x79, 0xbb, 0x7b, 0x7a, 0xba, 0xbe, 0x7e,
0x7f, 0xbf, 0x7d, 0xbd, 0xbc, 0x7c, 0xb4, 0x74, 0x75, 0xb5,
0x77, 0xb7, 0xb6, 0x76, 0x72, 0xb2, 0xb3, 0x73, 0xb1, 0x71,
0x70, 0xb0, 0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92,
0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9c, 0x5c,
0x5d, 0x9d, 0x5f, 0x9f, 0x9e, 0x5e, 0x5a, 0x9a, 0x9b, 0x5b,
0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89, 0x4b, 0x8b,
0x8a, 0x4a, 0x4e, 0x8e, 0x8f, 0x4f, 0x8d, 0x4d, 0x4c, 0x8c,
0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42,
0x43, 0x83, 0x41, 0x81, 0x80, 0x40};
uint16_t calc_crc16(uint8_t *pData, uint8_t len)
{
uint8_t byCRCHi = 0xff;
uint8_t byCRCLo = 0xff;
uint8_t byIdx;
uint16_t crc;
while (len--)
{
byIdx = byCRCHi ^ *pData++;
byCRCHi = byCRCLo ^ gabyCRCHi[byIdx];
byCRCLo = gabyCRCLo[byIdx];
}
crc = byCRCHi;
crc <<= 8;
crc += byCRCLo;
return crc;
}
uint8_t unpack_server_data(uint8_t *buf, uint8_t len, SERVER_PACK *pack)
{
uint8_t ret = 0;
uint16_t calc_crc = 0;
if (!buf || len < SERVER_PACK_MIN_LEN)
{
return ret;
}
if (buf[0] == SERVER_PACK_START_FLAG)
{
pack->start_flag = buf[0];
pack->len = buf[1];
pack->serial = buf[2] + (buf[3] << 8);
pack->encrypt_flag = buf[4];
pack->frame_type = buf[5];
if (pack->len > 4)
{
pack->data = &buf[6];
memcpy(pack->data, &buf[6], pack->len - 4);
}
pack->crc = (buf[len - 2] << 8) + buf[len - 1];
calc_crc = calc_crc16(&buf[2], pack->len);
if (pack->crc == calc_crc)
{
ret = 1;
}
}
return ret;
}
void pack_and_send_server_data(uint8_t type, uint8_t *pdata, uint8_t len, uint8_t stake_mark)
{
uint8_t index = 0;
uint16_t crc = 0;
uint16_t current_serial = 0;
uint8_t *buf = NULL;
buf = (uint8_t *)pvPortMalloc(len + 14);
if (!buf)
{
return;
}
/* 原子获取全局包序号，避免多任务竞争 */
taskENTER_CRITICAL();
current_serial = pack_serial;
pack_serial++;
taskEXIT_CRITICAL();
buf[index++] = 0x55;
buf[index++] = 0xAA;
buf[index++] = 0x01;
buf[index++] = stake_mark;
buf[index++] = SERVER_PACK_START_FLAG;
buf[index++] = len + 4;
buf[index++] = (current_serial >> 8) & 0xFF;
buf[index++] = current_serial & 0xFF;
buf[index++] = 0x00;
buf[index++] = type;
if ((len > 0) && (pdata))
{
memcpy(&buf[index], pdata, len);
}
index = index + len;
crc = calc_crc16(&buf[6], len + 4);
buf[index++] = crc & 0xFF;
buf[index++] = (crc >> 8) & 0xFF;
buf[index++] = 0xAA;
buf[index++] = 0x55;
if (type == FRAME_TYPE_0X3B)
{
printf("北向：0x3B 原始数据(%d字节): ", index);
for (uint16_t i = 0; i < index; i++)
printf("%02X ", buf[i]);
printf("\r\n");
}
Air724_Message_Send(buf, index);
vPortFree(buf);
}
int get_num_from_string(const char *str, int *num)
{
int len = strlen(str);
int index = 0;
int t = 0;
int flag = 0;
int i;
for (i = 0; i < len; i++)
{
flag = 0;
while ((str[i] >= '0' && str[i] <= '9') && (i < len))
{
t = str[i] - '0';
num[index] = num[index] * 10 + t;
i++;
flag = 1;
}
if (flag)
{
index++;
}
}
return index;
}
void get_cp56time_from_sec(uint8_t *buff, uint32_t sec)
{
struct tm timeinfo;
st_cp56time2a cp56time = {0};
time_t rawtime = sec;
localtime_r(&rawtime, &timeinfo);
cp56time.Compts.year = timeinfo.tm_year % 100; // 获取年份的最后两位数
cp56time.Compts.month = timeinfo.tm_mon + 1; // tm_mon是从0开始的，所以需要加1
cp56time.Compts.mday = timeinfo.tm_mday;
cp56time.Compts.hour = timeinfo.tm_hour;
cp56time.Compts.min = timeinfo.tm_min;
cp56time.Compts.msec = timeinfo.tm_sec * 1000;
buff[0] = cp56time.time & 0xFF;
buff[1] = (cp56time.time >> 8) & 0xFF;
buff[2] = (cp56time.time >> 16) & 0xFF;
buff[3] = (cp56time.time >> 24) & 0xFF;
buff[4] = (cp56time.time >> 32) & 0xFF;
buff[5] = (cp56time.time >> 40) & 0xFF;
buff[6] = (cp56time.time >> 48) & 0xFF;
}
void update_current_fee_model(FEE_MODEL *model)
{
if (!model)
{
return;
}
memcpy(&current_setting_fee_model, model, sizeof(FEE_MODEL));
}
FEE_MODEL *get_setting_fee_model(void)
{
return &current_setting_fee_model;
}
uint16_t htons(uint16_t val)
{
return (val << 8) | (val >> 8);
}
#endif

505
Core/User/Protocol/Ykc/server_common.h Normal file
View File

@@ -0,0 +1,505 @@
#ifndef __SERVER_COMMON_H__
#define __SERVER_COMMON_H__
#include <stdint.h>
#define SERVER_PACK_MAX_LEN 255
#define SERVER_PACK_MIN_LEN 8
#define SERVER_PACK_START_FLAG 0x68
#define CHARGER_SERIAL_LENGTH 7
#define TRADE_SERIAL_LENGTH 16
#define RSA_LENGTH 88
#define CHARGER_TYPE_DC 0
#define CHARGER_TYPE_AC 1
#define HEADER_LENGTH 6 // 消息体前的头部数据长度
#define FRAME_TYPE_0X01 0x01 // 充电桩登录认证
#define FRAME_TYPE_0X02 0x02
#define FRAME_TYPE_0X03 0x03 // 充电桩心跳包
#define FRAME_TYPE_0X04 0x04
#define FRAME_TYPE_0X05 0x05 // 计费模型验证请求
#define FRAME_TYPE_0X06 0x06
#define FRAME_TYPE_0X09 0x09 // 充电桩计费模型请求
#define FRAME_TYPE_0X0A 0x0A
#define FRAME_TYPE_0X12 0x12 // 读取实时监测数据
// charger ---> server
#define FRAME_TYPE_0X13 0x13 // 离线监测数据
#define FRAME_TYPE_0X15 0x15 // 充电握手
#define FRAME_TYPE_0X17 0x17 // 参数配置
#define FRAME_TYPE_0X19 0x19 // 充电结束
#define FRAME_TYPE_0X1B 0x1B // 错误报文
#define FRAME_TYPE_0X1D 0x1D // 充电阶段BMS中止
#define FRAME_TYPE_0X21 0x21 // 充电阶段充电机中止
#define FRAME_TYPE_0X23 0x23 // 充电过程BMS需求、充电机输出
#define FRAME_TYPE_0X25 0x25 // 充电过程BMS信息
//---------------------------------------
#define FRAME_TYPE_0X31 0x31 // 充电桩主动申请启动充电
#define FRAME_TYPE_0X32 0x32 // 运营平台确认启动充电
#define FRAME_TYPE_0X33 0x33 // 远程启动命令回复
#define FRAME_TYPE_0X34 0x34 // 运营平台远程控制启动
#define FRAME_TYPE_0X35 0x35 // 远程停机命令回复
#define FRAME_TYPE_0X36 0x36 // 运营平台远程停机
//---------------------------------------
#define FRAME_TYPE_0X3B 0x3B // 交易记录
#define FRAME_TYPE_0X40 0x40 // 交易记录确认
#define FRAME_TYPE_0X41 0x41 // 交易更新应答
#define FRAME_TYPE_0X42 0x42 // 远程账户余额更新
#define FRAME_TYPE_0X43 0x43 // 卡数据同步
#define FRAME_TYPE_0X44 0x44 // 离线卡数据同步
#define FRAME_TYPE_0X45 0x45 // 离线卡数据清除
#define FRAME_TYPE_0X46 0x46 // 离线卡数据清除应答
#define FRAME_TYPE_0X47 0x47 // 离线卡数据清除
#define FRAME_TYPE_0X48 0x48 // 离线卡数据清除应答
#define FRAME_TYPE_0X51 0x51 // 充电桩工作参数设置应答
#define FRAME_TYPE_0X52 0x52 // 充电桩工作参数设置
#define FRAME_TYPE_0X55 0x55 // 对时设置应答
#define FRAME_TYPE_0X56 0x56 // 对时设置
#define FRAME_TYPE_0X57 0x57 // 计费模型应答
#define FRAME_TYPE_0X58 0x58 // 计算模型设置
#define FRAME_TYPE_0X61 0x61 // 地锁数据上送
#define FRAME_TYPE_0X62 0x62 // 遥控地锁升锁与降锁
#define FRAME_TYPE_0X63 0x63 // 充电桩返回数据
#define FRAME_TYPE_0X91 0x91 // 远程启动应答
#define FRAME_TYPE_0X92 0x92 // 远程启动
#define FRAME_TYPE_0X93 0x93 // 远程更新应答
#define FRAME_TYPE_0X94 0x94 // 远程更新
#define FRAME_TYPE_0XA1 0xA1 // 充电桩主动申请并充充电
#define FRAME_TYPE_0XA2 0xA2 // 运营平台确认并充启动充电
#define FRAME_TYPE_0XA3 0xA3 // 远程并充启机命令回复
#define FRAME_TYPE_0XA4 0xA4 // 运营平台远程控制并充启机
#define FRAME_TYPE_0XA7 0xA7
#define FRAME_TYPE_0X91 0x91
#define FRAME_TYPE_0X92 0x92
#define FRAME_TYPE_MAX 0xFF
#define CAHRGE_START_MODE_APP 0x01
#define CAHRGE_START_MODE_CARD 0x02
#define CAHRGE_START_MODE_OFFLINE_CARD 0x04
#define CAHRGE_START_MODE_VIN 0x05
#define CAHRGE_START_MODE_IC_CARD 0xA0
#define CAHRGE_START_MODE_PASSWORD 0xA1
#define STOP_CHARGE_AS_APP 0x40
#define STOP_CHARGE_AS_FULL 0x41
#define STOP_CHARGE_AS_ENERGY_REACH 0x42
#define STOP_CHARGE_AS_MONEY_REACH 0x43
#define STOP_CHARGE_AS_TIME_REACH 0x44
#define STOP_CHARGE_AS_MANUAL 0x45
#define STOP_CHARGE_AS_NO_MONEY 0x6E
#define STOP_CHARGE_AS_EMERGY_STOP 0x72
#define STOP_CHARGE_AS_POWEROFF 0x83
typedef enum
{
STOP_REASON_APP = 0x40,
STOP_REASON_FULL = 0x41,
STOP_REASON_MANUAL = 0x45,
STOP_REASON_INSUFFICIENT_BALANCE = 0x6E,
STOP_REASON_EMERGENCY_STOP = 0x72,
STOP_REASON_OTHER // 其他原因可以添加在这里
} StopReason;
typedef struct
{
uint8_t start_flag;
uint8_t len;
uint16_t serial;
uint8_t encrypt_flag;
uint8_t frame_type;
uint8_t *data;
uint16_t crc;
} SERVER_PACK;
typedef struct
{
float voltage; // 电压 (单位: V)
float charge_energy; // 充电能量 (单位: kWh)
float current; // 电流 (单位: A)
unsigned long charge_time; // 充电时间 (单位: 秒)
float charge_money; // 充电费用 (单位: 元)
} CHARGING_GUN_CTRL;
typedef struct
{
uint16_t fee_model_no; // 计费模型编号
uint32_t shark_fee_ratio; // 尖费电费费率
uint32_t shark_service_ratio; // 尖服务费费率
uint32_t peak_fee_ratio; // 峰电费费率
uint32_t peak_service_ratio; // 峰服务费费率
uint32_t flat_fee_ratio; // 平电费费率
uint32_t flat_service_ratio; // 平服务费费率
uint32_t valley_fee_ratio; // 谷电费费率
uint32_t valley_service_ratio; // 谷服务费费率
uint8_t loss_ratio; // 计损比例
uint8_t fee_num[48]; // 0x00：尖费率 0x01：峰费率 0x02：平费率 0x03：谷费率
} __attribute__((packed)) FEE_MODEL;
typedef struct
{
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编码
uint8_t charger_type; // 桩类型,0--DC,1--AC
uint8_t gun_num; // 充电枪个数
uint8_t protocol_ver; // 协议版本
uint8_t software_ver[8]; // 程序版本
uint8_t net_conn_type; // 网络链接类型,0：SIM卡,1:LAN,2：WAN,03:others
uint8_t sim[10]; // SIM卡
uint8_t tele_factory; // 0x00,移动,02:电信,03:联通,04:其他
} __attribute__((packed)) PACK_DATA_0X01; // 0x01 充电桩登陆认证
typedef struct
{
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编码
uint8_t result; // 登陆结果
} __attribute__((packed)) PACK_DATA_0X02; // 0x02 充电桩登陆认证应答;
typedef struct
{
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编码
uint8_t gun_index; // 枪号
uint8_t gun_status; // 枪状态,0:正常,1:异常
} __attribute__((packed)) PACK_DATA_0X03; // 0x03
typedef struct
{
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编码
uint8_t gun_index; // 枪号
uint8_t ack; // 0
} __attribute__((packed)) PACK_DATA_0X04; // 0x04
typedef struct
{
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编码
uint16_t fee_model_no; // 计费模型编号
} __attribute__((packed)) PACK_DATA_0X05; // 05 计费模型验证请求
typedef struct
{
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编码
uint16_t fee_model_no; // 计费模型编号
uint8_t result; // 0x00 桩计费模型与平台一致,0x01 桩计费模型与平台不一致
} __attribute__((packed)) PACK_DATA_0X06; // 06 计费模型验证请求
typedef struct
{
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编码
} __attribute__((packed)) PACK_DATA_0X09; // 0x09 计费模型请求
typedef struct
{
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编码
FEE_MODEL model;
} __attribute__((packed)) PACK_DATA_0X0A; // 0x0A
typedef struct
{
uint8_t trade_serial[TRADE_SERIAL_LENGTH]; // 交易流水号
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编号
uint8_t gun_index; // 枪编号
uint8_t status; // 状态
uint8_t gun_back; // 枪是否归位
uint8_t gun_is_insert; // 是否插枪
uint16_t out_voltage; // 输出电压,小数点后一位,待机置0
uint16_t out_current; // 输出电流,小数点后一位,待机置0
uint8_t gun_line_temp; // 枪线温度
uint8_t gun_line_num[8]; // 枪线编码
uint8_t soc; // 待机置零；交流桩置零
uint8_t battery_temp; // 电池组最高温度.整形，偏移量-50 oC；待机置零；交流桩置零
uint16_t charge_time; // 累计充电时间
uint16_t remain_time; // 剩余时间
uint32_t charge_energy; // 充电度数
uint32_t loss_energy; // 计损充电度数
uint32_t charge_money; // 已充金额
uint16_t hard_fault; // 硬件故障
} __attribute__((packed)) PACK_DATA_0X13; // 0x13
typedef struct
{
uint8_t trade_serial[TRADE_SERIAL_LENGTH]; // 交易流水号
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编号
uint8_t gun_index; // 枪编号
uint8_t bms_soc; //
uint16_t bms_vol_low; //
uint16_t bms_vol_high;
uint8_t bms_temp_low; //
uint8_t bms_temp_high;
uint16_t charge_time; // 电桩累计充电时间
uint16_t out_energy; // 电桩输出能量
uint32_t charger_motor_no; // 充电桩电机编号
} __attribute__((packed)) PACK_DATA_0X19; // 0x19
typedef struct
{
uint8_t trade_serial[TRADE_SERIAL_LENGTH]; // 交易流水号
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编号
uint8_t gun_index; // 枪号
uint16_t bms_vol_demand; // BMS电压需求 0.1V/位
uint16_t bms_cur_demand; // BMS电流需求 0.1A/位, -400A偏移
uint8_t bms_charge_mode; // BMS充电模式 0x01:恒压 0x02:恒流
uint16_t bms_vol_measure; // BMS充电电压测量值 0.1V/位
uint16_t bms_cur_measure; // BMS充电电流测量值 0.1A/位, -400A偏移
uint16_t bms_max_cell_vol; // BMS最高单体电压及组号 低12位:0.01V/位 高4位:组号
uint8_t bms_soc; // BMS当前SOC 1%/位 0~100%
uint16_t bms_remain_time; // BMS估算剩余充电时间 1min/位 0~600min
uint16_t charger_vol_output; // 电桩电压输出值 0.1V/位
uint16_t charger_cur_output; // 电桩电流输出值 0.1A/位, -400A偏移
uint16_t charge_time; // 累计充电时间 1min/位 0~600min
} __attribute__((packed)) PACK_DATA_0X23; // 0x23
typedef struct
{
uint8_t trade_serial[TRADE_SERIAL_LENGTH]; // 交易流水号
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编号
uint8_t gun_index; // 枪号
uint8_t bms_max_cell_vol_num; // BMS最高单体电压所在编号 1/位,1偏移 1~256
uint8_t bms_max_temp; // BMS最高动力蓄电池温度 1°C/位,-50°C偏移
uint8_t max_temp_point_num; // 最高温度检测点编号 1/位,1偏移 1~128
uint8_t bms_min_temp; // 最低动力蓄电池温度 1°C/位,-50°C偏移
uint8_t min_temp_point_num; // 最低温度检测点编号 1/位,1偏移 1~128
uint8_t bms_alarm_1; // 位0-1:单体电压过高/过低 位2-3:SOC过高/过低 位4-5:充电过流 位6-7:温度过高 (<00>:正常 <01>:过高 <10>:过低)
uint8_t bms_alarm_2; // 位0-1:绝缘状态 位2-3:输出连接器状态 位4-5:充电禁止 位6-7:预留 (<00>:正常 <01>:异常 <10>:不可信)
} __attribute__((packed)) PACK_DATA_0X25; // 0x25
typedef struct
{
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编号
uint8_t gun_index; // 枪编号
uint8_t start_mode; // 启动方式,0x1刷卡启动,0x02,账号启动,0x03，VIN码启动
uint8_t password_flag; // 是否需要密码
uint8_t card_no[8]; // 账号或物理卡号
uint8_t password[16]; // 对用户输入的密码进行16位MD5加密,小写上传
uint8_t vin[17]; // VIN码,非VIN码方式为0
} __attribute__((packed)) PACK_DATA_0X31; // 0x31
typedef struct
{
uint8_t trade_serial[TRADE_SERIAL_LENGTH]; // 交易流水号
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编号
uint8_t gun_index; // 枪编号
uint8_t logic_card_no[8]; // 逻辑卡号
uint32_t remain_money; // 账户余额
uint8_t result; // 鉴权成功标志,0失败,1成功
uint8_t err_code; // 失败原因,0x01账户不存在,0x02账户冻结,0x03余额不足,0x04未结账记录,0x05桩停用
// 0x06账户不能在此桩充电,0x07密码错误,0x08电站电容不足,0x09VIN码不存在,
// 0x0A该桩存在未结账记录,0x0B该桩不支持刷卡
} __attribute__((packed)) PACK_DATA_0X32; // 0x32
typedef struct
{
uint8_t trade_serial[TRADE_SERIAL_LENGTH]; // 交易流水号
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编号
uint8_t gun_index; // 枪编号
uint8_t result; // 启动结果
uint8_t err_code; // 失败原因
} __attribute__((packed)) PACK_DATA_0X33; // 0x33
typedef struct
{
uint8_t trade_serial[TRADE_SERIAL_LENGTH]; // 交易流水号
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编号
uint8_t gun_index; // 枪编号
uint8_t logic_cardid[8]; // 逻辑卡号
uint8_t phy_cardid[8]; // 物理卡号
uint32_t remain_money; // 账户余额,0.01元
uint16_t max_power; // 最大功率
} __attribute__((packed)) PACK_DATA_0X34; // 0x34
typedef struct
{
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编号
uint8_t gun_index; // 枪编号
uint8_t result; // 停止结果,0x00失败 0x01成功
uint8_t err_code; // 失败原因,0x0无
} __attribute__((packed)) PACK_DATA_0X35; // 0x35
typedef struct
{
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编号
uint8_t gun_index; // 枪编号
} __attribute__((packed)) PACK_DATA_0X36; // 0x36
typedef struct
{
uint8_t trade_serial[TRADE_SERIAL_LENGTH]; // 交易流水号
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编号
uint8_t gun_index; // 枪编号
uint8_t start_time[7]; // 开始时间
uint8_t end_time[7]; // 结束时间
uint32_t shark_price; // 尖单价
uint32_t shark_energy; // 尖电量
uint32_t loss_shark_energy; // 计损尖电量
uint32_t shark_money; // 尖金额
uint32_t peak_price; // 峰单价
uint32_t peak_energy; // 峰电量
uint32_t loss_peak_energy; // 计损峰电量
uint32_t peak_money; // 峰金额
uint32_t flat_price; // 平单价
uint32_t flat_energy; // 平电量
uint32_t loss_flat_energy; // 计损平电量
uint32_t flat_money; // 平金额
uint32_t valley_price; // 谷单价
uint32_t valley_energy; // 谷电量
uint32_t loss_valley_energy; // 计损谷电量
uint32_t valley_money; // 谷金额
uint8_t meter_start_value[5];
uint8_t meter_end_value[5];
uint32_t total_energy; // 总电量
uint32_t loss_total_energy; // 计损总电量
uint32_t consumption; // 消费金额
uint8_t vin[17]; // 电动汽车唯一标识
uint8_t trade_flag; // 交易标识
uint8_t trade_time[7]; // 交易时间
uint8_t stop_reason; // 停止原因
uint8_t phy_cardid[8]; // 物理卡号
} __attribute__((packed)) PACK_DATA_0X3B; // 0x3B
typedef struct
{
uint8_t trade_serial[TRADE_SERIAL_LENGTH]; // 交易流水号
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编号
uint8_t gun_index; // 枪编号
uint8_t logical_card_number[8]; // 逻辑卡号
uint8_t physical_card_number[8]; // 物理卡号
uint8_t balance[4]; // 账户余额
uint8_t max_power[2]; // 最大功率
} __attribute__((packed)) PACK_DATA_0XA8;
typedef struct
{
uint8_t trade_serial[TRADE_SERIAL_LENGTH]; // 交易流水号
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编号
uint8_t gun_index; // 枪编号
uint8_t result[1];
uint8_t reson[1];
} __attribute__((packed)) PACK_DATA_0XA7;
typedef struct
{
uint8_t trade_serial[TRADE_SERIAL_LENGTH]; // 交易流水号
uint8_t result;
} __attribute__((packed)) PACK_DATA_0X40;
typedef struct
{
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编号
uint8_t phy_cardid[8]; // 物理卡号
uint8_t result; // 0:修改成功,1:设备编码错误,2:卡号错误
} __attribute__((packed)) PACK_DATA_0X41;
typedef struct
{
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编号
uint8_t gun_index; // 枪编号
uint8_t phy_cardid[8]; // 物理卡号
uint8_t remain_money[4]; // 修复后的余额
} __attribute__((packed)) PACK_DATA_0X42;
typedef struct
{
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编号
uint8_t current_time[7];
} __attribute__((packed)) PACK_DATA_0X55;
typedef struct
{
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编号
uint8_t current_time[7];
} __attribute__((packed)) PACK_DATA_0X56;
typedef struct
{
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编码
uint8_t result; // 设置结果
} __attribute__((packed)) PACK_DATA_0X57; // 0x57
typedef struct
{
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编码
FEE_MODEL model;
} __attribute__((packed)) PACK_DATA_0X58; // 0x58
typedef struct
{
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编码
uint8_t control_mode;
} __attribute__((packed)) PACK_DATA_0X92; // 0x92
typedef struct
{
uint8_t charger_serial[CHARGER_SERIAL_LENGTH]; // 桩编码
uint8_t result;
} __attribute__((packed)) PACK_DATA_0X91; // 0x91
#pragma pack(1)
typedef volatile union
{
uint64_t time; // 低7字节是七个八位位组二进制时间
struct
{
uint16_t msec;
uint8_t min : 6;
uint8_t res1 : 1;
uint8_t iv : 1;
uint8_t hour : 5;
uint8_t res2 : 2;
uint8_t su : 1;
uint8_t mday : 5;
uint8_t wday : 3;
uint8_t month : 4;
uint8_t res3 : 4;
uint8_t year : 7;
uint8_t res4 : 1;
} Compts;
} st_cp56time2a;
#pragma pack()
struct QueueItem
{
uint8_t *data;
uint16_t length;
};
extern void load_charger_serial(uint8_t stake_mark, uint8_t *serial);
extern void set_charger_serial_for_server(uint8_t value, uint8_t offset);
extern uint8_t is_my_charger_serial(uint8_t stake_mark, uint8_t *serial);
extern void load_trade_serial(uint8_t stake_mark, uint8_t idx, uint8_t *serial);
extern void set_trade_serial(uint8_t stake_mark, uint8_t idx, uint8_t *serial);
extern void increase_heart_beat_cnt(void);
extern void reset_heart_beat_cnt(void);
extern uint32_t get_heart_beat_cnt(void);
extern uint8_t unpack_server_data(uint8_t *buf, uint8_t len, SERVER_PACK *pack);
extern void pack_and_send_server_data(uint8_t type, uint8_t *data, uint8_t len, uint8_t stake_mark);
extern int get_num_from_string(const char *str, int *num);
extern uint32_t get_card_logic_num(uint8_t idx);
extern uint32_t get_card_phy_num(uint8_t idx);
extern void set_card_phy_logic_num(uint8_t idx, uint8_t type, uint32_t num);
extern void get_cp56time_from_sec(uint8_t *buff, uint32_t sec);
extern void update_current_fee_model(FEE_MODEL *model);
extern FEE_MODEL *get_setting_fee_model(void);
extern void generateTransactionID(uint8_t *buffer, uint16_t bufferSize, uint8_t gun_num);
extern void printLocalTime();
extern void sendFailureReasonToQueue(StopReason reason);
uint16_t htons(uint16_t val);
#endif

279
Core/User/Protocol/Ykc/server_to_charger.c Normal file
View File

@@ -0,0 +1,279 @@
/**
* @file server_to_charger.c
* @brief 充电桩通信协议处理模块 下行数据
* @details 处理充电桩与服务器之间的通信协议，包括登录认证应答、心跳应答、计费模型验证应答、
* 等功能。支持字节码格式的数据交互，通过串口协议与服务器通信。
* @date 2025-01-09 14:32:15
* @version 1.0.0
* @copyright Copyright (c) 2026
*/
#include "global.h"
#include "server_to_charger.h"
#include "point_protocol.h"
#include "host_computer_protocol.h"
// 登录认证应答
void on_cmd_frame_type_0X02(uint8_t stake_index, SERVER_PACK *pack)
{
PACK_DATA_0X02 data;
memcpy(&data, pack->data, sizeof(PACK_DATA_0X02));
if (is_my_charger_serial(stake_index, data.charger_serial))
{
if (data.result == 0)
{
g_charger_manager.charger_piles[stake_index - 1].is_online = 1;
#ifdef DEBUG
printf("北向：桩ID %d 登陆成功!\r\n", stake_index);
#endif
}
}
}
// 心跳应答
void on_cmd_frame_type_0X04(uint8_t stake_index, SERVER_PACK *pack)
{
PACK_DATA_0X04 data;
memcpy(&data, pack->data, sizeof(PACK_DATA_0X04));
#ifdef DEBUG
printf("北向：桩ID %d 收到心跳应答!\r\n", stake_index);
#endif
}
// 计费模型验证应答
void on_cmd_frame_type_0X06(uint8_t stake_index, SERVER_PACK *pack)
{
PACK_DATA_0X06 data;
memcpy(&data, pack->data, sizeof(PACK_DATA_0X06));
if (is_my_charger_serial(stake_index, data.charger_serial))
{
#ifdef DEBUG
printf("北向：接收到计费模型验证应答，模型ID：%d, 验证结果：%d\r\n", data.fee_model_no, data.result);
#endif
}
}
// 获取计费模型
void on_cmd_frame_type_0X0A(uint8_t stake_index, SERVER_PACK *pack)
{
PACK_DATA_0X0A data;
memcpy(&data, pack->data, sizeof(PACK_DATA_0X0A));
if (is_my_charger_serial(stake_index, data.charger_serial))
{
g_charger_manager.fee_model_global = data.model;
g_charger_manager.charger_piles[stake_index - 1].get_model = true;
#ifdef DEBUG
printf("北向：接收到计费模型应答,模型ID:%d\r\n", g_charger_manager.fee_model_global.fee_model_no);
printf("尖电费率:%d 服务费:%d\r\n", g_charger_manager.fee_model_global.shark_fee_ratio, g_charger_manager.fee_model_global.shark_service_ratio);
printf("峰电费率:%d 服务费:%d\r\n", g_charger_manager.fee_model_global.peak_fee_ratio, g_charger_manager.fee_model_global.peak_service_ratio);
printf("平电费率:%d 服务费:%d\r\n", g_charger_manager.fee_model_global.flat_fee_ratio, g_charger_manager.fee_model_global.flat_service_ratio);
printf("谷电费率:%d 服务费:%d\r\n", g_charger_manager.fee_model_global.valley_fee_ratio, g_charger_manager.fee_model_global.valley_service_ratio);
printf("计损比例: %d%% \r\n", g_charger_manager.fee_model_global.loss_ratio);
printf("\n合并后的费率时间段 :\r\n");
printf("================================================================\r\n");
int i = 0;
while (i < 48)
{
uint8_t current_type = g_charger_manager.fee_model_global.fee_num[i];
const char *fee_name;
switch (current_type)
{
case 0x00:
fee_name = " 尖时 ";
break;
case 0x01:
fee_name = " 峰时 ";
break;
case 0x02:
fee_name = " 平时 ";
break;
case 0x03:
fee_name = " 谷时 ";
break;
default:
fee_name = " 未知 ";
break;
}
// 起始时间（第 i 个半小时段）
int start_hour = i / 2;
int start_min = (i % 2) * 30;
// 向后查找连续相同费率的结束位置
int j = i;
while (j < 48 && g_charger_manager.fee_model_global.fee_num[j] == current_type)
{
j++;
}
// j 是第一个不等于 current_type 的位置，所以结束段是 j-1
int end_idx = j - 1;
int end_hour = (end_idx + 1) / 2; // 结束时间是 (end_idx+1) 对应的半小时起点
int end_min = ((end_idx + 1) % 2) * 30;
// 处理跨天：24:00 显示为 00:00
if (end_hour == 24)
{
end_hour = 0;
}
printf("%02d:%02d-%02d:%02d 为 %s 费率\r\n",
start_hour, start_min,
end_hour, end_min,
fee_name);
i = j; // 跳到下一个不同费率段
}
printf("================================================================\r\n");
#endif
}
}
void on_cmd_frame_type_0X58(uint8_t stake_index, SERVER_PACK *pack)
{
PACK_DATA_0X58 data;
memcpy(&data, pack->data, sizeof(PACK_DATA_0X58));
if (is_my_charger_serial(stake_index, data.charger_serial))
{
g_charger_manager.fee_model_global = data.model;
g_charger_manager.charger_piles[stake_index - 1].get_model = true;
#ifdef DEBUG
printf("北向：接收到计费模型应答,模型ID:%d\r\n", g_charger_manager.fee_model_global.fee_model_no);
printf("尖电费率:%d 服务费:%d\r\n", g_charger_manager.fee_model_global.shark_fee_ratio, g_charger_manager.fee_model_global.shark_service_ratio);
printf("峰电费率:%d 服务费:%d\r\n", g_charger_manager.fee_model_global.peak_fee_ratio, g_charger_manager.fee_model_global.peak_service_ratio);
printf("平电费率:%d 服务费:%d\r\n", g_charger_manager.fee_model_global.flat_fee_ratio, g_charger_manager.fee_model_global.flat_service_ratio);
printf("谷电费率:%d 服务费:%d\r\n", g_charger_manager.fee_model_global.valley_fee_ratio, g_charger_manager.fee_model_global.valley_service_ratio);
printf("计损比例: %d%% \r\n", g_charger_manager.fee_model_global.loss_ratio);
printf("\n合并后的费率时间段 :\r\n");
printf("================================================================\r\n");
int i = 0;
while (i < 48)
{
uint8_t current_type = g_charger_manager.fee_model_global.fee_num[i];
const char *fee_name;
switch (current_type)
{
case 0x00:
fee_name = " 尖时 ";
break;
case 0x01:
fee_name = " 峰时 ";
break;
case 0x02:
fee_name = " 平时 ";
break;
case 0x03:
fee_name = " 谷时 ";
break;
default:
fee_name = " 未知 ";
break;
}
// 起始时间（第 i 个半小时段）
int start_hour = i / 2;
int start_min = (i % 2) * 30;
// 向后查找连续相同费率的结束位置
int j = i;
while (j < 48 && g_charger_manager.fee_model_global.fee_num[j] == current_type)
{
j++;
}
// j 是第一个不等于 current_type 的位置，所以结束段是 j-1
int end_idx = j - 1;
int end_hour = (end_idx + 1) / 2; // 结束时间是 (end_idx+1) 对应的半小时起点
int end_min = ((end_idx + 1) % 2) * 30;
// 处理跨天：24:00 显示为 00:00
if (end_hour == 24)
{
end_hour = 0;
}
printf("%02d:%02d-%02d:%02d 为 %s 费率\r\n",
start_hour, start_min,
end_hour, end_min,
fee_name);
i = j; // 跳到下一个不同费率段
}
printf("================================================================\r\n");
#endif
charger_to_server_0x57(stake_index);
}
}
// 平台控制充电
void on_cmd_frame_type_0X34(uint8_t stake_index, SERVER_PACK *pack)
{
PACK_DATA_0X34 data;
uint8_t result = TRUE; // 默认启动结果成功
uint8_t err_code = 0; // 默认错误码为0
memcpy(&data, pack->data, sizeof(PACK_DATA_0X34));
set_trade_serial(stake_index, data.gun_index, data.trade_serial);
printf(" └── [info] 桩ID:%d, 枪ID:%d, 金额:%d\r\n", stake_index, data.gun_index, data.remain_money);
if (is_my_charger_serial(stake_index, data.charger_serial) == FALSE)
{
result = 0;
err_code = 0x1; // 桩编号不匹配
charger_to_server_0X33(stake_index, data.gun_index, result, err_code);
g_charger_manager.charger_piles[stake_index - 1].guns[data.gun_index - 1].charger_state = FAIL_CHARGER_STATE;
return;
}
point_send_start_charging(stake_index, data.gun_index);
g_charger_manager.charger_piles[stake_index - 1].guns[data.gun_index - 1].charger_state = REDAY_CHARGER_START_STATE;
printf(" └── [info] 等待桩启动回应...\r\n");
}
// 平台控制停止充电
void on_cmd_frame_type_0X36(uint8_t stake_index, SERVER_PACK *pack)
{
PACK_DATA_0X36 data;
uint8_t result = TRUE; // 默认停止结果成功
uint8_t err_code = 0; // 默认错误码为0
memcpy(&data, pack->data, sizeof(PACK_DATA_0X36));
printf("北向：平台控制停止充电,桩ID:%d, 枪ID:%d\r\n", stake_index, data.gun_index);
if (!is_my_charger_serial(stake_index, data.charger_serial))
{
result = 0;
err_code = 0x1; // 桩编号不匹配
}
else if (g_charger_manager.charger_piles[stake_index - 1].guns[data.gun_index - 1].real_time_data.status != 3)
{
result = 0;
err_code = 0x2; // 枪未在使用
}
charger_to_server_0X35(stake_index, data.gun_index, result, err_code);
point_send_stop_charging(stake_index, data.gun_index);
}
// 平台接收到交易记录
void on_cmd_frame_type_0X40(uint8_t stake_index, SERVER_PACK *pack)
{
PACK_DATA_0X40 data;
memcpy(&data, pack->data, sizeof(PACK_DATA_0X40));
printf("北向：平台接收到交易记录,桩ID:%d, 交易记录:%s\r\n", stake_index, data.trade_serial);
if (data.result == 0)
{
printf("1234567890987654324567898765434567890-98765165165165*************************************成功\r\n");
return;
}
}

16
Core/User/Protocol/Ykc/server_to_charger.h Normal file
View File

@@ -0,0 +1,16 @@
#ifndef __SERVER_TO_CHARGER_H__
#define __SERVER_TO_CHARGER_H__
#include <stdint.h>
#include "server_common.h"
void on_cmd_frame_type_0X02(uint8_t stake_index,SERVER_PACK *pack);
void on_cmd_frame_type_0X04(uint8_t stake_index,SERVER_PACK *pack);
void on_cmd_frame_type_0X0A(uint8_t stake_index,SERVER_PACK *pack);
void on_cmd_frame_type_0X06(uint8_t stake_index,SERVER_PACK *pack);
void on_cmd_frame_type_0X58(uint8_t stake_index,SERVER_PACK *pack);
void on_cmd_frame_type_0X34(uint8_t stake_index,SERVER_PACK *pack);
void on_cmd_frame_type_0X36(uint8_t stake_index,SERVER_PACK *pack);
void on_cmd_frame_type_0X40(uint8_t stake_index,SERVER_PACK *pack);
#endif

34
Core/User/Protocol/Ykc/ykc_router.c Normal file
View File

@@ -0,0 +1,34 @@
#include "ykc_router.h"
static const ykc_route_entry_t YKC_ROUTE_TABLE[] = {
{FRAME_TYPE_0X02, on_cmd_frame_type_0X02, " 登录认证应答 "},
{FRAME_TYPE_0X04, on_cmd_frame_type_0X04, " 心跳应答 "},
{FRAME_TYPE_0X06, on_cmd_frame_type_0X06, " 计费模型验证应答 "},
{FRAME_TYPE_0X0A, on_cmd_frame_type_0X0A, " 获取计费模型 "},
{FRAME_TYPE_0X58, on_cmd_frame_type_0X58, " 计费模型设置 "},
{FRAME_TYPE_0X34, on_cmd_frame_type_0X34, " 平台启动充电 "},
{FRAME_TYPE_0X36, on_cmd_frame_type_0X36, " 平台控制停止充电 "},
{FRAME_TYPE_0X40, on_cmd_frame_type_0X40, " 平台接收到交易记录 "},
};
#define YKC_ROUTE_TABLE_SIZE (sizeof(YKC_ROUTE_TABLE) / sizeof(YKC_ROUTE_TABLE[0]))
void ykc_route_dispatch(uint8_t stake_mark, SERVER_PACK *pack)
{
if (!pack)
return;
for (size_t i = 0; i < YKC_ROUTE_TABLE_SIZE; i++)
{
if (pack->frame_type == YKC_ROUTE_TABLE[i].frame_type)
{
printf("[YKC Router] frame=0x%02X │ stake=%d │ %s\r\n",
pack->frame_type, stake_mark, YKC_ROUTE_TABLE[i].desc);
YKC_ROUTE_TABLE[i].handler(stake_mark, pack);
return;
}
}
printf("[YKC Router] 未知帧类型: 0x%02X from stake %d\r\n",
pack->frame_type, stake_mark);
}

19
Core/User/Protocol/Ykc/ykc_router.h Normal file
View File

@@ -0,0 +1,19 @@
#ifndef __YKC_ROUTER_H
#define __YKC_ROUTER_H
#include "global.h"
#include "server_common.h"
#include "server_to_charger.h"
typedef void (*ykc_handler_t)(uint8_t stake_index, SERVER_PACK *pack);
typedef struct
{
uint8_t frame_type; /* 帧类型（匹配键） */
ykc_handler_t handler; /* 处理函数 */
const char *desc; /* 描述（日志用） */
} ykc_route_entry_t;
void ykc_route_dispatch(uint8_t stake_mark, SERVER_PACK *pack);
#endif