常见的C++ json库的使用
2021-05-01 本文已影响0人
雪域迷影
常见的C++ Json库
关于JSON库的描述，可以参见维基百科https://en.wikipedia.org/wiki/JSON以及Introducing JSON，感觉C/C++对于Json解析没有其他高级语言比如Java、C#、JavaScript的支持那么友好，尤其在序列化和反序列化方面。
目前常见的C++的Json解析库有：
-
RapidJSON
A fast JSON parser/generator for C++ with both SAX/DOM style API -
nlohmann/json
JSON for Modern C++
一个非常不错的Json解析库，支持序列化和反序列化，对自定义的结构体支持比较友好 - Qt的解析库
- Boost库中的json解析
在Github上面有一个仓库miloyip/nativejson-benchmark，描述了常见的C/C++ Json解析库的性能对比。
另外，知乎上面有篇帖子讨论了有哪些 C++ 的 JSON 库比较好呢？，可以借鉴一下。
我觉得有位兄弟对于虑nlohmann/json和rapidjson这两个C++解析库的评论和对比比较到位，所以建议不是很追求效率的条件还是建议使用nlohmann/json，否则可以选择腾讯的rapidjson。
非常推荐 nlohmann/json看性能测试应该是rapidjson效率最好，所以最开始我也用的rapidjson](https://github.com/Tencent/rapidjson)，但我发现rapidjson的接口太难用了，太不友好，所以我就换成了[nlohmann/json](https://github.com/nlohmann/json0我觉得除非你的项目对效率要求极度严格，已经明确到需要考虑nlohmann/json和rapidjson之间的这一点效率差异了，否则毫不犹豫用nlohmann/json吧，现代C++网格，用起来相当简单。为了那么一点可能根本不需要考虑的效率问题而去选择rapidjson，而导致编码难度和心智负担大大提高，我觉得简直得不偿失。
下面是我在实际项目中使用nlohmann/json库以及Qt的Json库对自定义结构体进行序列化和反序列化的一些代码片段：
#ifndef _ADVANCEPARAMDEFINE_H
#define _ADVANCEPARAMDEFINE_H
#include <QJsonArray>
#include <QJsonObject>
#include <QMap>
#include <string>
#include <nlohmann/json.hpp>
using namespace std;
using namespace nlohmann;
struct MotorInitParam
{
int nAcc;
int nLimitOffset;
int nReverseOffset;
int nSpeed;
double dbGear; // 转换系数
int eAxisType; //EHSK_AXIS_TYPE 0-4 x\y\z\刮片\墨栈
};
//马达初始化参数
struct MotorInitParamInfo
{
bool bSupportMotorY;
bool bSupportMotorZ;
bool bSupportMotorScrap;
std::vector<MotorInitParam> motorParams;
QJsonObject toJsonObject()
{
QJsonObject jo;
jo.insert("bSupportMotorY", bSupportMotorY);
jo.insert("bSupportMotorZ", bSupportMotorZ);
jo.insert("bSupportMotorScrap", bSupportMotorScrap);
QJsonArray jarr;
for (auto& v : motorParams)
{
QJsonObject j;
j.insert("eAxisType", v.eAxisType);
j.insert("nAcc", v.nAcc);
j.insert("nLimitOffset", v.nLimitOffset);
j.insert("nReverseOffset", v.nReverseOffset);
j.insert("nSpeed", v.nSpeed);
j.insert("dbGear", v.dbGear);
jarr.append(j);
}
jo.insert("motorInitParams", jarr);
return jo;
}
MotorInitParamInfo& fromJsonObject(QJsonObject jo)
{
bSupportMotorY = jo["bSupportMotorY"].toBool();
bSupportMotorZ = jo["bSupportMotorZ"].toBool();
bSupportMotorScrap = jo["bSupportMotorScrap"].toBool();
QJsonArray jarr = jo["motorInitParams"].toArray();
for (auto& v : jarr)
{
MotorInitParam param;
param.eAxisType = v.toObject()["eAxisType"].toInt();
param.nAcc = v.toObject()["nAcc"].toInt();
param.nLimitOffset = v.toObject()["nLimitOffset"].toInt();
param.nReverseOffset = v.toObject()["nReverseOffset"].toInt();
param.nSpeed = v.toObject()["nSpeed"].toInt();
param.dbGear = v.toObject()["dbGear"].toDouble();
motorParams.push_back(param);
}
return *this;
}
};
struct MotorXParamInfo
{
double dbMotorParamAcc;//加减速距离
double dbSpeedMove;//常规速度
double dbSpeedReposition;//回零速度
double dbSpeedPrintEmpty;//空跑速度
double dbGear;//齿轮比
double dbXPrintLeftEdgeOffset;//左侧停止位补偿距离
double dbXPrintRightEdgeOffset;//右侧停止位补偿距离
bool bCheckRasterShake;//是否检测光栅抖动
bool bUsePrintSpeedAsBackCarSpeed; //复位速度是否使用打印速度
double uSpeedPrintSlow;//打印速度 慢
double uSpeedPrintMiddle;//打印速度 中
double uSpeedPrintFast;//打印速度 快
double dbLimitLenP; //正向运动限制最大距离
double dbLimitLenN;//负向运动限制最大距离
int nAxisPositionMode; //马达定位方式
int nMotoRasterPort; //接口绑定方式
int nRasterOfffset;
double dbGearRunLength;
QJsonObject toJsonObject()
{
QJsonObject jo;
jo.insert("dbMotorParamAcc", dbMotorParamAcc);
jo.insert("dbSpeedMove", dbSpeedMove);
jo.insert("dbSpeedReposition", dbSpeedReposition);
jo.insert("dbSpeedPrintEmpty", dbSpeedPrintEmpty);
jo.insert("dbGear", dbGear);
jo.insert("dbXPrintLeftEdgeOffset", dbXPrintLeftEdgeOffset);
jo.insert("dbXPrintRightEdgeOffset", dbXPrintRightEdgeOffset);
jo.insert("bCheckRasterShake", bCheckRasterShake);
jo.insert("bUsePrintSpeedAsBackCarSpeed", bUsePrintSpeedAsBackCarSpeed);
jo.insert("uSpeedPrintSlow", uSpeedPrintSlow);
jo.insert("uSpeedPrintMiddle", uSpeedPrintMiddle);
jo.insert("uSpeedPrintFast", uSpeedPrintFast);
jo.insert("dbLimitLenP", dbLimitLenP);
jo.insert("dbLimitLenN", dbLimitLenN);
jo.insert("nAxisPositionMode", nAxisPositionMode);
jo.insert("nMotoRasterPort", nMotoRasterPort);
return jo;
}
void fromJsonObject(QJsonObject jo)
{
dbMotorParamAcc = jo["dbMotorParamAcc"].toDouble();
dbSpeedMove = jo["dbSpeedMove"].toDouble();
dbSpeedReposition = jo["dbSpeedReposition"].toDouble();
dbSpeedPrintEmpty = jo["dbSpeedPrintEmpty"].toDouble();
dbGear = jo["dbGear"].toDouble();
dbXPrintLeftEdgeOffset = jo["dbXPrintLeftEdgeOffset"].toDouble();
dbXPrintRightEdgeOffset = jo["dbXPrintRightEdgeOffset"].toDouble();
bCheckRasterShake = jo["bCheckRasterShake"].toBool();
bUsePrintSpeedAsBackCarSpeed = jo["bUsePrintSpeedAsBackCarSpeed"].toBool();
uSpeedPrintSlow = jo["uSpeedPrintSlow"].toDouble();
uSpeedPrintMiddle = jo["uSpeedPrintMiddle"].toDouble();
uSpeedPrintFast = jo["uSpeedPrintFast"].toDouble();
dbLimitLenP = jo["dbLimitLenP"].toDouble();
dbLimitLenN = jo["dbLimitLenN"].toDouble();
nAxisPositionMode = jo["nAxisPositionMode"].toInt();
nMotoRasterPort = jo["nMotoRasterPort"].toInt();
}
};
struct MotoYParamInfo
{
double dbMotorParamAcc;//加减速距离
double dbSpeedMove;//常规速度
double dbSpeedReposition;//回零速度
double dbGear;//齿轮比
double dbSpeedPrintSlow;//打印速度 慢
double dbSpeedPrintMiddle;//打印速度 中
double dbSpeedPrintFast; //打印速度 快
bool bSupportPrintReverseCompensation;//是否支持反向补偿距离
double dbPrintReverseComp;//反向打印补偿
double dbLimitLenP; //正向运动限制最大距离
double dbLimitLenN;//负向运动限制最大距离
int nYPositionMode;//Y定位方式
bool bEnableDoubleY;//是都支持双Y最大误差
double dbDoubleYError;//双Y最大误差
int nGearOffset;
QJsonObject toJsonObject()
{
QJsonObject jo;
jo.insert("dbMotorParamAcc", dbMotorParamAcc);
jo.insert("dbSpeedMove", dbSpeedMove);
jo.insert("dbSpeedReposition", dbSpeedReposition);
jo.insert("dbGear", dbGear);
jo.insert("dbSpeedPrintSlow", dbSpeedPrintSlow);
jo.insert("dbSpeedPrintMiddle", dbSpeedPrintMiddle);
jo.insert("dbSpeedPrintFast", dbSpeedPrintFast);
jo.insert("bSupportPrintReverseCompensation", bSupportPrintReverseCompensation);
jo.insert("dbPrintReverseComp", dbPrintReverseComp);
jo.insert("dbLimitLenP", dbLimitLenP);
jo.insert("dbLimitLenN", dbLimitLenN);
jo.insert("nYPositionMode", nYPositionMode);
jo.insert("bEnableDoubleY", bEnableDoubleY);
jo.insert("dbDoubleYError", dbDoubleYError);
jo.insert("nGearOffset", nGearOffset);
return jo;
}
void fromJsonObject(QJsonObject jo)
{
dbMotorParamAcc = jo["dbMotorParamAcc"].toDouble();
dbSpeedMove = jo["dbSpeedMove"].toDouble();
dbSpeedReposition = jo["dbSpeedReposition"].toDouble();
dbGear = jo["dbGear"].toDouble();
dbSpeedPrintSlow = jo["dbSpeedPrintSlow"].toDouble();
dbSpeedPrintMiddle = jo["dbSpeedPrintMiddle"].toDouble();
dbSpeedPrintFast = jo["dbSpeedPrintFast"].toDouble();
bSupportPrintReverseCompensation = jo["bSupportPrintReverseCompensation"].toBool();
dbPrintReverseComp = jo["dbPrintReverseComp"].toBool();
dbLimitLenP = jo["dbLimitLenP"].toDouble();
dbLimitLenN = jo["dbLimitLenN"].toDouble();
nYPositionMode = jo["nYPositionMode"].toDouble();
bEnableDoubleY = jo["bEnableDoubleY"].toDouble();
dbDoubleYError = jo["dbDoubleYError"].toDouble();
nGearOffset = jo["nGearOffset"].toInt();
}
};
struct MotoZParamInfo
{
// 运动参数
// 加速度巨鹿
double dbMotorParamAcc;
// 速度
double dbSpeedMove;
// 复位速度
double dbSpeedReposition;
// 齿轮比
double dbGear;
// 零点位置是否在上方
bool bZZeroOnTop;
// 测高器
// 测高补偿
double dAltimeterCompensate;
// 运动参数 开始初始化高度
double dbInitHeight;
// X偏移
double dAltimeterXOffset;
// Y偏移
double dAltimeterYOffset;
// 感应高度
double dAltimeterResponseHeight;
// 弹出延时
int nAltimeterOutDelayTime;
// 下限位与平台距离
double dbLowerLimitHeight;
// 齿轮偏移
int nGearOffset;
double dbLimitLenP;
double dbLimitLenN;
// 精度 分辨率
double dbMotoDpi;
// 移动偏移量
int nPluseOffset;
QJsonObject toJsonObject()
{
QJsonObject jo;
jo.insert("dbMotorParamAcc", dbMotorParamAcc);
jo.insert("dbSpeedMove", dbSpeedMove);
jo.insert("dbSpeedReposition", dbSpeedReposition);
jo.insert("dbGear", dbGear);
jo.insert("bZZeroOnTop", bZZeroOnTop);
jo.insert("dAltimeterCompensate", dAltimeterCompensate);
jo.insert("dbInitHeight", dbInitHeight);
jo.insert("dAltimeterXOffset", dAltimeterXOffset);
jo.insert("dAltimeterYOffset", dAltimeterYOffset);
jo.insert("dAltimeterResponseHeight", dAltimeterResponseHeight);
jo.insert("nAltimeterOutDelayTime", nAltimeterOutDelayTime);
jo.insert("dbLowerLimitHeight", dbLowerLimitHeight);
jo.insert("nGearOffset", nGearOffset);
jo.insert("dbLimitLenP", dbLimitLenP);
jo.insert("dbLimitLenN", dbLimitLenN);
jo.insert("dbMotoDpi", dbMotoDpi);
jo.insert("nPluseOffset", nPluseOffset);
return jo;
}
void fromJsonObject(QJsonObject jo)
{
dbMotorParamAcc = jo["dbMotorParamAcc"].toDouble();
dbSpeedMove = jo["dbSpeedMove"].toDouble();
dbSpeedReposition = jo["dbSpeedReposition"].toDouble();
dbGear = jo["dbGear"].toDouble();
bZZeroOnTop = jo["bZZeroOnTop"].toBool();
dAltimeterCompensate = jo["dAltimeterCompensate"].toDouble();
dbInitHeight = jo["dbInitHeight"].toDouble();
dAltimeterXOffset = jo["dAltimeterXOffset"].toBool();
dAltimeterYOffset = jo["dAltimeterYOffset"].toBool();
dAltimeterResponseHeight = jo["dAltimeterResponseHeight"].toDouble();
nAltimeterOutDelayTime = jo["nAltimeterOutDelayTime"].toInt();
dbLowerLimitHeight = jo["dbLowerLimitHeight"].toDouble();
nGearOffset = jo["nGearOffset"].toDouble();
dbLimitLenP = jo["dbLimitLenP"].toDouble();
dbLimitLenN = jo["dbLimitLenN"].toDouble();
dbMotoDpi = jo["dbMotoDpi"].toDouble();
nPluseOffset = jo["nPluseOffset"].toInt();
}
};
struct Moto0ParamInfo
{
int nInkStackHeightFlash;
int nInkStackHeightKeepWet;
int nInkStackHeightScraping;
int nInkStackSpeed;
int nMotorParamAcc;
int nInkStackHeightPump;
double dbLimitLenP;
double dbLimitLenN;
int nInkstackType;
QJsonObject toJsonObject()
{
QJsonObject jo;
jo.insert("nInkStackHeightFlash", nInkStackHeightFlash);
jo.insert("nInkStackHeightKeepWet", nInkStackHeightKeepWet);
jo.insert("nInkStackHeightScraping", nInkStackHeightScraping);
jo.insert("nInkStackSpeed", nInkStackSpeed);
jo.insert("nMotorParamAcc", nMotorParamAcc);
jo.insert("nInkStackHeightPump", nInkStackHeightPump);
jo.insert("dbLimitLenP", dbLimitLenP);
jo.insert("dbLimitLenN", dbLimitLenN);
jo.insert("nInkstackType", nInkstackType);
return jo;
}
void fromJsonObject(QJsonObject jo)
{
nInkStackHeightFlash = jo["nInkStackHeightFlash"].toDouble();
nInkStackHeightKeepWet = jo["nInkStackHeightKeepWet"].toDouble();
nInkStackHeightScraping = jo["nInkStackHeightScraping"].toDouble();
nInkStackSpeed = jo["nInkStackSpeed"].toDouble();
nMotorParamAcc = jo["nMotorParamAcc"].toBool();
nInkStackHeightPump = jo["nInkStackHeightPump"].toDouble();
dbLimitLenP = jo["dbLimitLenP"].toDouble();
dbLimitLenN = jo["dbLimitLenN"].toBool();
nInkstackType = jo["nInkstackType"].toBool();
}
};
struct Moto1ParamInfo
{
int nScrapMotoSpeed;
int nScprapingPos;
double dbScprapingPosEnd;
double dbScprapingPosStart;
int nCarMoveSpeedToScraping;
int nMotorParamAcc;
double dbLimitLenP;
double dbLimitLenN;
int nScraperType;
int nScraperIndex;
QJsonObject toJsonObject()
{
QJsonObject jo;
jo.insert("nScrapMotoSpeed", nScrapMotoSpeed);
jo.insert("nScprapingPos", nScprapingPos);
jo.insert("dbScprapingPosEnd", dbScprapingPosEnd);
jo.insert("dbScprapingPosStart", dbScprapingPosStart);
jo.insert("nCarMoveSpeedToScraping", nCarMoveSpeedToScraping);
jo.insert("nMotorParamAcc", nMotorParamAcc);
jo.insert("dbLimitLenP", dbLimitLenP);
jo.insert("dbLimitLenN", dbLimitLenN);
jo.insert("nScraperType", nScraperType);
jo.insert("nScraperIndex", nScraperIndex);
return jo;
}
void fromJsonObject(QJsonObject jo)
{
nScrapMotoSpeed = jo["nScrapMotoSpeed"].toDouble();
nScprapingPos = jo["nScprapingPos"].toDouble();
dbScprapingPosEnd = jo["dbScprapingPosEnd"].toDouble();
dbScprapingPosStart = jo["dbScprapingPosStart"].toDouble();
nCarMoveSpeedToScraping = jo["nCarMoveSpeedToScraping"].toBool();
nMotorParamAcc = jo["nMotorParamAcc"].toDouble();
dbLimitLenP = jo["dbLimitLenP"].toDouble();
dbLimitLenN = jo["dbLimitLenN"].toBool();
nScraperType = jo["nScraperType"].toBool();
nScraperIndex = jo["nScraperIndex"].toBool();
}
};
struct shskItemNode
{
int nID;
double dbValue;
string szName;
public:
friend inline void to_json(json &j, const shskItemNode &p)
{
j = json{
{"nID",p.nID},
{"dbValue",p.dbValue},
{"szName",p.szName},
};
}
friend inline void from_json(const json &j, shskItemNode &p)
{
j.at("nID").get_to(p.nID);
j.at("dbValue").get_to(p.dbValue);
j.at("szName").get_to(p.szName);
}
};
//喷头组合参数
struct HeadPhysicalLayoutParam
{
bool bEnableHeadDecrypt;
vector<float> dbHeadBaseDistanceMMs;
int nHeadGroupCnt;
int nCurPhyLayoutID;
int nHeadItemCount;
vector<shskItemNode> itemNodeList;
public:
friend inline void to_json(json &j, const HeadPhysicalLayoutParam &p)
{
j = json{
{"bEnableHeadDecrypt",p.bEnableHeadDecrypt},
{"dbHeadBaseDistanceMMs",p.dbHeadBaseDistanceMMs},
{"nHeadGroupCnt",p.nHeadGroupCnt},
{"nCurPhyLayoutID",p.nCurPhyLayoutID},
{"nHeadItemCount",p.nHeadItemCount},
{"itemNodeList",p.itemNodeList},
};
}
friend inline void from_json(const json &j, HeadPhysicalLayoutParam &p)
{
j.at("bEnableHeadDecrypt").get_to(p.bEnableHeadDecrypt);
j.at("dbHeadBaseDistanceMMs").get_to(p.dbHeadBaseDistanceMMs);
j.at("nHeadGroupCnt").get_to(p.nHeadGroupCnt);
j.at("nCurPhyLayoutID").get_to(p.nCurPhyLayoutID);
j.at("nHeadItemCount").get_to(p.nHeadItemCount);
j.at("itemNodeList").get_to(p.itemNodeList);
}
};
//打印模式参数
struct prinModeParamItem
{
int uiID; //打印模式ID
string szName; //打印模式名字
int nPassMode; //Pass模式
int nXDpiValue; //横向DPI值
int nEclosionDotMode; //羽化点模式
int nEclosionRangSuperStrong; //羽化幅度-超强
int nEclosionRangStrong; //羽化幅度-强
int nEclosionRangNormal; //羽化幅度-正常
int nEclosionRangWeak; //羽化幅度-弱
int bWaitForStepStop; //是否等待步进停止
public:
friend inline void to_json(json &j, const prinModeParamItem &p)
{
j = json{
{"uiID",p.uiID},
{"szName",p.szName},
{"nPassMode",p.nPassMode},
{"nXDpiValue",p.nXDpiValue},
{"nEclosionDotMode",p.nEclosionDotMode},
{"nEclosionRangSuperStrong",p.nEclosionRangSuperStrong},
{"nEclosionRangStrong",p.nEclosionRangStrong},
{"nEclosionRangNormal",p.nEclosionRangNormal},
{"nEclosionRangWeak",p.nEclosionRangWeak},
{"bWaitForStepStop",p.bWaitForStepStop},
};
}
friend inline void from_json(const json &j, prinModeParamItem &p)
{
j.at("uiID").get_to(p.uiID);
j.at("szName").get_to(p.szName);
j.at("nPassMode").get_to(p.nPassMode);
j.at("nXDpiValue").get_to(p.nXDpiValue);
j.at("nEclosionDotMode").get_to(p.nEclosionDotMode);
j.at("nEclosionRangSuperStrong").get_to(p.nEclosionRangSuperStrong);
j.at("nEclosionRangStrong").get_to(p.nEclosionRangStrong);
j.at("nEclosionRangNormal").get_to(p.nEclosionRangNormal);
j.at("nEclosionRangWeak").get_to(p.nEclosionRangWeak);
j.at("bWaitForStepStop").get_to(p.bWaitForStepStop);
}
};
//打印模式配置参数项
struct printConfigParamItem
{
int nID;
double dbValue;
string szName;
vector<prinModeParamItem> printModeParamItems;
public:
friend inline void to_json(json &j, const printConfigParamItem &p)
{
j = json{
{"nID",p.nID},
{"dbValue",p.dbValue},
{"szName",p.szName},
{"printModeParamItems",p.printModeParamItems},
};
}
friend inline void from_json(const json &j, printConfigParamItem &p)
{
j.at("nID").get_to(p.nID);
j.at("dbValue").get_to(p.dbValue);
j.at("szName").get_to(p.szName);
j.at("printModeParamItems").get_to(p.printModeParamItems);
}
};
//打印模式配置全部参数
struct printConfigParam
{
vector<printConfigParamItem> printCfgParamItems;
public:
friend inline void to_json(json &j, const printConfigParam &p)
{
j = json{
{"printCfgParamItems",p.printCfgParamItems},
};
}
friend inline void from_json(const json &j, printConfigParam &p)
{
j.at("printCfgParamItems").get_to(p.printCfgParamItems);
}
};
//UV灯参数
struct UvLightParam
{
bool bUVEnable; //uv灯使能
bool bLPrintLLight; //向左运动-左灯
bool bLPrintRLight; //向左运动-右灯
bool bRPrintLLight; //向右运动-左灯
bool bRPrintRLight; //向右运动-右灯
int nDelayTime; //等待时间（毫秒）
bool bWaitUVToImageEdge; //等待UV灯照射结束
bool bUVAfterPrint; //UV灯打印完照射模式使能
int nUVAfterPrintModeAuto;//UV灯打印完照射模式自动匹配使能
int nUVCountCustom; //自定义照射次数
double dUVHeightCustom; //自定义照射距离(毫秒)
bool bCheckSecondUVLight; //启动第二组UV灯
double dbFrontLightOffLengthMM; //前灯关闭距离
double dbBackLightOnLengthMM; //后灯关闭距离
bool bSecondLSwithEnable; //第二组亮灭参数使能
bool bSecondLPositionEnable; //第二组偏移参数使能
bool bSecondLPrintLLight; //第二组向左运动-左灯
bool bSecondLPrintRLight; //第二组向左运动-右灯
bool bSecondRPrintLLight; //第二组向右运动-左灯
bool bSecondRPrintRLight; //第二组向右运动-右灯
public:
friend inline void to_json(json &j, const UvLightParam &p)
{
j = json{
{"bUVEnable",p.bUVEnable},
{"bLPrintLLight",p.bLPrintLLight},
{"bLPrintRLight",p.bLPrintRLight},
{"bRPrintLLight",p.bRPrintLLight},
{"bRPrintRLight",p.bRPrintRLight},
{"nDelayTime",p.nDelayTime},
{"bWaitUVToImageEdge",p.bWaitUVToImageEdge},
{"bUVAfterPrint",p.bUVAfterPrint},
{"nUVAfterPrintModeAuto",p.nUVAfterPrintModeAuto},
{"nUVCountCustom",p.nUVCountCustom},
{"dUVHeightCustom",p.dUVHeightCustom},
{"bCheckSecondUVLight",p.bCheckSecondUVLight},
{"dbFrontLightOffLengthMM",p.dbFrontLightOffLengthMM},
{"dbBackLightOnLengthMM",p.dbBackLightOnLengthMM},
{"bSecondLSwithEnable",p.bSecondLSwithEnable},
{"bSecondLPositionEnable",p.bSecondLPositionEnable},
{"bSecondLPrintLLight",p.bSecondLPrintLLight},
{"bSecondLPrintRLight",p.bSecondLPrintRLight},
{"bSecondRPrintLLight",p.bSecondRPrintLLight},
{"bSecondRPrintRLight",p.bSecondRPrintRLight},
};
}
friend inline void from_json(const json &j, UvLightParam &p)
{
j.at("bUVEnable").get_to(p.bUVEnable);
j.at("bLPrintLLight").get_to(p.bLPrintLLight);
j.at("bLPrintRLight").get_to(p.bLPrintRLight);
j.at("bRPrintLLight").get_to(p.bRPrintLLight);
j.at("bRPrintRLight").get_to(p.bRPrintRLight);
j.at("nDelayTime").get_to(p.nDelayTime);
j.at("bWaitUVToImageEdge").get_to(p.bWaitUVToImageEdge);
j.at("bUVAfterPrint").get_to(p.bUVAfterPrint);
j.at("nUVAfterPrintModeAuto").get_to(p.nUVAfterPrintModeAuto);
j.at("nUVCountCustom").get_to(p.nUVCountCustom);
j.at("dUVHeightCustom").get_to(p.dUVHeightCustom);
j.at("bCheckSecondUVLight").get_to(p.bCheckSecondUVLight);
j.at("dbFrontLightOffLengthMM").get_to(p.dbFrontLightOffLengthMM);
j.at("dbBackLightOnLengthMM").get_to(p.dbBackLightOnLengthMM);
j.at("bSecondLSwithEnable").get_to(p.bSecondLSwithEnable);
j.at("bSecondLPositionEnable").get_to(p.bSecondLPositionEnable);
j.at("bSecondLPrintLLight").get_to(p.bSecondLPrintLLight);
j.at("bSecondLPrintRLight").get_to(p.bSecondLPrintRLight);
j.at("bSecondRPrintLLight").get_to(p.bSecondRPrintLLight);
j.at("bSecondRPrintRLight").get_to(p.bSecondRPrintRLight);
}
};
//自动清洗
struct HsAutoCleanParam
{
int nAutoCleanPass; //清洗间隔
int nInkFlashCount_PrePrint; //打印前闪喷次数
int nInkFlashOnceTime_PrePrint; //打印前单次闪喷时间
int nInkFlashWaitTime_PrePrint; //打印前闪喷间隔时间
int nInkFlashCount_Printing; //打印中闪喷次数
int nInkFlashOnceTime_Printing; //打印中单次闪喷时间
int nInkFlashWaitTime_Printing; //打印中闪喷间隔时间
int nXMoveOffset; //小车移动距离
int nXMoveSpeed; //小车移动速度
int nKeepWetXPos; //保湿X目标位
int nKeepWetZPos; //保湿Z目标位
int nAutoCleantMode; //自动清洗模式
int nAutoCleanHeadGruopId; //自动清洗喷头组合Id
int nAutoCleanSpaceTypeIndex; //自动清洗间隔类型
int nFlashFreq_Printing; //打印中闪喷频率
int nFlashFreq_PrePrint; //打印前闪喷频率
vector<int> vAutoCleanHeadGruopIds; //自动清洗喷头组合Id列表
vector<string> vAutoCleanHeadGruopNames; //自动清洗喷头组合名列表，id位置对应Name
vector<string> vAutoCleanModeNames; //自动清洗模式名
vector<string> vAutoCleanSpaceTypeNames; //自动清洗间隔类型名
public:
friend inline void to_json(json &j, const HsAutoCleanParam &p)
{
j = json{
{"nAutoCleanPass",p.nAutoCleanPass},
{"nInkFlashCount_PrePrint",p.nInkFlashCount_PrePrint},
{"nInkFlashOnceTime_PrePrint",p.nInkFlashOnceTime_PrePrint},
{"nInkFlashWaitTime_PrePrint",p.nInkFlashWaitTime_PrePrint},
{"nInkFlashCount_Printing",p.nInkFlashCount_Printing},
{"nInkFlashOnceTime_Printing",p.nInkFlashOnceTime_Printing},
{"nInkFlashWaitTime_Printing",p.nInkFlashWaitTime_Printing},
{"nXMoveOffset",p.nXMoveOffset},
{"nXMoveSpeed",p.nXMoveSpeed},
{"nKeepWetXPos",p.nKeepWetXPos},
{"nKeepWetZPos",p.nKeepWetZPos},
{"nAutoCleantMode",p.nAutoCleantMode},
{"nAutoCleanHeadGruopId",p.nAutoCleanHeadGruopId},
{"nAutoCleanSpaceTypeIndex",p.nAutoCleanSpaceTypeIndex},
{"nFlashFreq_Printing",p.nFlashFreq_Printing},
{"nFlashFreq_PrePrint",p.nFlashFreq_PrePrint},
{"vAutoCleanHeadGruopIds",p.vAutoCleanHeadGruopIds},
{"vAutoCleanHeadGruopNames",p.vAutoCleanHeadGruopNames},
{"vAutoCleanModeNames",p.vAutoCleanModeNames},
{"vAutoCleanSpaceTypeNames",p.vAutoCleanSpaceTypeNames},
};
}
friend inline void from_json(const json &j, HsAutoCleanParam &p)
{
j.at("nAutoCleanPass").get_to(p.nAutoCleanPass);
j.at("nInkFlashCount_PrePrint").get_to(p.nInkFlashCount_PrePrint);
j.at("nInkFlashOnceTime_PrePrint").get_to(p.nInkFlashOnceTime_PrePrint);
j.at("nInkFlashWaitTime_PrePrint").get_to(p.nInkFlashWaitTime_PrePrint);
j.at("nInkFlashCount_Printing").get_to(p.nInkFlashCount_Printing);
j.at("nInkFlashOnceTime_Printing").get_to(p.nInkFlashOnceTime_Printing);
j.at("nInkFlashWaitTime_Printing").get_to(p.nInkFlashWaitTime_Printing);
j.at("nXMoveOffset").get_to(p.nXMoveOffset);
j.at("nXMoveSpeed").get_to(p.nXMoveSpeed);
j.at("nKeepWetXPos").get_to(p.nKeepWetXPos);
j.at("nKeepWetZPos").get_to(p.nKeepWetZPos);
j.at("nAutoCleantMode").get_to(p.nAutoCleantMode);
j.at("nAutoCleanHeadGruopId").get_to(p.nAutoCleanHeadGruopId);
j.at("nAutoCleanSpaceTypeIndex").get_to(p.nAutoCleanSpaceTypeIndex);
j.at("nFlashFreq_Printing").get_to(p.nFlashFreq_Printing);
j.at("nFlashFreq_PrePrint").get_to(p.nFlashFreq_PrePrint);
j.at("vAutoCleanHeadGruopIds").get_to(p.vAutoCleanHeadGruopIds);
j.at("vAutoCleanHeadGruopNames").get_to(p.vAutoCleanHeadGruopNames);
j.at("vAutoCleanModeNames").get_to(p.vAutoCleanModeNames);
j.at("vAutoCleanSpaceTypeNames").get_to(p.vAutoCleanSpaceTypeNames);
}
};
//清洗模式对应抽墨参数
struct HsCleanScrapParam
{
int id; //模式id
string cleanname; //模式名
int nPumpInkCount; //抽墨次数
int nPumpInkTime; //抽墨时间
int nPumpInkWaitTime; //抽墨间隔时间
int nPumpInkWasteTime; //抽废墨时间
public:
friend inline void to_json(json &j, const HsCleanScrapParam &p)
{
j = json{
{"id",p.id},
{"cleanname",p.cleanname},
{"nPumpInkCount",p.nPumpInkCount},
{"nPumpInkTime",p.nPumpInkTime},
{"nPumpInkWaitTime",p.nPumpInkWaitTime},
{"nPumpInkWasteTime",p.nPumpInkWasteTime},
};
}
friend inline void from_json(const json &j, HsCleanScrapParam &p)
{
j.at("id").get_to(p.id);
j.at("cleanname").get_to(p.cleanname);
j.at("nPumpInkCount").get_to(p.nPumpInkCount);
j.at("nPumpInkTime").get_to(p.nPumpInkTime);
j.at("nPumpInkWaitTime").get_to(p.nPumpInkWaitTime);
j.at("nPumpInkWasteTime").get_to(p.nPumpInkWasteTime);
}
};
//手动清洗参数
struct HsCleanManualParam
{
int nCleanFlashCount; //闪喷次数
int nFlashWaitTime; //闪喷等待时间
int nOnceFlashTime; //单次闪喷时间
double dbMotorMoveOutLen; //小车移除距离
double dbMotorMoveOutSpeed; //小车移除速度
int nFlashFreq; //闪喷频率
//int nScrapIndex; //抽墨参数索引
vector<HsCleanScrapParam> scrapParams; //抽墨参数
public:
friend inline void to_json(json &j, const HsCleanManualParam &p)
{
j = json{
{"nCleanFlashCount",p.nCleanFlashCount},
{"nFlashWaitTime",p.nFlashWaitTime},
{"nOnceFlashTime",p.nOnceFlashTime},
{"dbMotorMoveOutLen",p.dbMotorMoveOutLen},
{"dbMotorMoveOutSpeed",p.dbMotorMoveOutSpeed},
{"nFlashFreq",p.nFlashFreq},
//{"nScrapIndex",p.nScrapIndex},
{"scrapParams",p.scrapParams},
};
}
friend inline void from_json(const json &j, HsCleanManualParam &p)
{
j.at("nCleanFlashCount").get_to(p.nCleanFlashCount);
j.at("nFlashWaitTime").get_to(p.nFlashWaitTime);
j.at("nOnceFlashTime").get_to(p.nOnceFlashTime);
j.at("dbMotorMoveOutLen").get_to(p.dbMotorMoveOutLen);
j.at("dbMotorMoveOutSpeed").get_to(p.dbMotorMoveOutSpeed);
j.at("nFlashFreq").get_to(p.nFlashFreq);
//j.at("nScrapIndex").get_to(p.nScrapIndex);
j.at("scrapParams").get_to(p.scrapParams);
}
};
//清洗模式对应抽墨参数 扩展
struct HsCleanScrapExParam
{
int id; //模式id
string cleanname; //模式名
int nPumpInkCount; //抽墨次数
int nPumpInkWasteTime; //抽墨时间
vector<int> nOutputPowerPrecents; //输出功能百分比
vector<int> nPumpInkWaitTimes; //抽墨间隔时间
vector<int> nPumpInkTimes; //抽废墨时间
public:
friend inline void to_json(json &j, const HsCleanScrapExParam &p)
{
j = json{
{"id",p.id},
{"cleanname",p.cleanname},
{"nPumpInkCount",p.nPumpInkCount},
{"nPumpInkWasteTime",p.nPumpInkWasteTime},
{"nOutputPowerPrecents",p.nOutputPowerPrecents},
{"nPumpInkWaitTimes",p.nPumpInkWaitTimes},
{"nPumpInkTimes",p.nPumpInkTimes},
};
}
friend inline void from_json(const json &j, HsCleanScrapExParam &p)
{
j.at("id").get_to(p.id);
j.at("cleanname").get_to(p.cleanname);
j.at("nPumpInkCount").get_to(p.nPumpInkCount);
j.at("nPumpInkWasteTime").get_to(p.nPumpInkWasteTime);
j.at("nOutputPowerPrecents").get_to(p.nOutputPowerPrecents);
j.at("nPumpInkWaitTimes").get_to(p.nPumpInkWaitTimes);
j.at("nPumpInkTimes").get_to(p.nPumpInkTimes);
}
};
//手动清洗参数 扩展
struct HsCleanManualExParam
{
int nCleanFlashCount; //闪喷次数
int nFlashWaitTime; //闪喷等待时间
int nOnceFlashTime; //单次闪喷时间
double dbMotorMoveOutLen; //小车移除距离
double dbMotorMoveOutSpeed; //小车移除速度
int nFlashFreq; //闪喷频率
//int nScrapIndex; //抽墨参数索引
vector<HsCleanScrapExParam> scrapParams; //抽墨参数
public:
friend inline void to_json(json &j, const HsCleanManualExParam &p)
{
j = json{
{"nCleanFlashCount",p.nCleanFlashCount},
{"nFlashWaitTime",p.nFlashWaitTime},
{"nOnceFlashTime",p.nOnceFlashTime},
{"dbMotorMoveOutLen",p.dbMotorMoveOutLen},
{"dbMotorMoveOutSpeed",p.dbMotorMoveOutSpeed},
{"nFlashFreq",p.nFlashFreq},
//{"nScrapIndex",p.nScrapIndex},
{"scrapParams",p.scrapParams},
};
}
friend inline void from_json(const json &j, HsCleanManualExParam &p)
{
j.at("nCleanFlashCount").get_to(p.nCleanFlashCount);
j.at("nFlashWaitTime").get_to(p.nFlashWaitTime);
j.at("nOnceFlashTime").get_to(p.nOnceFlashTime);
j.at("dbMotorMoveOutLen").get_to(p.dbMotorMoveOutLen);
j.at("dbMotorMoveOutSpeed").get_to(p.dbMotorMoveOutSpeed);
j.at("nFlashFreq").get_to(p.nFlashFreq);
//j.at("nScrapIndex").get_to(p.nScrapIndex);
j.at("scrapParams").get_to(p.scrapParams);
}
};
//跑机参数
struct HsRunningMachineParam
{
double dbXBeginPos; //小车开始位置
double dbXEndPos; //小车结束位置
double dbXSpeed; //小车速度
double dbZBeginPos; //z轴开始位置
double dbZEndPos; //z轴最大位置
double dbYOffsetOnce; //单向走纸距离
double dbYOffsetAll; //最大走纸距离
int nSPos; //刮片移出位置
public:
friend inline void to_json(json &j, const HsRunningMachineParam &p)
{
j = json{
{"dbXBeginPos",p.dbXBeginPos},
{"dbXEndPos",p.dbXEndPos},
{"dbXSpeed",p.dbXSpeed},
{"dbZBeginPos",p.dbZBeginPos},
{"dbZEndPos",p.dbZEndPos},
{"dbYOffsetAll",p.dbYOffsetAll},
{"dbYOffsetOnce",p.dbYOffsetOnce},
{"nSPos",p.nSPos},
};
}
friend inline void from_json(const json &j, HsRunningMachineParam &p)
{
j.at("dbXBeginPos").get_to(p.dbXBeginPos);
j.at("dbXEndPos").get_to(p.dbXEndPos);
j.at("dbXSpeed").get_to(p.dbXSpeed);
j.at("dbZBeginPos").get_to(p.dbZBeginPos);
j.at("dbZEndPos").get_to(p.dbZEndPos);
j.at("dbYOffsetAll").get_to(p.dbYOffsetAll);
j.at("dbYOffsetOnce").get_to(p.dbYOffsetOnce);
j.at("nSPos").get_to(p.nSPos);
}
};
//闪喷参数
struct HsMicroFlashParam
{
bool bSupportAutoFlash; //是否支持自动闪喷
bool bAutoFlash; //开启自动闪喷
int nAutoFlashFreq; //自动闪喷频率
int nAutoMicrowaveOnceTime; //自动单次闪喷时间
int nAutoMicrowaveWatiTime; //自动间隔时间
bool bAutoFlashPumpInkEnable; //自动抽废墨使能
int nAutoCleanInkStackTimeInterval;//自动抽废墨周期
int nAutoCleanInkStackTime; //自动抽废墨时间
int nManualFlashFreq; //手动闪喷频率
int nCleanFlashCount; //手动闪喷次数
int nOnceFlashTime; //手动单次闪喷时间
int nFlashWaitTime; //手动闪喷间隔时间
bool bFlashSlot; //启用闪喷槽
int nFlashSlotLeftPos; //闪喷槽左侧位置
int nFlashSlotRightPos; //闪喷槽右侧位置
int nFlashSlotWidth; //闪喷槽宽度
public:
friend inline void to_json(json &j, const HsMicroFlashParam &p)
{
j = json{
{"bSupportAutoFlash",p.bSupportAutoFlash},
{"bAutoFlash",p.bAutoFlash},
{"nAutoFlashFreq",p.nAutoFlashFreq},
{"nAutoMicrowaveOnceTime",p.nAutoMicrowaveOnceTime},
{"nAutoMicrowaveWatiTime",p.nAutoMicrowaveWatiTime},
{"bAutoFlashPumpInkEnable",p.bAutoFlashPumpInkEnable},
{"nAutoCleanInkStackTimeInterval",p.nAutoCleanInkStackTimeInterval},
{"nAutoCleanInkStackTime",p.nAutoCleanInkStackTime},
{"nManualFlashFreq",p.nManualFlashFreq},
{"nCleanFlashCount",p.nCleanFlashCount},
{"nOnceFlashTime",p.nOnceFlashTime},
{"nFlashWaitTime",p.nFlashWaitTime},
{"bFlashSlot",p.bFlashSlot},
{"nFlashSlotLeftPos",p.nFlashSlotLeftPos},
{"nFlashSlotRightPos",p.nFlashSlotRightPos},
{"nFlashSlotWidth",p.nFlashSlotWidth},
};
}
friend inline void from_json(const json &j, HsMicroFlashParam &p)
{
j.at("bSupportAutoFlash").get_to(p.bSupportAutoFlash);
j.at("bAutoFlash").get_to(p.bAutoFlash);
j.at("nAutoFlashFreq").get_to(p.nAutoFlashFreq);
j.at("nAutoMicrowaveOnceTime").get_to(p.nAutoMicrowaveOnceTime);
j.at("nAutoMicrowaveWatiTime").get_to(p.nAutoMicrowaveWatiTime);
j.at("bAutoFlashPumpInkEnable").get_to(p.bAutoFlashPumpInkEnable);
j.at("nAutoCleanInkStackTimeInterval").get_to(p.nAutoCleanInkStackTimeInterval);
j.at("nAutoCleanInkStackTime").get_to(p.nAutoCleanInkStackTime);
j.at("nManualFlashFreq").get_to(p.nManualFlashFreq);
j.at("nCleanFlashCount").get_to(p.nCleanFlashCount);
j.at("nOnceFlashTime").get_to(p.nOnceFlashTime);
j.at("nFlashWaitTime").get_to(p.nFlashWaitTime);
j.at("bFlashSlot").get_to(p.bFlashSlot);
j.at("nFlashSlotLeftPos").get_to(p.nFlashSlotLeftPos);
j.at("nFlashSlotRightPos").get_to(p.nFlashSlotRightPos);
j.at("nFlashSlotWidth").get_to(p.nFlashSlotWidth);
}
};
//走纸参数
struct HsRunPaperParam
{
int nYRunModeBeforePrint; //打印前走纸模式
int nYRunModeAfterPrint; //打印后走纸模式
double dbYRunAheadBeforePrint;//打印前进纸距离
double dbYRunBackBeforePrint;//打印前退纸距离
double dbYRunAheadAfterPrint;//打印后进纸距离
double dbYRunBackAfterPrint;//打印前进纸距离
int nPassModeYRunMode; //前后pass数走纸模式
int nOffsetNozzle; //前后PASS不走纸偏移孔
bool bEnableDryingAfterPrint;//打印完烘干开关
double dbYAllLenAfterPrint;//总走纸距离
int nEachPassWaitTime;//每PASS等待时间
bool bMovebackAfterDrying;//烘干后是否回退
bool bCheckOutOfPaper;//缺纸检测
int nCheckPaperValidPassCnt;//检测有效PASS数
bool bSupportTestPaper;//是否支持测纸
bool bCheckTestPaper;//测纸开关
int nPaperLeftOffset;//纸张左边距微调
int nPaperRightOffset;//纸张右边距微调
double dPaperTestSensorOffset;//测纸传感器偏移
double dPaperTestInvalidSPace;//测纸非检测区域
int nTestPaperWidth;//测纸宽度
bool bEmptyXMargin;//清空X白边
bool bEnableYPrintDirection; //启用Y定位方向
bool bMultiPrintTip; //多份打印提示
public:
friend inline void to_json(json &j, const HsRunPaperParam &p)
{
j = json{
{"nYRunModeBeforePrint",p.nYRunModeBeforePrint},
{"nYRunModeAfterPrint",p.nYRunModeAfterPrint},
{"dbYRunAheadBeforePrint",p.dbYRunAheadBeforePrint},
{"dbYRunBackBeforePrint",p.dbYRunBackBeforePrint},
{"dbYRunAheadAfterPrint",p.dbYRunAheadAfterPrint},
{"dbYRunBackAfterPrint",p.dbYRunBackAfterPrint},
{"nPassModeYRunMode",p.nPassModeYRunMode},
{"nOffsetNozzle",p.nOffsetNozzle},
{"bEnableDryingAfterPrint",p.bEnableDryingAfterPrint},
{"dbYAllLenAfterPrint",p.dbYAllLenAfterPrint},
{"nEachPassWaitTime",p.nEachPassWaitTime},
{"bMovebackAfterDrying",p.bMovebackAfterDrying},
{"bCheckOutOfPaper",p.bCheckOutOfPaper},
{"nCheckPaperValidPassCnt",p.nCheckPaperValidPassCnt},
{"bSupportTestPaper",p.bSupportTestPaper},
{"bCheckTestPaper",p.bCheckTestPaper},
{"nPaperLeftOffset",p.nPaperLeftOffset},
{"nPaperRightOffset",p.nPaperRightOffset},
{"dPaperTestSensorOffset",p.dPaperTestSensorOffset},
{"dPaperTestInvalidSPace",p.dPaperTestInvalidSPace},
{"nTestPaperWidth",p.nTestPaperWidth},
{"bEmptyXMargin",p.bEmptyXMargin},
{"bEnableYPrintDirection",p.bEnableYPrintDirection},
{"bMultiPrintTip",p.bMultiPrintTip},
};
}
friend inline void from_json(const json &j, HsRunPaperParam &p)
{
j.at("nYRunModeBeforePrint").get_to(p.nYRunModeBeforePrint);
j.at("nYRunModeAfterPrint").get_to(p.nYRunModeAfterPrint);
j.at("dbYRunAheadBeforePrint").get_to(p.dbYRunAheadBeforePrint);
j.at("dbYRunBackBeforePrint").get_to(p.dbYRunBackBeforePrint);
j.at("dbYRunAheadAfterPrint").get_to(p.dbYRunAheadAfterPrint);
j.at("dbYRunBackAfterPrint").get_to(p.dbYRunBackAfterPrint);
j.at("nPassModeYRunMode").get_to(p.nPassModeYRunMode);
j.at("nOffsetNozzle").get_to(p.nOffsetNozzle);
j.at("bEnableDryingAfterPrint").get_to(p.bEnableDryingAfterPrint);
j.at("dbYAllLenAfterPrint").get_to(p.dbYAllLenAfterPrint);
j.at("nEachPassWaitTime").get_to(p.nEachPassWaitTime);
j.at("bMovebackAfterDrying").get_to(p.bMovebackAfterDrying);
j.at("bCheckOutOfPaper").get_to(p.bCheckOutOfPaper);
j.at("nCheckPaperValidPassCnt").get_to(p.nCheckPaperValidPassCnt);
j.at("bSupportTestPaper").get_to(p.bSupportTestPaper);
j.at("bCheckTestPaper").get_to(p.bCheckTestPaper);
j.at("nPaperLeftOffset").get_to(p.nPaperLeftOffset);
j.at("nPaperRightOffset").get_to(p.nPaperRightOffset);
j.at("dPaperTestSensorOffset").get_to(p.dPaperTestSensorOffset);
j.at("dPaperTestInvalidSPace").get_to(p.dPaperTestInvalidSPace);
j.at("nTestPaperWidth").get_to(p.nTestPaperWidth);
j.at("bEmptyXMargin").get_to(p.bEmptyXMargin);
j.at("bEnableYPrintDirection").get_to(p.bEnableYPrintDirection);
j.at("bMultiPrintTip").get_to(p.bMultiPrintTip);
}
};
////波形设置参数
//struct HsWaveSetParam
//{
// string szWaveName; //当前波形文件名
// vector<string> szWaveFileList; //波形文件列表
//
// int nPrintWaveIndex; //默认模型索引
// vector<string> printWaveNameList;//波形名列表
//
// float fTempMin; //最小温度
// float fTempMax; //最大温度
//public:
// friend inline void to_json(json &j, const HsWaveSetParam &p)
// {
// j = json{
// {"szWaveName",p.szWaveName},
// {"szWaveFileList",p.szWaveFileList},
// {"nPrintWaveIndex",p.nPrintWaveIndex},
// {"printWaveNameList",p.printWaveNameList},
// {"fTempMin",p.fTempMin},
// {"fTempMax",p.fTempMax},
// };
// }
// friend inline void from_json(const json &j, HsWaveSetParam &p)
// {
// j.at("szWaveName").get_to(p.szWaveName);
// j.at("szWaveFileList").get_to(p.szWaveFileList);
// j.at("nPrintWaveIndex").get_to(p.nPrintWaveIndex);
// j.at("printWaveNameList").get_to(p.printWaveNameList);
// j.at("fTempMin").get_to(p.fTempMin);
// j.at("fTempMax").get_to(p.fTempMax);
// }
//};
//波形设置参数
struct HsWaveSetParam
{
string szWaveName; //当前波形文件名
vector<string> szWaveFileList; //波形文件列表
int nPrintWaveIndex; //默认模型索引
vector<string> printWaveNameList; //波形名列表
double fTempMin; //最小温度
double fTempMax; //最大温度
public:
/*friend inline void to_json(json &j, const HsWaveSetParam &p)
{
j = json{
{"szWaveName",p.szWaveName},
{"szWaveFileList",p.szWaveFileList},
{"nPrintWaveIndex",p.nPrintWaveIndex},
{"printWaveNameList",p.printWaveNameList},
{"fTempMin",p.fTempMin},
{"fTempMax",p.fTempMax},
};
}
friend inline void from_json(const json &j, HsWaveSetParam &p)
{
j.at("szWaveName").get_to(p.szWaveName);
j.at("szWaveFileList").get_to(p.szWaveFileList);
j.at("nPrintWaveIndex").get_to(p.nPrintWaveIndex);
j.at("printWaveNameList").get_to(p.printWaveNameList);
j.at("fTempMin").get_to(p.fTempMin);
j.at("fTempMax").get_to(p.fTempMax);
}*/
QJsonObject toJsonObject()
{
QJsonObject jo;
jo.insert("szWaveName", szWaveName.c_str());
QJsonArray jarrWaveFileList;
for (auto& v : szWaveFileList)
{
jarrWaveFileList.append(v.c_str());
}
jo.insert("szWaveFileList", jarrWaveFileList);
jo.insert("nPrintWaveIndex", nPrintWaveIndex);
QJsonArray jarrWaveNameList;
for (auto& v : printWaveNameList)
{
jarrWaveNameList.append(v.c_str());
}
jo.insert("printWaveNameList", jarrWaveNameList);
jo.insert("fTempMin", fTempMin);
jo.insert("fTempMax", fTempMax);
return jo;
}
HsWaveSetParam& fromJsonObject(QJsonObject jo)
{
szWaveName = jo["szWaveName"].toString().toStdString();
QJsonArray jarrWaveFileList = jo["szWaveFileList"].toArray();
for (auto& v : jarrWaveFileList)
{
szWaveFileList.push_back(v.toString().toStdString());
}
nPrintWaveIndex = jo["nPrintWaveIndex"].toInt();
QJsonArray jarrWaveNameList = jo["printWaveNameList"].toArray();
for (auto& v : jarrWaveNameList)
{
printWaveNameList.push_back(v.toString().toStdString());
}
fTempMin = jo["fTempMin"].toDouble();
fTempMax = jo["fTempMax"].toDouble();
return *this;
}
};
struct HsAlarmSet
{
int iTypeId; //报警类型Id
string sTypeName; //报警类型名
bool bEnable; //报警使能
int nRingIntetvalTime; //响铃间隔时间
int nRingTimesPerSecond; //每秒响铃次数
public:
friend inline void to_json(json &j, const HsAlarmSet &p)
{
j = json{
{"iTypeId",p.iTypeId},
{"sTypeName",p.sTypeName},
{"bEnable",p.bEnable},
{"nRingIntetvalTime",p.nRingIntetvalTime},
{"nRingTimesPerSecond",p.nRingTimesPerSecond},
};
}
friend inline void from_json(const json &j, HsAlarmSet &p)
{
j.at("iTypeId").get_to(p.iTypeId);
j.at("sTypeName").get_to(p.sTypeName);
j.at("bEnable").get_to(p.bEnable);
j.at("nRingIntetvalTime").get_to(p.nRingIntetvalTime);
j.at("nRingTimesPerSecond").get_to(p.nRingTimesPerSecond);
}
};
struct HsGeneralParam
{
double dbXOriginToZero; //X白边起始偏移
double dbYOriginToZero; //Y白边起始偏移
double dbMarginSetOffset; //X白边定位偏移
bool bSupportYMargin; //是否支持Y轴白边
int nXPhysicalRasterDpi; //X物理光栅DPI
int nXLogicRasterDpi; //X逻辑光栅DPI
int nYPhysicalRasterDpi; //Y物理光栅DPI
int nYLogicRasterDpi; //Y逻辑光栅DPI
bool bSupportAdaptiveLogicRaster; //是否支持逻辑光栅
bool bSupportBEEclosion; //是否支持首尾羽化
bool bBEEclosionEnable; //是否启用首尾羽化
float nEclosionHeight; //首尾羽化高度
int nColorBarDeepnessWeak; //彩条浓度弱
int nColorBarDeepnessMid; //彩条浓度中
int nColorBarDeepnessStrong; //彩条浓度强
int nPrintToOriginTime; //下位机未收到包打印暂停时间
int nResumeWaitTime; //打印暂停时间自动恢复时间
int nMotoSpeedScale; //马达加速曲线比例
//位置单位 0-脉冲 1-毫米
int nPositonUnitType;
//计量单位 0-毫米 1-英寸
int nMeasurementUnit;
//0-模板模式 1-开关模式 2-抽点模式 3-混合模式 4-校正模式 5-适配模式
int nHeadBetweenEcloMode; //喷头间羽化模式
//0-不启用, 1-喷头间距, 2-套色, 3-喷头间距和套色
int nColorSplit; //套色细分模式
vector<HsAlarmSet> vecAlarmSettings; //报警器设置
public:
friend inline void to_json(json &j, const HsGeneralParam &p)
{
j = json{
{"dbXOriginToZero",p.dbXOriginToZero},
{"dbYOriginToZero",p.dbYOriginToZero},
{"dbMarginSetOffset",p.dbMarginSetOffset},
{"bSupportYMargin",p.bSupportYMargin},
{"nXPhysicalRasterDpi",p.nXPhysicalRasterDpi},
{"nXLogicRasterDpi",p.nXLogicRasterDpi},
{"nYPhysicalRasterDpi",p.nYPhysicalRasterDpi},
{"nYLogicRasterDpi",p.nYLogicRasterDpi},
{"bSupportAdaptiveLogicRaster",p.bSupportAdaptiveLogicRaster},
{"bSupportBEEclosion",p.bSupportBEEclosion},
{"bBEEclosionEnable",p.bBEEclosionEnable},
{"nEclosionHeight",p.nEclosionHeight},
{"nColorBarDeepnessWeak",p.nColorBarDeepnessWeak},
{"nColorBarDeepnessMid",p.nColorBarDeepnessMid},
{"nColorBarDeepnessStrong",p.nColorBarDeepnessStrong},
{"nPrintToOriginTime",p.nPrintToOriginTime},
{"nResumeWaitTime",p.nResumeWaitTime},
{"nMotoSpeedScale",p.nMotoSpeedScale},
{"nPositonUnitType",p.nPositonUnitType},
{"nMeasurementUnit",p.nMeasurementUnit},
{"nHeadBetweenEcloMode",p.nHeadBetweenEcloMode},
{"nColorSplit",p.nColorSplit},
{"vecAlarmSettings",p.vecAlarmSettings},
};
}
friend inline void from_json(const json &j, HsGeneralParam &p)
{
j.at("dbXOriginToZero").get_to(p.dbXOriginToZero);
j.at("dbYOriginToZero").get_to(p.dbYOriginToZero);
j.at("dbMarginSetOffset").get_to(p.dbMarginSetOffset);
j.at("bSupportYMargin").get_to(p.bSupportYMargin);
j.at("nXPhysicalRasterDpi").get_to(p.nXPhysicalRasterDpi);
j.at("nXLogicRasterDpi").get_to(p.nXLogicRasterDpi);
j.at("nYPhysicalRasterDpi").get_to(p.nYPhysicalRasterDpi);
j.at("nYLogicRasterDpi").get_to(p.nYLogicRasterDpi);
j.at("bSupportAdaptiveLogicRaster").get_to(p.bSupportAdaptiveLogicRaster);
j.at("bSupportBEEclosion").get_to(p.bSupportBEEclosion);
j.at("bBEEclosionEnable").get_to(p.bBEEclosionEnable);
j.at("nEclosionHeight").get_to(p.nEclosionHeight);
j.at("nColorBarDeepnessWeak").get_to(p.nColorBarDeepnessWeak);
j.at("nColorBarDeepnessMid").get_to(p.nColorBarDeepnessMid);
j.at("nColorBarDeepnessStrong").get_to(p.nColorBarDeepnessStrong);
j.at("nPrintToOriginTime").get_to(p.nPrintToOriginTime);
j.at("nResumeWaitTime").get_to(p.nResumeWaitTime);
j.at("nMotoSpeedScale").get_to(p.nMotoSpeedScale);
j.at("nPositonUnitType").get_to(p.nPositonUnitType);
j.at("nMeasurementUnit").get_to(p.nMeasurementUnit);
j.at("nHeadBetweenEcloMode").get_to(p.nHeadBetweenEcloMode);
j.at("nColorSplit").get_to(p.nColorSplit);
j.at("vecAlarmSettings").get_to(p.vecAlarmSettings);
}
};
// 基准套色参数
// 每一列的数据项
struct BaseAdjustColItem
{
// 列头显示（close、C1~C8 M1~M8 Y1~Y8 K1~K8）
string szShow;
// 向右偏移量
int nRightOffset;
// 向左偏移量
int nLeftOffset;
// 垂直偏移量
int nVerOffset;
};
// 每个喷头的数据项
struct HeadItem
{
// 喷头的行数 4行
//int nRow;
// 喷头的通道数
int nChannel;
// 某一个喷头的数据
vector<BaseAdjustColItem> headDataItem;
};
// 所有的喷头数据项
//struct AllHeadData
//{
// // 喷头数
// int nHeadCount;
// // 所有的喷头数据
// vector<HeadItem> HeadData;
//};
// 基准横向DPI
struct BaseXDpiItem
{
int nID; //ID
double dbValue; //I值
string szName; //名字
};
// 喷头索引和值
struct PhyHeadIndexItem
{
int nIndex; // 0 1 5 7
string szText; // H2 H4 H6 H8等
};
// 基准通道索引和值
struct BaseChannelIndexItem
{
int nIndex;
string szText; // K1~K8 C1~C8 M1~M8 K1~K8
};
struct HsBaseAdjustParam
{
int nHeadGroupCnt; //物理布局喷头个数
int nHeadChannelCnt; //单喷头喷头通道数
int nPhyLayoutIndex; //当前物理布局索引
int nListRowCnt; //列表行数
int nListColCnt; //列表列数
//char byChannelInk[32];
bool bSupportHeadColumnOffset; //是否支持喷头列偏移
bool bSupportColorSplit; //是否支持套色细分
vector<PhyHeadIndexItem> szHeadGroupList; //喷头选择列表
vector<BaseChannelIndexItem> szHeadChannelList; //基准通道列表
vector<HeadItem> colParamList; // 所有喷头通道的偏移数据（包括颜色信息、向右、向左、垂直偏移量）
vector<BaseXDpiItem> baseXDpiList; //基准横向DPI列表
int nCurXDpi; //当前基准横向DPI值
QJsonObject toJsonObject()
{
QJsonObject jo;
jo.insert("nHeadGroupCnt", nHeadGroupCnt);
jo.insert("nHeadChannelCnt", nHeadChannelCnt);
jo.insert("nPhyLayoutIndex", nPhyLayoutIndex);
jo.insert("nListRowCnt", nListRowCnt);
jo.insert("nListColCnt", nListColCnt);
jo.insert("bSupportHeadColumnOffset", bSupportHeadColumnOffset);
jo.insert("bSupportColorSplit", bSupportColorSplit);
// 喷头选择列表
QJsonArray jXHeadGroupArr;
for (auto& v : szHeadGroupList)
{
QJsonObject j;
j.insert("nIndex", v.nIndex);
j.insert("szText", v.szText.c_str());
jXHeadGroupArr.append(j);
}
jo.insert("szHeadGroupList", jXHeadGroupArr);
// 基准通道列表
QJsonArray jXHeadChannelArr;
for (auto& v : szHeadChannelList)
{
QJsonObject j;
j.insert("nIndex", v.nIndex);
j.insert("szText", v.szText.c_str());
jXHeadChannelArr.append(j);
}
jo.insert("szHeadChannelList", jXHeadChannelArr);
// 喷头数据列表
QJsonArray jColParamsArr;
for (auto& v : colParamList)
{
// 每个喷头的数据项
HeadItem headItem = v;
int headChannelCount = v.nChannel;
QJsonObject j2;
j2.insert("nChannel", v.nChannel);
QJsonArray arr2;
for (auto&v2 : v.headDataItem)
{
QJsonObject j3;
j3.insert("szShow", v2.szShow.c_str());
j3.insert("nRightOffset", v2.nRightOffset);
j3.insert("nLeftOffset", v2.nLeftOffset);
j3.insert("nVerOffset", v2.nVerOffset);
arr2.append(j3);
}
j2.insert("headDataItem", arr2);
}
jo.insert("colParams", jColParamsArr);
//基准横向DPI列表
QJsonArray jBaseXDpiArr;
for (auto& v : baseXDpiList)
{
QJsonObject j;
j.insert("nID", v.nID);
j.insert("dbValue", v.dbValue);
j.insert("szName", v.szName.c_str());
jBaseXDpiArr.append(j);
}
jo.insert("baseXDpiList", jBaseXDpiArr);
jo.insert("nCurXDpi", nCurXDpi);
return jo;
}
HsBaseAdjustParam& fromJsonObject(QJsonObject jo)
{
nHeadGroupCnt = jo["nHeadGroupCnt"].toInt();
nHeadChannelCnt = jo["nHeadChannelCnt"].toInt();
nPhyLayoutIndex = jo["nPhyLayoutIndex"].toInt();
nListRowCnt = jo["nListRowCnt"].toInt();
nListColCnt = jo["nListColCnt"].toInt();
bSupportColorSplit = jo["bSupportColorSplit"].toBool();
bSupportHeadColumnOffset = jo["bSupportHeadColumnOffset"].toBool();
//喷头选择列表
QJsonArray jHeadGroupArr = jo["szHeadGroupList"].toArray();
for (auto& v : jHeadGroupArr)
{
PhyHeadIndexItem item;
item.nIndex = v.toObject()["nIndex"].toInt();
item.szText = v.toObject()["szText"].toString().toStdString();
szHeadGroupList.push_back(item);
}
//基准通道列表
QJsonArray jHeadChannelArr = jo["szHeadChannelList"].toArray();
for (auto& v : jHeadChannelArr)
{
BaseChannelIndexItem item;
item.nIndex = v.toObject()["nIndex"].toInt();
item.szText = v.toObject()["szText"].toString().toStdString();
szHeadChannelList.push_back(item);
}
QJsonArray jColParamArr = jo["colParamList"].toArray();
for (auto& v : jColParamArr)
{
HeadItem headItem;
headItem.nChannel = v.toObject()["nChannel"].toInt();
for (auto& v2 : v.toObject()["headDataItem"].toArray())
{
BaseAdjustColItem item;
item.szShow = v2.toObject()["szShow"].toString().toStdString();
item.nRightOffset = v2.toObject()["nRightOffset"].toInt();
item.nLeftOffset = v2.toObject()["nLeftOffset"].toInt();
item.nVerOffset = v2.toObject()["nVerOffset"].toInt();
headItem.headDataItem.push_back(item);
}
colParamList.push_back(headItem);
}
QJsonArray jBaseXDpiArr = jo["baseXDpiList"].toArray();
for (auto& v : jBaseXDpiArr)
{
BaseXDpiItem item;
item.nID = v.toObject()["nID"].toInt();
item.dbValue = v.toObject()["dbValue"].toDouble();
item.szName = v.toObject()["szName"].toString().toStdString();
baseXDpiList.push_back(item);
}
nCurXDpi = jo["nCurXDpi"].toInt();
return *this;
}
};
#endif
