652 lines
15 KiB
C++
652 lines
15 KiB
C++
#ifndef CHECK_CFG_H
|
||
#define CHECK_CFG_H
|
||
|
||
|
||
|
||
|
||
#include <QFile>
|
||
#include <QJsonObject>
|
||
#include <QJsonDocument>
|
||
#include <QJsonParseError>
|
||
#include "QJsonValue"
|
||
#include <QJsonArray>
|
||
#include "QByteArray"
|
||
#include "stdint-gcc.h"
|
||
#include "QList"
|
||
#include "QString"
|
||
#include <QDebug>
|
||
#include "base/mycfg.h"
|
||
|
||
|
||
#define JVALUE_TO_BOOL(v,j) \
|
||
{\
|
||
if(j.type() == QJsonValue::Bool)\
|
||
v=j.toBool();\
|
||
else\
|
||
qWarning()<<#j<<"json not a bool value"<<endl;\
|
||
}
|
||
#define JVALUE_TO_INT(v,j) \
|
||
{\
|
||
if(j.type() == QJsonValue::Double)\
|
||
v=j.toInt();\
|
||
else\
|
||
{\
|
||
v=0;\
|
||
qWarning()<<#j<<"json not a int value"<<endl;\
|
||
}\
|
||
}
|
||
#define JVALUE_TO_U8(v,j) \
|
||
{\
|
||
if(j.type() == QJsonValue::Double)\
|
||
v=(uint8_t)j.toInt();\
|
||
else\
|
||
{\
|
||
v=0;\
|
||
qWarning()<<#j<<"json not a int value"<<endl;\
|
||
}\
|
||
}
|
||
#define JVALUE_TO_U16(v,j) \
|
||
{\
|
||
if(j.type() == QJsonValue::Double)\
|
||
v=(uint16_t)j.toInt();\
|
||
else\
|
||
{\
|
||
v=0;\
|
||
qWarning()<<#j<<"json not a int value"<<endl;\
|
||
}\
|
||
}
|
||
#define JVALUE_TO_STR(v,j) \
|
||
{\
|
||
if(j.type() == QJsonValue::String)\
|
||
v=j.toString();\
|
||
else\
|
||
qWarning()<<#j<<"json not a string value"<<endl;\
|
||
}
|
||
#define JVALUE_IS_ARRAY(j) \
|
||
if(j.type()!=QJsonValue::Array){\
|
||
qWarning()<<#j<<"json not a array"<<endl;\
|
||
}else\
|
||
|
||
|
||
|
||
|
||
class check_range;
|
||
class check_task;
|
||
class check_err;
|
||
class check_suberr;
|
||
|
||
class my_json
|
||
{
|
||
public:
|
||
my_json(){}
|
||
~my_json(){}
|
||
template <typename T>
|
||
void json_to_list(QJsonObject j,QString key,QList<T> &list,
|
||
T (my_json::*json_to_value)(QJsonValue v))
|
||
{
|
||
QJsonValue value = j.value(key);
|
||
JVALUE_IS_ARRAY(value)
|
||
{
|
||
QJsonArray array = value.toArray();
|
||
for (int i = 0; i < array.size(); i++) {
|
||
QJsonValue item = array.at(i);
|
||
list.append((this->*json_to_value)(item));
|
||
}
|
||
}
|
||
}
|
||
uint8_t json_to_u8(QJsonValue v){
|
||
uint8_t r;
|
||
JVALUE_TO_U8(r,v);
|
||
return r;
|
||
}
|
||
uint16_t json_to_u16(QJsonValue v){
|
||
uint16_t r;
|
||
JVALUE_TO_U16(r,v);
|
||
return r;
|
||
}
|
||
int json_to_int(QJsonValue v){
|
||
int r;
|
||
JVALUE_TO_INT(r,v);
|
||
return r;
|
||
}
|
||
QString json_to_str(QJsonValue v){
|
||
QString r;
|
||
JVALUE_TO_STR(r,v);
|
||
return r;
|
||
}
|
||
check_range json_to_range(QJsonValue v);
|
||
check_task json_to_task(QJsonValue v);
|
||
check_err json_to_err(QJsonValue v);
|
||
check_suberr json_to_suberr(QJsonValue v);
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
|
||
// 范围
|
||
class check_range
|
||
{
|
||
public:
|
||
|
||
check_range(uint16_t min,uint16_t max)
|
||
{
|
||
this->min=min;
|
||
this->max=max;
|
||
}
|
||
check_range(QJsonObject j)
|
||
{
|
||
JVALUE_TO_U16(min,j.value("Min"));
|
||
JVALUE_TO_U16(max,j.value("Max"));
|
||
if(min>max)
|
||
qWarning()<<"the range min="<<min<<"max="<<max<<"is empty."<<endl;
|
||
}
|
||
check_range(const check_range& b)
|
||
{
|
||
min=b.min;
|
||
max=b.max;
|
||
}
|
||
~check_range()
|
||
{
|
||
|
||
}
|
||
check_range& operator=(const check_range& b)
|
||
{
|
||
min=b.min;
|
||
max=b.max;
|
||
return *this;
|
||
}
|
||
// 如果在范围内则范围true
|
||
bool in_range(uint16_t a)
|
||
{
|
||
if(a>=min&&a<=max)
|
||
return true;
|
||
else
|
||
return false;
|
||
}
|
||
//private:
|
||
uint16_t min;
|
||
uint16_t max;
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
// 任务参数
|
||
class check_task
|
||
{
|
||
public:
|
||
check_task()
|
||
{
|
||
task_id=0;
|
||
index=0;
|
||
param_num=0;
|
||
return_num=0;
|
||
err_jump=0;
|
||
retry=0;
|
||
}
|
||
check_task(QJsonObject j)
|
||
{
|
||
my_json m;
|
||
JVALUE_TO_STR(brief,j.value("TaskBrief"));
|
||
JVALUE_TO_U8(task_id,j.value("TaskID"));
|
||
JVALUE_TO_U8(index,j.value("TaskIndex"));
|
||
JVALUE_TO_U8(err_jump,j.value("ErrJumpTo"));
|
||
JVALUE_TO_U8(retry,j.value("RetryCount"));
|
||
JVALUE_TO_U8(param_num,j.value("ParamCount"));
|
||
JVALUE_TO_U8(return_num,j.value("ReturnCount"));
|
||
m.json_to_list(j,"ParamInfo",params_info,&my_json::json_to_str);
|
||
m.json_to_list(j,"ReturnInfo",returns_info,&my_json::json_to_str);
|
||
m.json_to_list(j,"ParamVal",params,&my_json::json_to_u16);
|
||
m.json_to_list(j,"TestStandard",ranges,&my_json::json_to_range);
|
||
JVALUE_TO_U8(failed_code,j.value("ExecuteErrCode"));
|
||
m.json_to_list(j,"ResultErrCode",ret_failed_code,&my_json::json_to_u8);
|
||
}
|
||
check_task(const check_task& b)
|
||
{
|
||
brief=b.brief;
|
||
task_id=b.task_id;
|
||
index=b.index;
|
||
param_num=b.param_num;
|
||
params_info=b.params_info;
|
||
params=b.params;
|
||
ranges=b.ranges;
|
||
return_num=b.return_num;
|
||
returns_info=b.returns_info;
|
||
err_jump=b.err_jump;
|
||
retry=b.retry;
|
||
failed_code=b.failed_code;
|
||
ret_failed_code=b.ret_failed_code;
|
||
}
|
||
~check_task()
|
||
{
|
||
|
||
}
|
||
check_task& operator=(const check_task& b)
|
||
{
|
||
brief=b.brief;
|
||
task_id=b.task_id;
|
||
index=b.index;
|
||
param_num=b.param_num;
|
||
params_info=b.params_info;
|
||
params=b.params;
|
||
ranges=b.ranges;
|
||
return_num=b.return_num;
|
||
returns_info=b.returns_info;
|
||
err_jump=b.err_jump;
|
||
retry=b.retry;
|
||
failed_code=b.failed_code;
|
||
ret_failed_code=b.ret_failed_code;
|
||
return *this;
|
||
}
|
||
QByteArray to_byte_array()
|
||
{
|
||
QByteArray t;
|
||
t.append(task_id);
|
||
t.append(index);
|
||
t.append(retry);
|
||
t.append(err_jump);
|
||
t.append((param_num&0x0f)|(return_num<<4));
|
||
for(int i=0;i<params.size();i++)
|
||
{
|
||
t.append(uint8_t(params[i]&0xff));
|
||
t.append(uint8_t(params[i]>>8));
|
||
}
|
||
if(param_num!=params.size())
|
||
{
|
||
qWarning()<<"name="<<brief<<" param_num!=params.size()."<<endl;
|
||
}
|
||
if(return_num>returns_info.size())
|
||
{
|
||
qWarning()<<"name="<<brief<<" return_num>returns_info.size()."<<endl;
|
||
}
|
||
if(ch_errcode.size()!=ranges.size())
|
||
{
|
||
qWarning()<<"name="<<brief<<" ch_errcode.size()!=ranges.size()."<<endl;
|
||
}
|
||
return t;
|
||
}
|
||
QList<check_range> get_ranges()
|
||
{
|
||
return ranges;
|
||
}
|
||
QJsonObject returns_to_json(bool ack,QByteArray data)
|
||
{
|
||
QJsonObject j;
|
||
QJsonArray a;
|
||
QJsonArray ret_err;
|
||
ch_errcode.clear();
|
||
j.insert("TaskBrief",brief);
|
||
j.insert("TaskIndex",get_index());
|
||
j.insert("TaskID",get_task_id());
|
||
j.insert("Ack",ack);
|
||
if(ack!=true)
|
||
{
|
||
// 添加流程错误
|
||
j.insert("ExecuteErrCode",failed_code);
|
||
ch_errcode.append(failed_code);
|
||
}
|
||
else{
|
||
j.insert("ExecuteErrCode",0);
|
||
}
|
||
{
|
||
if((data.size()/2)<return_num)
|
||
qWarning()<<"data size too less."<<endl;
|
||
else
|
||
{
|
||
for(int i=0;i<return_num;i++)
|
||
{
|
||
QJsonObject t;
|
||
int value=data[i*2]|(data[i*2+1]<<8);
|
||
if(returns_info.size()>i)
|
||
t.insert("ReturnInfo",returns_info[i]);
|
||
else
|
||
t.insert("ReturnInfo","unknown");
|
||
t.insert("Return",value);
|
||
// 判断值域
|
||
if(ranges.size()>i)
|
||
{
|
||
//qDebug()<<"rang:"<<ranges[i].min<<ranges[i].max<<value<<endl;
|
||
bool b=ranges[i].in_range(value);
|
||
t.insert("InRange",b);
|
||
if(b==true) ret_err.append(0);
|
||
else {
|
||
if(ret_failed_code.size()>i)
|
||
{
|
||
ret_err.append(ret_failed_code[i]);
|
||
ch_errcode.append(ret_failed_code[i]);
|
||
}
|
||
else
|
||
ret_err.append(0);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
t.insert("InRange",true);
|
||
ret_err.append(0);
|
||
}
|
||
a.append(t);
|
||
}
|
||
}
|
||
}
|
||
//qDebug()<<"task="<<get_brief()<<"ch_errcode="<<ch_errcode<<endl;
|
||
j.insert("Returns",a);
|
||
j.insert("ResultErrCode",ret_err);
|
||
return j;
|
||
}
|
||
QList<uint8_t> get_ch_errcode(){
|
||
//qDebug()<<"task="<<get_brief()<<"ch_errcode="<<ch_errcode<<endl;
|
||
return ch_errcode;
|
||
}
|
||
QString get_brief(){return brief;}
|
||
uint8_t get_task_id(){return task_id;}
|
||
uint8_t get_index(){return index;}
|
||
int get_return_num(){return return_num;}
|
||
QList<QString> get_return_info(){return returns_info;}
|
||
int get_err_jump(){return err_jump;}
|
||
uint8_t get_failed_code(){return failed_code;}
|
||
QList<uint8_t> get_ret_failed_code(){return ret_failed_code;}
|
||
private:
|
||
// 任务简要描述
|
||
QString brief;
|
||
// 对应从机的检测项目
|
||
uint8_t task_id;
|
||
// 此任务执行的次序
|
||
uint8_t index;
|
||
// 此任务参数个数
|
||
uint8_t param_num;
|
||
// 参数介绍
|
||
QList<QString> params_info;
|
||
// 参数指
|
||
QList<uint16_t> params;
|
||
// 参数范围
|
||
QList<check_range> ranges;
|
||
// 返回值个数
|
||
uint8_t return_num;
|
||
// 返回值说明
|
||
QList<QString> returns_info;
|
||
// 失败时跳转到任务
|
||
uint8_t err_jump;
|
||
// 失败后重试次数
|
||
uint8_t retry;
|
||
// 此任务失败时的错误代码
|
||
uint8_t failed_code;
|
||
// 此任务返回值错误时的错误代码
|
||
QList<uint8_t> ret_failed_code;
|
||
|
||
// 解析时此任务产生的错误代码
|
||
QList<uint8_t> ch_errcode;
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
class check_err
|
||
{
|
||
public:
|
||
check_err(){}
|
||
check_err(QJsonObject j){
|
||
my_json m;
|
||
JVALUE_TO_STR(info,j.value("Info"));
|
||
JVALUE_TO_U8(code,j.value("MajorErrCode"));
|
||
m.json_to_list(j,"SubErrCode",sub_errs,&my_json::json_to_u8);
|
||
}
|
||
check_err(const check_err& b)
|
||
{
|
||
info=b.info;
|
||
code=b.code;
|
||
sub_errs=b.sub_errs;
|
||
}
|
||
~check_err(){}
|
||
check_err& operator=(const check_err& b)
|
||
{
|
||
info=b.info;
|
||
code=b.code;
|
||
sub_errs=b.sub_errs;
|
||
return *this;
|
||
}
|
||
void append(uint8_t suberr){
|
||
sub_errs.append(suberr);
|
||
}
|
||
void append(QList<uint8_t> suberrs){
|
||
this->sub_errs.append(suberrs);
|
||
}
|
||
bool operator ==(const uint8_t code)
|
||
{
|
||
return this->code==code;
|
||
}
|
||
QString get_err_string()
|
||
{
|
||
return info;
|
||
}
|
||
QString operator ()()
|
||
{
|
||
return info;
|
||
}
|
||
bool in_range(uint8_t err){
|
||
foreach (uint8_t i, sub_errs) {
|
||
if(i==err) return true;
|
||
}
|
||
return false;
|
||
}
|
||
uint8_t get_code(){return code;}
|
||
QList<uint8_t> get_subcodes(){return sub_errs;}
|
||
private:
|
||
QString info;
|
||
uint8_t code;
|
||
QList<uint8_t> sub_errs;
|
||
};
|
||
|
||
class check_suberr
|
||
{
|
||
public:
|
||
check_suberr(){}
|
||
check_suberr(QJsonObject j)
|
||
{
|
||
JVALUE_TO_STR(info,j.value("Info"));
|
||
JVALUE_TO_U8(code,j.value("ErrCode"));
|
||
}
|
||
check_suberr(const check_suberr& b)
|
||
{
|
||
info=b.info;
|
||
code=b.code;
|
||
}
|
||
~check_suberr(){}
|
||
check_suberr& operator=(const check_suberr& b)
|
||
{
|
||
info=b.info;
|
||
code=b.code;
|
||
return *this;
|
||
}
|
||
bool operator ==(const uint8_t code)
|
||
{
|
||
return this->code==code;
|
||
}
|
||
QString get_err_string()
|
||
{
|
||
return info;
|
||
}
|
||
QString operator ()()
|
||
{
|
||
return info;
|
||
}
|
||
private:
|
||
QString info;
|
||
uint8_t code;
|
||
};
|
||
|
||
|
||
|
||
class check_value
|
||
{
|
||
public:
|
||
check_value(){
|
||
|
||
}
|
||
~check_value(){
|
||
|
||
}
|
||
private:
|
||
QString info;
|
||
uint16_t value;
|
||
};
|
||
|
||
|
||
#pragma pack(1)
|
||
typedef struct{
|
||
uint16_t max;
|
||
uint16_t min;
|
||
uint8_t err;
|
||
}scheme_range_def;
|
||
|
||
typedef struct
|
||
{
|
||
uint8_t taskid;
|
||
uint8_t taskindex;
|
||
uint8_t item_num;
|
||
uint8_t err;
|
||
scheme_range_def range[16];
|
||
}scheme_task_def;
|
||
|
||
typedef struct{
|
||
uint8_t err;
|
||
uint8_t suberr_num;
|
||
uint8_t suberr[30];
|
||
}marerr_def;
|
||
|
||
|
||
|
||
typedef struct{
|
||
uint8_t slave_data[2048];
|
||
uint32_t plan_id;
|
||
uint32_t timeout_m;
|
||
uint32_t task_num;
|
||
uint32_t marerr_num;
|
||
marerr_def marerr[21];
|
||
scheme_task_def task[0];
|
||
}scheme_def;
|
||
|
||
#pragma pack()
|
||
|
||
|
||
// 检测序列
|
||
class check_cfg
|
||
{
|
||
public:
|
||
check_cfg();
|
||
~check_cfg();
|
||
void reload();
|
||
bool updata(QString jstring);
|
||
QByteArray tasks_to_byte_array();
|
||
QByteArray tasksid_to_byte_array();
|
||
QByteArray scheme_to_byte_array();
|
||
void scheme_json_to_struct();
|
||
const scheme_def *check_scheme(void){
|
||
if(scheme_==nullptr){
|
||
qWarning()<<"scheme_ ptr is null,application will failed."<<endl;
|
||
}
|
||
return scheme_;
|
||
}
|
||
int check_scheme_size(){
|
||
return scheme_struct_size;
|
||
}
|
||
// 获取检测方案id
|
||
int get_plan_id();
|
||
// 把方案id转化为具体信息
|
||
QString planid_to_String(int id);
|
||
QString get_brief(){return brief;}
|
||
// 获取适配的从机软件版本号
|
||
QList<uint16_t>& get_slave_soft_versions();
|
||
// 获取适配的从机硬件版本号
|
||
QList<uint16_t>& get_slave_hard_versions();
|
||
// 获取方案执行最长时间
|
||
int get_check_time_out();
|
||
// 获取任务id最大值
|
||
uint8_t get_task_id_max();
|
||
// 根据错误号返回错误字符串
|
||
QString get_err_string(int err);
|
||
// 获取检测任务个数
|
||
int get_check_task_num();
|
||
// 根据序列指获取对应的任务参数
|
||
check_task get_task(int index);
|
||
// 返回返回值个数
|
||
int get_return_num(){
|
||
int ret=0;
|
||
for (int i=0;i<tasks.size();i++){
|
||
ret+=tasks[i].get_return_num();
|
||
}
|
||
return ret;
|
||
}
|
||
// 返回返回值参数
|
||
QStringList get_return_info(){
|
||
return check_ret_items;
|
||
}
|
||
// 返回参数错误位 data为原始检测数据(去除16字节执行结果)
|
||
QByteArray returns_to_paramerr(QByteArray data);
|
||
// 返回任务执行结果的json data为原始检测数据(包含16字节执行结果)
|
||
QJsonObject returns_to_json(QByteArray data);
|
||
// 返回执行结果的json字符串
|
||
QString returns_to_jstring(QByteArray data)
|
||
{
|
||
QJsonDocument doc;
|
||
doc.setObject(returns_to_json(data));
|
||
return doc.toJson();
|
||
}
|
||
QString scheme_to_jstring()
|
||
{
|
||
return json_doc.toJson();
|
||
}
|
||
// 返回主错误列表
|
||
QList<check_err> get_ch_merrcode();
|
||
// 错误代码在范围内时返回true并把对应主错误代码添加进l
|
||
bool in_err_range(QList<check_err> &l,uint8_t code);
|
||
private:
|
||
// 提取指定任务的执行结果
|
||
bool get_return_ack_by_index(QByteArray data,int index);
|
||
void clear()
|
||
{
|
||
slave_soft_versions.clear();
|
||
slave_hard_versions.clear();
|
||
errs.clear();
|
||
suberrs.clear();
|
||
tasks.clear();
|
||
check_ret_items.clear();
|
||
}
|
||
private:
|
||
mycfg *cfg_;
|
||
QJsonDocument json_doc;
|
||
QByteArray check_cfg_data;
|
||
|
||
int plan_id;
|
||
QString brief;
|
||
QList<uint16_t> slave_soft_versions;
|
||
QList<uint16_t> slave_hard_versions;
|
||
int time_out_s;// 小板超时时间
|
||
int time_out_m;// 主板超时时间
|
||
uint8_t task_id_max;
|
||
QList<check_err> errs;
|
||
QList<check_suberr> suberrs;
|
||
QList<check_task> tasks;
|
||
|
||
// 检测时产生的错误代码
|
||
QList<uint8_t> ch_errcode;
|
||
|
||
// 返回值项目
|
||
QStringList check_ret_items;
|
||
|
||
// 把方案解析为结构体的形式
|
||
scheme_def *scheme_;
|
||
int scheme_struct_size;
|
||
};
|
||
|
||
|
||
check_cfg *check_plan();
|
||
|
||
|
||
|
||
|
||
#endif // CHECK_CFG_H
|