zhangwen/front_linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add interface

Browse Source
This commit is contained in:
lnk
2026-04-01 15:30:52 +08:00
parent 15cbbd1c24
commit b11105f91c
5 changed files with 485 additions and 169 deletions
Download Patch File Download Diff File Expand all files Collapse all files

263
LFtid1056/cloudfront/code/rocketmq.cpp
View File

@@ -2083,7 +2083,7 @@ bool parseJsonMessageCLOUD(const std::string &body,
std::cerr << "[parseJsonMessageCLOUD] 'messageBody' is missing or is not a string\n";
guid.clear();
devid.clear();
front_ip.clear();
front_id.clear();
node = 0;
detailObj = nlohmann::json::object();
return false;
@@ -2094,7 +2094,7 @@ bool parseJsonMessageCLOUD(const std::string &body,
std::cerr << "[parseJsonMessageCLOUD] 'messageBody' is empty\n";
guid.clear();
devid.clear();
front_ip.clear();
front_id.clear();
node = 0;
detailObj = nlohmann::json::object();
return false;
@@ -2112,9 +2112,9 @@ bool parseJsonMessageCLOUD(const std::string &body,
// FrontId
if (j.contains("FrontId") && j["FrontId"].is_string()) {
front_ip = j["FrontId"].get<std::string>();
front_id = j["FrontId"].get<std::string>();
} else {
front_ip.clear();
front_id.clear();
}
// Node
@@ -2154,7 +2154,7 @@ bool parseJsonMessageCLOUD(const std::string &body,
std::cerr << "[parseJsonMessageCLOUD] JSON parse error: " << e.what() << "\n";
guid.clear();
devid.clear();
front_ip.clear();
front_id.clear();
node = 0;
detailObj = nlohmann::json::object();
return false;
@@ -2222,10 +2222,23 @@ bool parsemsg(const std::string& devid, const std::string& guid, const nlohmann:
try {
switch (parsed.type) {
case 1101: { // 读取目录
if(!recordguid(devid,guid,static_cast<int>(DeviceState::READING_FILEMENU),1)){
int ret = recordguid(devid,guid,static_cast<int>(DeviceState::READING_FILEMENU),1);
if(-1 == ret){ //0记录成功往下执行，1装置正忙，-1未找到装置
send_reply_to_queue(guid, static_cast<int>(ResponseCode::NOT_FOUND), //响应
"未找到该装置，读取目录指令执行失败");
DIY_ERRORLOG_CODE(devid,1,LOG_CODE_CLOUD, "未找到该装置，读取目录指令执行失败"); //日志记录
return true;
}
else if(ret > 0){
send_reply_to_queue(guid, static_cast<int>(ResponseCode::BUSY),
"该装置正忙，读取目录指令执行失败");
DIY_WARNLOG_CODE(devid,1,LOG_CODE_CLOUD, "该装置正忙，读取目录指令执行失败");
return true;
}
else{
std::cout << "记录装置状态成功，准备读取目录" << std::endl; //调试输出
DIY_INFOLOG_CODE(devid,1,LOG_CODE_CLOUD, "记录装置状态成功，准备读取目录");
}
if (!msgObj.contains("Name") || !msgObj["Name"].is_string()) return false;
parsed.name = msgObj["Name"].get<std::string>();
@@ -2240,8 +2253,24 @@ bool parsemsg(const std::string& devid, const std::string& guid, const nlohmann:
case 1102: { // 下载文件
if(!recordguid(devid,guid,static_cast<int>(DeviceState::READING_FILEDATA),1)){
return true;
{
int ret = recordguid(devid, guid, static_cast<int>(DeviceState::READING_FILEDATA), 1);
if (-1 == ret) {
send_reply_to_queue(guid, static_cast<int>(ResponseCode::NOT_FOUND),
"未找到该装置，下载文件指令执行失败");
DIY_ERRORLOG_CODE(devid, 1, LOG_CODE_CLOUD, "未找到该装置，下载文件指令执行失败");
return true;
}
else if (ret > 0) {
send_reply_to_queue(guid, static_cast<int>(ResponseCode::BUSY),
"该装置正忙，下载文件指令执行失败");
DIY_WARNLOG_CODE(devid, 1, LOG_CODE_CLOUD, "该装置正忙，下载文件指令执行失败");
return true;
}
else {
std::cout << "记录装置状态成功，准备下载文件" << std::endl;
DIY_INFOLOG_CODE(devid, 1, LOG_CODE_CLOUD, "记录装置状态成功，准备下载文件");
}
}
if (!msgObj.contains("Name") || !msgObj["Name"].is_string()) return false;
@@ -2276,7 +2305,7 @@ bool parsemsg(const std::string& devid, const std::string& guid, const nlohmann:
parsed.dataArray_us.clear();
switch (parsed.datatype) {
case 0x0C: { // 定值（float 阵列）
case 1: { // 定值（float 阵列）
for (const auto& v : msgObj["DataArray"]) {
if (!v.is_number()) return false;
@@ -2285,7 +2314,7 @@ bool parsemsg(const std::string& devid, const std::string& guid, const nlohmann:
}
// 打印 DataArray
std::cout << "[0x0C] DataArray=[";
std::cout << "[1] DataArray=[";
for (size_t i = 0; i < parsed.dataArray_f.size(); ++i) {
std::cout << parsed.dataArray_f[i] << (i + 1 < parsed.dataArray_f.size() ? ", " : "");
}
@@ -2297,8 +2326,24 @@ bool parsemsg(const std::string& devid, const std::string& guid, const nlohmann:
switch (parsed.operate) {
case 1: { // 读
if(!recordguid(devid,guid,static_cast<int>(DeviceState::READING_FIXEDVALUE),2)){
return true;
{
int ret = recordguid(devid, guid, static_cast<int>(DeviceState::READING_FIXEDVALUE), 2);
if (-1 == ret) {
send_reply_to_queue(guid, static_cast<int>(ResponseCode::NOT_FOUND),
"未找到该装置，读取定值指令执行失败");
DIY_ERRORLOG_CODE(devid, 1, LOG_CODE_CLOUD, "未找到该装置，读取定值指令执行失败");
return true;
}
else if (ret > 0) {
send_reply_to_queue(guid, static_cast<int>(ResponseCode::BUSY),
"该装置正忙，读取定值指令执行失败");
DIY_WARNLOG_CODE(devid, 1, LOG_CODE_CLOUD, "该装置正忙，读取定值指令执行失败");
return true;
}
else {
std::cout << "记录装置状态成功，准备读取定值" << std::endl;
DIY_INFOLOG_CODE(devid, 1, LOG_CODE_CLOUD, "记录装置状态成功，准备读取定值");
}
}
ClientManager::instance().get_fixedvalue_action_to_device(
@@ -2308,8 +2353,24 @@ bool parsemsg(const std::string& devid, const std::string& guid, const nlohmann:
}
case 2: { // 写
if(!recordguid(devid,guid,static_cast<int>(DeviceState::SET_FIXEDVALUE),1)){
return true;
{
int ret = recordguid(devid, guid, static_cast<int>(DeviceState::SET_FIXEDVALUE), 1);
if (-1 == ret) {
send_reply_to_queue(guid, static_cast<int>(ResponseCode::NOT_FOUND),
"未找到该装置，写定值指令执行失败");
DIY_ERRORLOG_CODE(devid, 1, LOG_CODE_CLOUD, "未找到该装置，写定值指令执行失败");
return true;
}
else if (ret > 0) {
send_reply_to_queue(guid, static_cast<int>(ResponseCode::BUSY),
"该装置正忙，写定值指令执行失败");
DIY_WARNLOG_CODE(devid, 1, LOG_CODE_CLOUD, "该装置正忙，写定值指令执行失败");
return true;
}
else {
std::cout << "记录装置状态成功，准备写定值" << std::endl;
DIY_INFOLOG_CODE(devid, 1, LOG_CODE_CLOUD, "记录装置状态成功，准备写定值");
}
}
ClientManager::instance().set_fixedvalue_action_to_device(
@@ -2322,7 +2383,7 @@ bool parsemsg(const std::string& devid, const std::string& guid, const nlohmann:
break;
}
case 0x0D: { // 内部定值（uint16_t 阵列）
case 2: { // 内部定值（uint16_t 阵列）
for (const auto& v : msgObj["DataArray"]) {
if (!v.is_number_integer() && !v.is_number_unsigned()) return false;
// 范围校验 [0, 65535]
@@ -2332,7 +2393,7 @@ bool parsemsg(const std::string& devid, const std::string& guid, const nlohmann:
}
// 打印 DataArray
std::cout << "[0x0D] DataArray=[";
std::cout << "[2] DataArray=[";
for (size_t i = 0; i < parsed.dataArray_us.size(); ++i) {
std::cout << parsed.dataArray_us[i] << (i + 1 < parsed.dataArray_us.size() ? ", " : "");
}
@@ -2344,8 +2405,24 @@ bool parsemsg(const std::string& devid, const std::string& guid, const nlohmann:
switch (parsed.operate) {
case 1: { // 读
if(!recordguid(devid,guid,static_cast<int>(DeviceState::READING_INTERFIXEDVALUE),3)){
return true;
{
int ret = recordguid(devid, guid, static_cast<int>(DeviceState::READING_INTERFIXEDVALUE), 3);
if (-1 == ret) {
send_reply_to_queue(guid, static_cast<int>(ResponseCode::NOT_FOUND),
"未找到该装置，读取内部定值指令执行失败");
DIY_ERRORLOG_CODE(devid, 1, LOG_CODE_CLOUD, "未找到该装置，读取内部定值指令执行失败");
return true;
}
else if (ret > 0) {
send_reply_to_queue(guid, static_cast<int>(ResponseCode::BUSY),
"该装置正忙，读取内部定值指令执行失败");
DIY_WARNLOG_CODE(devid, 1, LOG_CODE_CLOUD, "该装置正忙，读取内部定值指令执行失败");
return true;
}
else {
std::cout << "记录装置状态成功，准备读取内部定值" << std::endl;
DIY_INFOLOG_CODE(devid, 1, LOG_CODE_CLOUD, "记录装置状态成功，准备读取内部定值");
}
}
ClientManager::instance().get_interfixedvalue_action_to_device(devid); // 获取内部定值
@@ -2355,8 +2432,24 @@ bool parsemsg(const std::string& devid, const std::string& guid, const nlohmann:
}
case 2: { // 写
if(!recordguid(devid,guid,static_cast<int>(DeviceState::SET_INTERFIXEDVALUE),1)){
return true;
{
int ret = recordguid(devid, guid, static_cast<int>(DeviceState::SET_INTERFIXEDVALUE), 1);
if (-1 == ret) {
send_reply_to_queue(guid, static_cast<int>(ResponseCode::NOT_FOUND),
"未找到该装置，写内部定值指令执行失败");
DIY_ERRORLOG_CODE(devid, 1, LOG_CODE_CLOUD, "未找到该装置，写内部定值指令执行失败");
return true;
}
else if (ret > 0) {
send_reply_to_queue(guid, static_cast<int>(ResponseCode::BUSY),
"该装置正忙，写内部定值指令执行失败");
DIY_WARNLOG_CODE(devid, 1, LOG_CODE_CLOUD, "该装置正忙，写内部定值指令执行失败");
return true;
}
else {
std::cout << "记录装置状态成功，准备写内部定值" << std::endl;
DIY_INFOLOG_CODE(devid, 1, LOG_CODE_CLOUD, "记录装置状态成功，准备写内部定值");
}
}
ClientManager::instance().set_interfixedvalue_action_to_device(devid, parsed.dataArray_us);
@@ -2384,8 +2477,24 @@ bool parsemsg(const std::string& devid, const std::string& guid, const nlohmann:
<< ", guid=" << guid << std::endl;
//
if (!recordguid(devid, guid, static_cast<int>(DeviceState::READING_RUNNINGINFORMATION_1), 1)) {
return true;
{
int ret = recordguid(devid, guid, static_cast<int>(DeviceState::READING_RUNNINGINFORMATION_1), 1);
if (-1 == ret) {
send_reply_to_queue(guid, static_cast<int>(ResponseCode::NOT_FOUND),
"未找到该装置，读取运行状态指令执行失败");
DIY_ERRORLOG_CODE(devid, 1, LOG_CODE_CLOUD, "未找到该装置，读取运行状态指令执行失败");
return true;
}
else if (ret > 0) {
send_reply_to_queue(guid, static_cast<int>(ResponseCode::BUSY),
"该装置正忙，读取运行状态指令执行失败");
DIY_WARNLOG_CODE(devid, 1, LOG_CODE_CLOUD, "该装置正忙，读取运行状态指令执行失败");
return true;
}
else {
std::cout << "记录装置状态成功，准备读取运行状态" << std::endl;
DIY_INFOLOG_CODE(devid, 1, LOG_CODE_CLOUD, "记录装置状态成功，准备读取运行状态");
}
}
//
@@ -2399,8 +2508,24 @@ bool parsemsg(const std::string& devid, const std::string& guid, const nlohmann:
std::cout << "[parsemsg] read version info, devid=" << devid
<< ", guid=" << guid << std::endl;
if (!recordguid(devid, guid, static_cast<int>(DeviceState::READING_DEVVERSION), 1)) {
return true;
{
int ret = recordguid(devid, guid, static_cast<int>(DeviceState::READING_DEVVERSION), 1);
if (-1 == ret) {
send_reply_to_queue(guid, static_cast<int>(ResponseCode::NOT_FOUND),
"未找到该装置，读取版本信息指令执行失败");
DIY_ERRORLOG_CODE(devid, 1, LOG_CODE_CLOUD, "未找到该装置，读取版本信息指令执行失败");
return true;
}
else if (ret > 0) {
send_reply_to_queue(guid, static_cast<int>(ResponseCode::BUSY),
"该装置正忙，读取版本信息指令执行失败");
DIY_WARNLOG_CODE(devid, 1, LOG_CODE_CLOUD, "该装置正忙，读取版本信息指令执行失败");
return true;
}
else {
std::cout << "记录装置状态成功，准备读取版本信息" << std::endl;
DIY_INFOLOG_CODE(devid, 1, LOG_CODE_CLOUD, "记录装置状态成功，准备读取版本信息");
}
}
ClientManager::instance().read_devversion_action_to_device(devid);
@@ -2413,11 +2538,27 @@ bool parsemsg(const std::string& devid, const std::string& guid, const nlohmann:
std::cout << "[parsemsg] time sync, devid=" << devid
<< ", guid=" << guid << std::endl;
if (!recordguid(devid, guid, static_cast<int>(DeviceState::SET_RIGHTTIME_2), 1)) {
return true;
{
int ret = recordguid(devid, guid, static_cast<int>(DeviceState::SET_RIGHTTIME_2), 1);
if (-1 == ret) {
send_reply_to_queue(guid, static_cast<int>(ResponseCode::NOT_FOUND),
"未找到该装置，对时指令执行失败");
DIY_ERRORLOG_CODE(devid, 1, LOG_CODE_CLOUD, "未找到该装置，对时指令执行失败");
return true;
}
else if (ret > 0) {
send_reply_to_queue(guid, static_cast<int>(ResponseCode::BUSY),
"该装置正忙，对时指令执行失败");
DIY_WARNLOG_CODE(devid, 1, LOG_CODE_CLOUD, "该装置正忙，对时指令执行失败");
return true;
}
else {
std::cout << "记录装置状态成功，准备对时" << std::endl;
DIY_INFOLOG_CODE(devid, 1, LOG_CODE_CLOUD, "记录装置状态成功，准备对时");
}
}
// 方案A：Msg 为空，直接使用当前系统时间下发
//
ClientManager::instance().set_righttime_action_to_device(devid);
return true;
@@ -2429,8 +2570,24 @@ bool parsemsg(const std::string& devid, const std::string& guid, const nlohmann:
std::cout << "[parsemsg] reboot device, devid=" << devid
<< ", guid=" << guid << std::endl;
if (!recordguid(devid, guid, static_cast<int>(DeviceState::SET_CTRL), 1)) {
return true;
{
int ret = recordguid(devid, guid, static_cast<int>(DeviceState::SET_CTRL), 1);
if (-1 == ret) {
send_reply_to_queue(guid, static_cast<int>(ResponseCode::NOT_FOUND),
"未找到该装置，重启指令执行失败");
DIY_ERRORLOG_CODE(devid, 1, LOG_CODE_CLOUD, "未找到该装置，重启指令执行失败");
return true;
}
else if (ret > 0) {
send_reply_to_queue(guid, static_cast<int>(ResponseCode::BUSY),
"该装置正忙，重启指令执行失败");
DIY_WARNLOG_CODE(devid, 1, LOG_CODE_CLOUD, "该装置正忙，重启指令执行失败");
return true;
}
else {
std::cout << "记录装置状态成功，准备重启装置" << std::endl;
DIY_INFOLOG_CODE(devid, 1, LOG_CODE_CLOUD, "记录装置状态成功，准备重启装置");
}
}
ClientManager::instance().set_ctrl_action_to_device(devid,0x01,0x00);//尝试装置重启指令！
@@ -2443,8 +2600,24 @@ bool parsemsg(const std::string& devid, const std::string& guid, const nlohmann:
std::cout << "[parsemsg] upgrade device, devid=" << devid
<< ", guid=" << guid << std::endl;
if (!recordguid(devid, guid, static_cast<int>(DeviceState::SET_PREUPGRADE), 2)) {
return true;
{
int ret = recordguid(devid, guid, static_cast<int>(DeviceState::SET_PREUPGRADE), 2);
if (-1 == ret) {
send_reply_to_queue(guid, static_cast<int>(ResponseCode::NOT_FOUND),
"未找到该装置，升级指令执行失败");
DIY_ERRORLOG_CODE(devid, 1, LOG_CODE_CLOUD, "未找到该装置，升级指令执行失败");
return true;
}
else if (ret > 0) {
send_reply_to_queue(guid, static_cast<int>(ResponseCode::BUSY),
"该装置正忙，升级指令执行失败");
DIY_WARNLOG_CODE(devid, 1, LOG_CODE_CLOUD, "该装置正忙，升级指令执行失败");
return true;
}
else {
std::cout << "记录装置状态成功，准备执行升级预校验" << std::endl;
DIY_INFOLOG_CODE(devid, 1, LOG_CODE_CLOUD, "记录装置状态成功，准备执行升级预校验");
}
}
ClientManager::instance().set_preupgrade_action_to_device(devid, "");//尝试装置升级指令！第一步校验
@@ -2465,7 +2638,29 @@ bool parsemsg(const std::string& devid, const std::string& guid, const nlohmann:
}
}
//心跳和其他响应
//////////////////////////////////////////////////////////////////////////////////////////////////////////云响应
static int get_cloud_type_by_state(int type)
{
switch (static_cast<DeviceState>(type)) {
case DeviceState::READING_FILEMENU: return 1101; // 读取文件目录
case DeviceState::READING_FILEDATA: return 1102; // 下载文件数据
case DeviceState::READING_FIXEDVALUE: return 1103; // 读取测点定值
case DeviceState::SET_FIXEDVALUE: return 1103; // 设置测点定值
case DeviceState::READING_INTERFIXEDVALUE: return 1103; // 读取内部定值
case DeviceState::SET_INTERFIXEDVALUE: return 1103; // 设置内部定值
case DeviceState::READING_RUNNINGINFORMATION_1: return 1111; // 主动读取运行状态
case DeviceState::READING_DEVVERSION: return 1112; // 读取版本信息
case DeviceState::SET_RIGHTTIME_2: return 1113; // 主动对时
case DeviceState::SET_CTRL: return 1114; // 控制/重启
case DeviceState::SET_PREUPGRADE: return 1115; // 升级预校验
default:
return type; // 其他未映射的，保持原值，避免影响现有逻辑
}
}
void send_reply_to_cloud(int reply_code, const std::string& dev_id, int type, const std::string& guid, const std::string& mac) {
try {
/*std::string guid = find_guid_index_from_dev_id(dev_id);*/
@@ -2487,7 +2682,7 @@ void send_reply_to_cloud(int reply_code, const std::string& dev_id, int type, co
// ---- 构造 Detail ----
nlohmann::json detail;
detail["Type"] = type;
detail["Type"] = get_cloud_type_by_state(type);
// Msg
nlohmann::json msg;