From 4a70f6469348aa56de6e6dd0984a5e7b66754b1c Mon Sep 17 00:00:00 2001
From: andy <ranchuan1996@qq.com>
Date: Sun, 26 Nov 2023 23:05:35 +0800
Subject: [PATCH] =?UTF-8?q?=E9=87=8D=E6=96=B0=E6=9E=84=E5=BB=BA=E7=9A=84?=
 =?UTF-8?q?=E6=89=B9=E6=A3=80=E4=BB=AA=E4=B8=BB=E6=9D=BF=E7=A8=8B=E5=BA=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 base/base.h               |   2 +-
 base/check_cfg.cpp        | 582 ++++++++++++++++++++++++++++++++++
 base/check_cfg.h          | 651 ++++++++++++++++++++++++++++++++++++++
 base/mycfg.cpp            | 108 ++++++-
 base/mycfg.h              |   8 +-
 checker_host.pro          |  23 +-
 interface/codec.cpp       |  34 ++
 interface/codec.h         |  41 ++-
 interface/codec_m4.cpp    |  91 ++++++
 interface/codec_m4.h      |  18 ++
 interface/codec_slave.cpp |  86 +++++
 interface/codec_slave.h   |  21 ++
 interface/codec_ym.cpp    | 103 ++++--
 interface/codec_ym.h      |  39 +++
 interface/if_tcp.cpp      | 175 ++++++++++
 interface/if_tcp.h        |  31 ++
 interface/interface.cpp   |  28 +-
 interface/interface.h     |  28 +-
 main.cpp                  |   4 +-
 prot/prot_m4.cpp          |  88 ++++++
 prot/prot_m4.h            |  53 ++++
 prot/prot_pc.cpp          |  79 +++++
 prot/prot_pc.h            |  75 +++++
 prot/prot_slave.cpp       |  77 +++++
 prot/prot_slave.h         |  60 ++++
 prot_cmd/cmd_pc.cpp       |  70 ++++
 prot_cmd/cmd_pc.h         |  28 ++
 prot_cmd/cmd_slave.cpp    |  12 +
 prot_cmd/cmd_slave.h      |  14 +
 29 files changed, 2565 insertions(+), 64 deletions(-)
 create mode 100644 base/check_cfg.cpp
 create mode 100644 base/check_cfg.h
 create mode 100644 interface/codec_m4.cpp
 create mode 100644 interface/codec_m4.h
 create mode 100644 interface/codec_slave.cpp
 create mode 100644 interface/codec_slave.h
 create mode 100644 interface/codec_ym.h
 create mode 100644 prot/prot_m4.cpp
 create mode 100644 prot/prot_m4.h
 create mode 100644 prot/prot_pc.cpp
 create mode 100644 prot/prot_pc.h
 create mode 100644 prot/prot_slave.cpp
 create mode 100644 prot/prot_slave.h
 create mode 100644 prot_cmd/cmd_pc.cpp
 create mode 100644 prot_cmd/cmd_pc.h
 create mode 100644 prot_cmd/cmd_slave.cpp
 create mode 100644 prot_cmd/cmd_slave.h

diff --git a/base/base.h b/base/base.h
index 922b439..34b098e 100644
--- a/base/base.h
+++ b/base/base.h
@@ -21,7 +21,7 @@ public:
     char operator [](int index){
         int size=this->size();
         if(index<0) index=size+index;
-        if(index>=size) return char(0);
+        if(index<0||index>=size) return char(0);
         return QByteArray::operator [](index);
     }
     myarray &operator =(const myarray &b){
diff --git a/base/check_cfg.cpp b/base/check_cfg.cpp
new file mode 100644
index 0000000..be1356e
--- /dev/null
+++ b/base/check_cfg.cpp
@@ -0,0 +1,582 @@
+#include "base/check_cfg.h"
+#include "base/mycfg.h"
+#include "base/crc.h"
+#include "QDir"
+
+
+// 配置路径
+#define CFG_PATH mystring("/home/root/config/")
+#define CHECK_CFG_FILE_NAME cfg_->def_check_cfg
+
+
+
+check_range my_json::json_to_range(QJsonValue v){
+    if(v.type()==QJsonValue::Object)
+        return check_range(v.toObject());
+    else{
+        qWarning()<<"json not a object"<<endl;
+        return check_range(0,0);
+    }
+}
+
+check_task my_json::json_to_task(QJsonValue v){
+    if(v.type()==QJsonValue::Object)
+        return check_task(v.toObject());
+    else{
+        qWarning()<<"json not a object"<<endl;
+        return check_task();
+    }
+}
+
+
+check_err my_json::json_to_err(QJsonValue v)
+{
+    if(v.type()==QJsonValue::Object)
+        return check_err(v.toObject());
+    else{
+        qWarning()<<"json not a object"<<endl;
+        return check_err();
+    }
+}
+check_suberr my_json::json_to_suberr(QJsonValue v)
+{
+    if(v.type()==QJsonValue::Object)
+        return check_suberr(v.toObject());
+    else{
+        qWarning()<<"json not a object"<<endl;
+        return check_suberr();
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+check_cfg::check_cfg()
+{
+    this->cfg_=syscfg();
+    this->scheme_=nullptr;
+
+    QDir path;
+    if (!path.exists(CFG_PATH)) {
+        path.mkdir(CFG_PATH);
+    }
+
+    reload();
+
+}
+
+check_cfg::~check_cfg(){
+    if(scheme_!=nullptr){
+        free(scheme_);
+        scheme_=nullptr;
+    }
+}
+
+
+// 把方案转化为结构体
+void check_cfg::scheme_json_to_struct(){
+    if(scheme_!=nullptr){
+        free(scheme_);
+        scheme_=nullptr;
+    }
+    scheme_struct_size=sizeof(scheme_def)+sizeof(scheme_task_def)*get_check_task_num();
+    scheme_=(scheme_def *)calloc(1,scheme_struct_size);
+    if(scheme_){
+        scheme_->plan_id=get_plan_id();
+        scheme_->task_num=get_check_task_num();
+        scheme_->timeout_m=get_check_time_out();
+        scheme_->marerr_num=errs.size();
+        qDebug()<<"scheme,id,task_num="<<scheme_->plan_id<<scheme_->task_num<<endl;
+        for(int i=0;i<scheme_->task_num;i++){
+            scheme_task_def *st=&scheme_->task[i];
+            check_task ct=tasks[i];
+            st->err=ct.get_failed_code();
+            st->item_num=ct.get_return_num();
+            st->taskid=ct.get_task_id();
+            st->taskindex=ct.get_index();
+            QList<uint8_t> ret_errs=ct.get_ret_failed_code();
+            QList<check_range> rangs=ct.get_ranges();
+            int rangs_num=rangs.size();
+            int err_num=ret_errs.size();
+            qDebug()<<"st,err,item_num,taskid,taskindex="<<st->item_num<<st->taskid<<st->taskindex<<endl;
+            for(int i=0;i<st->item_num;i++){
+                qDebug()<<"i="<<i<<endl;
+                if(rangs_num>i){
+                    st->range[i].err=0;
+                    if(err_num>i){
+                        st->range[i].err=ret_errs[i];
+                    }
+                    st->range[i].max=rangs[i].max;
+                    st->range[i].min=rangs[i].min;
+                }else{
+                    st->range[i].err=0;
+                    st->range[i].max=65535;
+                    st->range[i].min=0;
+                }
+            }
+        }
+        qDebug()<<"tran err list."<<endl;
+        for(int i=0;i<scheme_->marerr_num;i++){
+            marerr_def *merr=&scheme_->marerr[i];
+            QList<uint8_t> suberr=errs[i].get_subcodes();
+            merr->err=errs[i].get_code();
+            merr->suberr_num=suberr.size();
+            for(int j=0;j<merr->suberr_num;j++){
+                merr->suberr[j]=suberr[j];
+            }
+        }
+        qDebug()<<"tran slave array."<<endl;
+        QByteArray slave_array=scheme_to_byte_array();
+        uint32_t crc32=crc::crc32(slave_array);
+        slave_array.append(crc32&0xff);
+        slave_array.append((crc32>>8)&0xff);
+        slave_array.append((crc32>>16)&0xff);
+        slave_array.append((crc32>>24)&0xff);
+        memcpy(scheme_->slave_data,slave_array.data(),slave_array.size());
+        qDebug()<<"tran end."<<endl;
+    }else{
+        qWarning()<<"can not calloc."<<endl;
+    }
+}
+
+
+
+// 升级
+bool check_cfg::updata(QString jstring)
+{
+    QFile file;
+    QJsonDocument json_doc;
+    QJsonParseError err;
+    file.setFileName(CHECK_CFG_FILE_NAME);
+    json_doc = QJsonDocument::fromJson(jstring.toUtf8(),&err);
+    if(err.error != QJsonParseError::NoError)
+    {
+        qWarning()<<"parse json failed:"<<err.errorString();
+        qWarning()<<jstring<<endl;
+        return false;
+    }
+    if(file.exists())
+    {
+        if(file.remove()!=true)
+            qWarning()<<"remove file "<<file.fileName()<<"err"<<endl;
+    }
+    if(!file.exists())
+    {
+        file.open(QIODevice::ReadWrite);
+        QTextStream stream(&file);
+        stream.setCodec("utf-8");
+        stream<<json_doc.toJson();
+        file.flush();
+        file.close();
+        system((char *)"sync");
+    }
+    reload();
+    return true;
+}
+
+
+void check_cfg::reload()
+{
+    QFile file;
+    file.setFileName(CHECK_CFG_FILE_NAME);
+    if(file.exists())
+    {
+        file.open(QIODevice::ReadOnly);
+        QTextStream stream(&file);
+        stream.setCodec("utf-8");
+        QString json_str = stream.readAll();
+
+        QJsonParseError err;
+        json_doc = QJsonDocument::fromJson(json_str.toUtf8(),&err);
+        if(err.error != QJsonParseError::NoError)
+        {
+            qWarning()<<"parse json failed:"<<err.errorString();
+            qWarning()<<json_str<<endl;
+        }
+        else
+        {
+            clear();
+            my_json m;
+            QJsonObject json = json_doc.object();
+            JVALUE_TO_INT(plan_id,json.value("PlanID"));
+            JVALUE_TO_STR(brief,json.value("PlanBrief"));
+            m.json_to_list(json,"CheckSoftVersion",slave_soft_versions,&my_json::json_to_u16);
+            m.json_to_list(json,"CheckHardVersion",slave_hard_versions,&my_json::json_to_u16);
+            JVALUE_TO_INT(time_out_s,json.value("TimeOutS"));
+            JVALUE_TO_INT(time_out_m,json.value("TimeOutM"));
+            JVALUE_TO_U8(task_id_max,json.value("TaskIDMax"));
+            m.json_to_list(json,"MajorErrInfo",errs,&my_json::json_to_err);
+            m.json_to_list(json,"SubErrInfo",suberrs,&my_json::json_to_suberr);
+            m.json_to_list(json,"TaskArray",tasks,&my_json::json_to_task);
+            m.json_to_list(json,"CheckerRtvName",check_ret_items,&my_json::json_to_str);
+
+            // 如果返回参数字段为空，则依次统计
+            if(check_ret_items.size()==0){
+                for(int i=0;i<tasks.size();i++){
+                    check_ret_items.append(tasks[i].get_return_info());
+                }
+            }
+
+            // task index应该从0开始依次递增
+            for(int i=0;i<tasks.size();i++)
+            {
+                if(tasks[i].get_index()!=i)
+                {
+                    qWarning()<<"name="<<tasks[i].get_brief()<<" task_index!=[i]"<<endl;
+                }
+            }
+            // 检查子错误与主错误的对应关系
+            ch_errcode.clear();
+            for(int i=0;i<tasks.size();i++){
+                ch_errcode.append(tasks[i].get_failed_code());
+                ch_errcode.append(tasks[i].get_ret_failed_code());
+            }
+            // 查找子错误是否都有对应的描述
+            QSet<uint8_t> s=ch_errcode.toSet();
+            if(s.contains(uint8_t(0)))
+                s.remove(uint8_t(0));
+            QList<uint8_t> d=s.toList();
+            for(int i=0;i<suberrs.size();i++){
+                for(int j=0;j<d.size();j++){
+                    if(suberrs[i]==d[j]){
+                        d.removeAt(j);
+                        break;
+                    }
+                }
+            }
+            if(!d.isEmpty())
+            {
+                qWarning()<<"many suberr have not brief."<<d<<endl;
+            }
+            // 匹配主错误
+            get_ch_merrcode();
+            // 把剩下的子错误全部添加到优先级最低的主错误中
+            errs.last().append(ch_errcode);
+
+            // 生成方案结构体
+            scheme_json_to_struct();
+        }
+        qInfo()<<"check id:"<<planid_to_String(0);
+        file.close();
+    }
+    else
+    {
+        qWarning()<<"check cfg file "<<file.fileName()<<" had lossed"<<endl;
+    }
+}
+
+
+
+
+
+#define TASKS_MAX_SIZE (0x700-4)
+
+// 把任务数据转化为字节数组
+QByteArray check_cfg::tasks_to_byte_array()
+{
+    QByteArray t;
+    for(int i=0;i<tasks.size();i++)
+    {
+        t.append(tasks[i].to_byte_array());
+    }
+    int size=t.size();
+    if(size<TASKS_MAX_SIZE)
+    {
+        t.append(TASKS_MAX_SIZE-size,char(0xff));
+    }
+    else
+    {
+        qWarning()<<"tasks array size too larg."<<endl;
+    }
+    return t;
+}
+
+#define TASKSID_MAX_SIZE (0x100-4)
+// 把任务序号转化为数组
+QByteArray check_cfg::tasksid_to_byte_array()
+{
+    QByteArray t;
+    t.append(plan_id&0xff);
+    t.append((plan_id>>8)&0xff);
+    t.append((plan_id>>16)&0xff);
+    t.append((plan_id>>24)&0xff);
+    for(int i=0;i<tasks.size();i++)
+    {
+        t.append(tasks[i].get_task_id());
+    }
+    int size=t.size();
+    if(size<TASKSID_MAX_SIZE)
+    {
+        t.append(TASKSID_MAX_SIZE-size,char(0xff));
+    }
+    else
+    {
+        qWarning()<<"tasksid array size too larg."<<endl;
+    }
+    return t;
+}
+
+
+// 方案转化为数组
+QByteArray check_cfg::scheme_to_byte_array()
+{
+    QByteArray t;
+    t.append(tasksid_to_byte_array());
+    t.append(4,char(0xff));
+    t.append(tasks_to_byte_array());
+    return t;
+}
+
+
+
+
+// 获取检测方案id
+int check_cfg::get_plan_id()
+{
+    return plan_id;
+}
+// 根据方案获取具体信息，id为0时填充本机方案
+QString check_cfg::planid_to_String(int id)
+{
+    if(id==0) id=plan_id;
+    // 日bit0~bit4 月bit5~bit8 年bit9~bit15
+    int sid=(id>>0)&0x7f;
+    int modele=(id>>7)&0x1f;
+    int chip=(id>>12)&0xf;
+    int day=(id>>16)&0x1f;
+    int month=(id>>21)&0xf;
+    int year=((id>>25)&0x7f)+2022;
+    QString s="%1-%2-%3 id=%4,modele=%5,chip=%6";
+    return s.arg(year).arg(month).arg(day).arg(sid).arg(modele).arg(chip);
+}
+// 获取适配的从机软件版本号
+QList<uint16_t>& check_cfg::get_slave_soft_versions()
+{
+    return slave_soft_versions;
+}
+// 获取适配的从机硬件版本号
+QList<uint16_t>& check_cfg::get_slave_hard_versions()
+{
+    return slave_hard_versions;
+}
+// 获取方案执行最长时间
+int check_cfg::get_check_time_out()
+{
+    return time_out_m;
+}
+// 获取任务id最大值
+uint8_t check_cfg::get_task_id_max()
+{
+    return task_id_max;
+}
+// 根据错误号返回错误字符串
+QString check_cfg::get_err_string(int err)
+{
+    QString r;
+    for(int i=0;i<errs.size();i++)
+    {
+        if(errs[i]==err)
+            r=errs[i]();
+    }
+    if(!r.isEmpty())
+        return r;
+    for(int i=0;i<suberrs.size();i++)
+    {
+        if(suberrs[i]==err)
+            r=suberrs[i]();
+    }
+    if(!r.isEmpty())
+        return r;
+    return QString("未知错误");
+}
+// 获取检测任务个数
+int check_cfg::get_check_task_num()
+{
+    return tasks.size();
+}
+// 根据序列指获取对应的任务参数
+check_task check_cfg::get_task(int index)
+{
+    for(int i=0;i<tasks.size();i++)
+    {
+        if(tasks[i].get_index()==index)
+            return tasks[i];
+    }
+    return check_task();
+    //return tasks[index];
+}
+
+
+
+
+
+QJsonObject check_cfg::returns_to_json(QByteArray data)
+{
+    QJsonObject j;
+    QJsonArray a;
+    // 先是8字节错误结果，再是8字节执行状态1已执行
+    QByteArray d=data.mid(16,data.size()-16);
+    //j.insert("PlanID",plan_id);
+    j.insert("TasksExecuteCode",QString(data.mid(0,8).toHex().toUpper()));
+    ch_errcode.clear();
+    for(int i=0;i<get_check_task_num();)
+    {
+        QJsonObject t;
+        bool ack=get_return_ack_by_index(data,i);
+        check_task task=get_task(i);
+        t=task.returns_to_json(ack,d);
+        ch_errcode.append(task.get_ch_errcode());
+        //qDebug()<<"append err code="<<ch_errcode<<endl;
+        //if(ack==true)
+        {
+            d.remove(0,get_task(i).get_return_num()*2);
+            i++;
+        }
+//            else
+//            {
+//                i=get_task(i).get_err_jump();
+//            }
+        a.append(t);
+    }
+    j.insert("TaskArray",a);
+    QList<check_err> e=get_ch_merrcode();
+//        QJsonArray err_code;
+//        QString err_str;
+//        for(int i=0;i<e.size();i++)
+//        {
+//            err_str=err_str+e[i]()+";";
+//            err_code.append(e[i].get_code());
+//        }
+//        if(err_code.isEmpty()){
+//            j.insert("ErrInfo","ok");
+//            err_code.append(0);
+//        }
+//        else{
+//            j.insert("ErrInfo",err_str);
+//        }
+//        j.insert("ErrCode",err_code);
+    if(e.isEmpty()){
+        j.insert("ErrInfo","ok");
+        j.insert("ErrCode",0);
+    }
+    else{
+        j.insert("ErrInfo",e[0]());
+        j.insert("ErrCode",e[0].get_code());
+    }
+    return j;
+}
+
+
+
+
+QList<check_err> check_cfg::get_ch_merrcode()
+{
+    QList<check_err> l;
+    QSet<uint8_t> s=ch_errcode.toSet();
+    if(s.contains(uint8_t(0)))
+        s.remove(uint8_t(0));
+    ch_errcode=s.toList();
+    //qDebug()<<"mejor errs="<<errs<<endl;
+    for(int i=0;i<ch_errcode.size();)
+    {
+        if(in_err_range(l,ch_errcode[i])==true)
+        {
+            ch_errcode.removeAt(i);
+        }
+        else
+        {
+            i++;
+        }
+    }
+    if(!ch_errcode.isEmpty()){
+        // 有子错误没找到主错误
+        qWarning()<<"many suberr left."<<ch_errcode<<endl;
+    }
+    return l;
+}
+
+
+
+bool check_cfg::in_err_range(QList<check_err> &l,uint8_t code)
+{
+    for(int j=0;j<errs.size();j++)
+    {
+        if(errs[j].in_range(code))
+        {
+            //qDebug()<<"find subcode="<<code<<" in mcode="<<errs[j].get_code()<<endl;
+            l.append(errs[j]);
+            return true;
+        }
+    }
+    qDebug()<<"can not find mcode,subcode="<<code<<endl;
+    return false;
+}
+
+
+bool check_cfg::get_return_ack_by_index(QByteArray data,int index)
+{
+    if(data.size()<8)
+    {
+        qWarning()<<"check values too less."<<endl;
+        return false;
+    }
+    if(index<0||index>=64){
+        qWarning()<<"index out of range."<<endl;
+        return false;
+    }
+    if((data[index/8]&(1<<(index%8)))!=0)
+    {return false;}else{return true;}
+}
+
+
+QByteArray check_cfg::returns_to_paramerr(QByteArray data)
+{
+    QByteArray p;
+    int len=(get_return_num()+7)/8;
+    int index=0;
+    p.append(len,char(0xff));
+    if(data.size()<get_return_num()*2){
+        qWarning()<<"data too less"<<endl;
+        return p;
+    }
+    for(int i=0;i<tasks.size();i++)
+    {
+        QList<check_range> ranges=tasks[i].get_ranges();
+        for(int j=0;j<ranges.size();j++)
+        {
+            int temp=data[index*2]|(data[index*2+1]<<8);
+            if(temp>=ranges[j].min&&temp<=ranges[j].max){
+              p[index/8]=p[index/8]& (~(1<<(index%8)));
+            }else{
+              p[index/8]=p[index/8]|(1<<(index%8));
+            }
+            index++;
+        }
+    }
+    return p;
+}
+
+
+
+static check_cfg *g_check_cfg;
+
+check_cfg *check_plan()
+{
+    if(g_check_cfg==nullptr){
+        g_check_cfg = new check_cfg();
+    }
+    return g_check_cfg;
+}
+
+
+
+
+
diff --git a/base/check_cfg.h b/base/check_cfg.h
new file mode 100644
index 0000000..2b893e8
--- /dev/null
+++ b/base/check_cfg.h
@@ -0,0 +1,651 @@
+#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
diff --git a/base/mycfg.cpp b/base/mycfg.cpp
index e96eb3c..8666a79 100644
--- a/base/mycfg.cpp
+++ b/base/mycfg.cpp
@@ -18,7 +18,6 @@
 
 // 配置文件
 #define CFG_FILE_NAME CFG_PATH+"cfg.json"
-#define CHECK_CFG_FILE_NAME cfg_->def_check_cfg
 
 // 自启动路径
 #define AUTO_START_PATH "/usr/local/QDesktop-fb"
@@ -282,20 +281,111 @@ void mycfg::init_env()
 
 
 
+void mycfg::restart()
+{
+    system("systemctl restart atk-qtapp-start.service");
+}
 
 
 
+void mycfg::reload()
+{
+    QFile file;
+    file.setFileName(CFG_FILE_NAME);
+    if(!file.exists())
+    {
+        file.open(QIODevice::ReadWrite);
+        QTextStream stream(&file);
+        stream.setCodec("utf-8");
+        stream<<to_json();
+        file.close();
+    }
+    else
+    {
+        file.open(QIODevice::ReadOnly);
+        QTextStream stream(&file);
+        stream.setCodec("utf-8");
+        mystring json_str = stream.readAll();
+        to_class(json_str);
+        file.close();
+    }
+}
+
+// 把配置写入json文件
+void mycfg::save()
+{
+    QFile file;
+    file.setFileName(CFG_FILE_NAME);
+    if(file.exists())
+    {
+        if(file.remove()!=true)
+            qWarning()<<"remove file "<<file.fileName()<<"err"<<endl;
+    }
+    file.open(QIODevice::ReadWrite);
+    QTextStream stream(&file);
+    stream.setCodec("utf-8");
+    stream<<to_json();
+    file.flush();
+    file.close();
+    system((char *)"sync");
+}
+
+
+// 把文件保存到配置路径下
+bool mycfg::save_file(mystring name,myarray data){
+    QFile file;
+    file.setFileName(CFG_PATH+name);
+    if(file.exists())
+    {
+        if(file.remove()!=true){
+            qWarning()<<"remove file "<<file.fileName()<<"err"<<endl;
+            return false;
+        }
+    }
+    file.open(QIODevice::ReadWrite);
+    file.write(data);
+    file.flush();
+    file.close();
+    system((char *)"sync");
+
+    return true;
+}
 
 
 
-
-
-
-
-mycfg g_syscfg;
-
-mycfg *syscfg(){
-    return &g_syscfg;
+// 更新生产信息
+void mycfg::updata_produc_info(myarray data)
+{
+    production_info.clear();
+    for(int i=0;i<data.size();i++){
+        production_info.append(data[i]);
+    }
+}
+void mycfg::updata_produc_info(QList<int> data)
+{
+    production_info.clear();
+    for(int i=0;i<data.size();i++){
+        production_info.append(data[i]);
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+mycfg *g_syscfg;
+
+mycfg *syscfg(){
+    if(g_syscfg==nullptr){
+        g_syscfg=new mycfg();
+    }
+    return g_syscfg;
 }
 
 
diff --git a/base/mycfg.h b/base/mycfg.h
index 70fc237..7011c27 100644
--- a/base/mycfg.h
+++ b/base/mycfg.h
@@ -11,8 +11,14 @@ public:
     mycfg();
 
     void to_class(mystring str);
-    mystring to_json();
     void init_env();
+    mystring to_json();
+    void restart();
+    void reload();
+    void save();
+    bool save_file(mystring name,myarray data);
+    void updata_produc_info(myarray data);
+    void updata_produc_info(QList<int> data);
 
     bool tcp_enable;//tcp使能
     mystring server_ip;
diff --git a/checker_host.pro b/checker_host.pro
index 4136917..ee8c3f2 100644
--- a/checker_host.pro
+++ b/checker_host.pro
@@ -1,4 +1,4 @@
-QT       += core gui
+QT       += core gui network serialbus serialport
 
 greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
 
@@ -17,24 +17,41 @@ DEFINES += QT_DEPRECATED_WARNINGS
 
 SOURCES += \
     base/base.cpp \
+    base/check_cfg.cpp \
     base/crc.cpp \
     base/mycfg.cpp \
     interface/codec.cpp \
+    interface/codec_m4.cpp \
+    interface/codec_slave.cpp \
     interface/codec_ym.cpp \
     interface/if_tcp.cpp \
     interface/interface.cpp \
     main.cpp \
-    mainwindow.cpp
+    mainwindow.cpp \
+    prot/prot_m4.cpp \
+    prot/prot_pc.cpp \
+    prot/prot_slave.cpp \
+    prot_cmd/cmd_pc.cpp \
+    prot_cmd/cmd_slave.cpp
 
 HEADERS += \
     base/base.h \
+    base/check_cfg.h \
     base/crc.h \
     base/file.h \
     base/mycfg.h \
     interface/codec.h \
+    interface/codec_m4.h \
+    interface/codec_slave.h \
+    interface/codec_ym.h \
     interface/if_tcp.h \
     interface/interface.h \
-    mainwindow.h
+    mainwindow.h \
+    prot/prot_m4.h \
+    prot/prot_pc.h \
+    prot/prot_slave.h \
+    prot_cmd/cmd_pc.h \
+    prot_cmd/cmd_slave.h
 
 FORMS += \
     mainwindow.ui
diff --git a/interface/codec.cpp b/interface/codec.cpp
index e69de29..cf2cbd5 100644
--- a/interface/codec.cpp
+++ b/interface/codec.cpp
@@ -0,0 +1,34 @@
+
+#include "interface/codec.h"
+
+
+
+
+
+
+
+Codec *codecFind(const char *name)
+{
+    extern const int __start_codecdef;
+    extern const int __stop_codecdef;
+    codec_def *start=(codec_def *)&__start_codecdef;
+    codec_def *end=(codec_def *)&__stop_codecdef;
+  codec_def *item = 0;
+  for (item=start;item<end;item++)
+  {
+    if (item != nullptr)
+    {
+      if (strcmp(name, item->name) == 0)
+        return item->codec_get_fun();
+    }
+  }
+  qWarning("can not find codec named '%s'", name);
+  return nullptr;
+}
+
+
+
+
+
+
+
diff --git a/interface/codec.h b/interface/codec.h
index cb2f129..aa81d4d 100644
--- a/interface/codec.h
+++ b/interface/codec.h
@@ -13,9 +13,16 @@ public:
     fullFrame = false;
   }
   virtual ~Codec() {}
-  virtual myarray encode(int srcAddr, int dstAddr, int cmd, myarray data) = 0;
-  virtual myarray decode(int &srcAddr, int &dstAddr, int &cmd, myarray data) = 0;
-  virtual myarray decode(int &srcAddr, int &dstAddr, int &cmd)
+  // 返回true,则是一个完整的帧
+//  virtual bool packCheck(myarray data){return false;}
+//  virtual bool recvByte(int byte){return false;}
+//  virtual myarray encode(int srcAddr, int dstAddr, int cmd, myarray data){return myarray();}
+//  virtual myarray decode(int &srcAddr, int &dstAddr, int &cmd, myarray data){return myarray();}
+  virtual bool packCheck(myarray data)=0;
+  virtual bool recvByte(int byte)=0;
+  virtual myarray encode(int srcAddr, int dstAddr, int cmd, myarray data)=0;
+  virtual myarray decode(int &srcAddr, int &dstAddr, int &cmd, myarray data)=0;
+  myarray decode(int &srcAddr, int &dstAddr, int &cmd)
   {
     if (fullFrame == true)
     {
@@ -24,11 +31,37 @@ public:
     }
     return myarray();
   }
-  virtual bool recvByte(int byte) = 0;
 
 protected:
   bool fullFrame;
   myarray data;
 };
 
+
+
+
+Codec *codecFind(const char *name);
+
+
+
+
+typedef struct{
+    const char *name;
+    Codec *(*codec_get_fun)();
+}codec_def;
+
+
+#define codec_export(name_,fun_) \
+  const static char __codec_##name_##_name[] __attribute__((section(".rodata.codecstr"))) = #name_; \
+  __attribute__((used)) static codec_def _codec_##name_ __attribute__((section("codecdef")))={\
+  .name=__codec_##name_##_name,\
+  .codec_get_fun=fun_,\
+}
+
+
+
+
+
+
+
 #endif // CODEC_H
diff --git a/interface/codec_m4.cpp b/interface/codec_m4.cpp
new file mode 100644
index 0000000..1d3382b
--- /dev/null
+++ b/interface/codec_m4.cpp
@@ -0,0 +1,91 @@
+#include "codec_m4.h"
+#include "QDebug"
+
+
+bool codec_m4::recvByte(int byte)
+{
+    bool ack = false;
+    if (fullFrame == true)
+    {
+      return fullFrame;
+    }
+    data.append(byte);
+    switch (data.size()) {
+    case 1:
+        if(uint8_t(data[0])==0xff)
+        {
+            num_to_read=2;
+        }
+        else
+        {
+            data.remove(0,1);
+            num_to_read=0;
+        }
+        break;
+    case 2:
+        {
+            int len=data[1];
+            num_to_read=len+2;
+        }
+        break;
+    default:
+        break;
+    }
+    // 此时一帧数据已完成
+    if(num_to_read>0&&num_to_read==data.size())
+    {
+        data.remove(0,2);
+        qDebug()<<"recv_m4:"<<QString(data)<<endl;
+        ack=true;
+        num_to_read=0;
+    }
+    fullFrame=ack;
+    return fullFrame;
+}
+
+
+
+bool codec_m4::packCheck(myarray data)
+{
+    if(data[0]!=0xff){
+        return false;
+    }
+    if(data.size()>=2&&(data.size()==(data[1]+2))){
+        return true;
+    }
+    return false;
+}
+
+myarray codec_m4::encode(int srcAddr, int dstAddr, int cmd, myarray data)
+{
+    myarray r;
+    r.append(0xff);
+    r.append(char(data.size()));
+    r.append(data);
+    return r;
+}
+myarray codec_m4::decode(int &srcAddr, int &dstAddr, int &cmd, myarray data)
+{
+    if(packCheck(data)){
+        return myarray(data.mid(2));
+    }
+}
+
+
+
+Codec *codec_get()
+{
+    static Codec *codec_=nullptr;
+    if(codec_==nullptr){
+        codec_=new codec_m4();
+    }
+    return codec_;
+}
+
+
+codec_export(codec_m4,codec_get);
+
+
+
+
+
diff --git a/interface/codec_m4.h b/interface/codec_m4.h
new file mode 100644
index 0000000..5bfeb60
--- /dev/null
+++ b/interface/codec_m4.h
@@ -0,0 +1,18 @@
+#ifndef CODEC_M4_H
+#define CODEC_M4_H
+#include "interface/codec.h"
+
+
+class codec_m4:public Codec
+{
+public:
+    codec_m4(){num_to_read=0;}
+    virtual bool packCheck(myarray data);
+    virtual bool recvByte(int byte);
+    virtual myarray encode(int srcAddr, int dstAddr, int cmd, myarray data);
+    virtual myarray decode(int &srcAddr, int &dstAddr, int &cmd, myarray data);
+protected:
+    int num_to_read;
+};
+
+#endif // CODEC_M4_H
diff --git a/interface/codec_slave.cpp b/interface/codec_slave.cpp
new file mode 100644
index 0000000..22cba98
--- /dev/null
+++ b/interface/codec_slave.cpp
@@ -0,0 +1,86 @@
+#include "codec_slave.h"
+#include "base/crc.h"
+
+
+myarray codec_slave::encode(int srcAddr, int dstAddr, int cmd, myarray data)
+{
+    Q_UNUSED(srcAddr);
+    myarray t;
+    uint16_t len=data.size()+10;
+    cmd_no++;
+
+    t.append('Y');
+    t.append('e');
+    t.append(len&0xff);
+    t.append(len>>8);
+    t.append(char(0));// 源地址
+    t.append(char(dstAddr&0xff));// 目标地址
+    t.append(cmd);// 命令码
+    t.append(cmd_no&0xff);
+    t.append(cmd_no>>8);
+    t.append(data);
+    t.append(crc::crc8((uint8_t *)t.data(),t.size()));
+    return t;
+}
+
+
+myarray codec_slave::decode(int &srcAddr, int &dstAddr, int &cmd, myarray data)
+{
+    myarray r;
+    QString str_err="ok";
+    if(data.size()<10)
+    {
+        // 一帧数据至少10字节
+        qWarning("recv data len too less");
+        str_err="recv data len too less.";
+        return r;
+    }
+    uint16_t len=data[2]|(data[3]<<8);
+    uint8_t crc=crc::crc8((uint8_t *)data.data(),data.size()-1);
+    if(len!=data.size())
+    {
+        // 如果长度不相等则产生了数据丢失
+        qWarning("recv data have lossed");
+        str_err="recv data have lossed.";
+        return r;
+    }
+    srcAddr=data[4];
+    dstAddr=data[5];
+    uint16_t no=data[7]|(data[8]<<8);
+    uint16_t h_no=cmd_no;
+    if(no!=h_no)
+    {
+        // 发送一条指令应等待其返回，此时流水号应相同
+        //qWarning()<<"alave_addr="<<src_addr<<" cmd_no error:host="<<h_no<<",slave="<<no<<endl;
+        //return r;
+        //str_err="cmd no err.";
+    }
+    if(crc!=uint8_t(data[len-1]))
+    {
+        // crc校验不对
+        qWarning("recv data crc check error:%02x,%02x",crc,uint8_t(data[len-1]));
+        qWarning("data=%s",data.toHex(' ').data());
+        str_err="crc check err.";
+    }
+    cmd=data[6];
+    r=data.mid(9,len-10);
+    return r;
+}
+
+
+
+Codec *codec_slave_get()
+{
+    static Codec *codec_=nullptr;
+    if(codec_==nullptr){
+        codec_=new codec_slave();
+    }
+    return codec_;
+}
+
+
+codec_export(codec_slave,codec_slave_get);
+
+
+
+
diff --git a/interface/codec_slave.h b/interface/codec_slave.h
new file mode 100644
index 0000000..15ed5ce
--- /dev/null
+++ b/interface/codec_slave.h
@@ -0,0 +1,21 @@
+#ifndef CODEC_SLAVE_H
+#define CODEC_SLAVE_H
+
+#include "interface/codec.h"
+
+
+class codec_slave: public Codec
+{
+public:
+    codec_slave(): Codec(){
+
+    }
+    virtual bool packCheck(myarray data){return false;}
+    virtual bool recvByte(int byte){return false;}
+    virtual myarray encode(int srcAddr, int dstAddr, int cmd, myarray data);
+    virtual myarray decode(int &srcAddr, int &dstAddr, int &cmd, myarray data);
+protected:
+    uint16_t cmd_no;
+};
+
+#endif // CODEC_SLAVE_H
diff --git a/interface/codec_ym.cpp b/interface/codec_ym.cpp
index 8863259..2b13e41 100644
--- a/interface/codec_ym.cpp
+++ b/interface/codec_ym.cpp
@@ -1,18 +1,10 @@
 
 #include "codec.h"
+#include "base/crc.h"
+#include "interface/codec_ym.h"
 
-class CodecYm : public Codec
-{
-  Q_OBJECT
-public:
-  CodecYm() : Codec()
-  {
-    is_big_data = false;
-    num_to_read = 0;
-  }
-  ~CodecYm() {}
   // 重载接收字节函数
-  bool recvByte(int byte)
+  bool CodecYm::recvByte(int byte)
   {
     bool ack = false;
     if (fullFrame == true)
@@ -74,26 +66,38 @@ public:
     return fullFrame;
   }
   // 重载解码函数
-  QByteArray decode(int &srcAddr, int &dstAddr, int &cmd, QByteArray data)
+  myarray CodecYm::decode(int &srcAddr, int &dstAddr, int &cmd, myarray data)
   {
     Q_UNUSED(srcAddr);
     Q_UNUSED(dstAddr);
-    QByteArray r;
+    myarray r;
+    if(packCheck(data)==true){
+        cmd=this->cmd;
+        if (is_big_data == false)
+          r = data.mid(7, len - 3);
+        else
+          r = data.mid(11, len - 7);
+    }
+    return r;
+  }
+  bool CodecYm::packCheck(myarray data)
+  {
+    bool ack=false;
     if (data.size() < 9)
     {
       // 主机一帧数据至少9字节
       qWarning("recv data len too less");
-      return r;
+      return ack;
     }
 
     if ((uint8_t(data[0]) != 0x59u) || (uint8_t(data[1]) != 0x6du))
     {
       // 帧头不对
       qWarning("frame head not 0x59 0x6d");
-      return r;
+      return ack;
     }
 
-    int len = (data[2] | (data[3] << 8));
+    len = (data[2] | (data[3] << 8));
     if (len == 65535)
     {
       // 重新设置数据长度
@@ -108,10 +112,10 @@ public:
     {
       // 如果长度不相等则产生了数据丢失
       qWarning("recv data have lossed");
-      return r;
+      return ack;
     }
     uint8_t chk_a = 0, chk_b = 0;
-    // crc::crc16((uint8_t *)data.data(),2,len+4,&chk_a,&chk_b);
+    crc::crc16((uint8_t *)data.data(),2,len+4,&chk_a,&chk_b);
     if (chk_a != uint8_t(data[data.size() - 2]) || chk_b != uint8_t(data[data.size() - 1]))
     {
       // crc校验不对
@@ -122,15 +126,58 @@ public:
     cmd_no = data[5] | (data[6] << 8);
     cmd = data[4];
     // 数据负载
-    if (is_big_data == false)
-      r = data.mid(7, len - 3);
-    else
-      r = data.mid(11, len - 7);
-    return r;
+    return true;
+  }
+  myarray CodecYm::encode(int srcAddr, int dstAddr, int cmd, myarray data)
+  {
+      Q_UNUSED(srcAddr);
+      Q_UNUSED(dstAddr);
+      myarray t;
+      uint32_t len=data.size()+3;
+
+      t.append(0x59u);
+      t.append(0x6du);
+      t.append(0x43u);
+      if(len<65535)
+      {
+          t.append((len)&0xff);
+          t.append((len)>>8);
+          t.append(cmd);
+          t.append(cmd_no&0xff);
+          t.append(cmd_no>>8);
+      }else{
+          len+=4;
+          t.append(0xff);
+          t.append(0xff);
+          t.append(cmd);
+          t.append(cmd_no&0xff);
+          t.append(cmd_no>>8);
+          t.append(len&0xff);
+          t.append((len>>8)&0xff);
+          t.append((len>>16)&0xff);
+          t.append((len>>24)&0xff);
+      }
+      t.append(data);
+      uint8_t chk_a,chk_b;
+      crc::crc16((uint8_t *)t.data(),3,len+5,&chk_a,&chk_b);
+      t.append(chk_a);
+      t.append(chk_b);
+      return t;
   }
 
-private:
-  bool is_big_data;
-  int num_to_read;
-  int cmd_no;
-};
+
+
+
+Codec *codec_ym_get()
+{
+    static Codec *codec_=nullptr;
+    if(codec_==nullptr){
+        codec_=new CodecYm();
+    }
+    return codec_;
+}
+
+
+codec_export(codec_ym,codec_ym_get);
+
+
diff --git a/interface/codec_ym.h b/interface/codec_ym.h
new file mode 100644
index 0000000..f354b39
--- /dev/null
+++ b/interface/codec_ym.h
@@ -0,0 +1,39 @@
+#ifndef CODEC_YM_H
+#define CODEC_YM_H
+
+#include "interface/codec.h"
+
+class CodecYm : public Codec
+{
+  Q_OBJECT
+public:
+  CodecYm() : Codec()
+  {
+    is_big_data = false;
+    num_to_read = 0;
+  }
+  ~CodecYm() {}
+  // 重载接收字节函数
+  bool recvByte(int byte);
+  // 重载解码函数
+  myarray decode(int &srcAddr, int &dstAddr, int &cmd, myarray data);
+  bool packCheck(myarray data);
+  myarray encode(int srcAddr, int dstAddr, int cmd, myarray data);
+private:
+  bool is_big_data;
+  int num_to_read;
+  int cmd_no;
+  int cmd;
+  int len;
+};
+
+
+
+
+
+
+
+
+
+
+#endif // CODEC_YM_H
diff --git a/interface/if_tcp.cpp b/interface/if_tcp.cpp
index b3671e3..0ab1372 100644
--- a/interface/if_tcp.cpp
+++ b/interface/if_tcp.cpp
@@ -1,11 +1,186 @@
 #include "if_tcp.h"
+#include "QNetworkConfigurationManager"
+#include "QThread"
 
 if_tcp::if_tcp()
 {
+    this->connect_state=false;
+    this->timer_reconnect_=nullptr;
+    this->tcp_socket_=nullptr;
+    this->reconnect_timeout_ms=10000;
+    this->cfg_=syscfg();
 
+    this->timer_recv_end_=nullptr;
+    this->recv_end_timeout_ms=100;
+    qDebug("tcp created.");
 }
 
 if_tcp::~if_tcp()
 {
   
 }
+
+
+void if_tcp::init()
+{
+    if(nullptr == timer_reconnect_)
+    {
+        timer_reconnect_ = new QTimer(this);
+
+        connect(timer_reconnect_, &QTimer::timeout, this, &if_tcp::reconnect_cb);
+    }
+    timer_reconnect_->start(reconnect_timeout_ms);
+
+
+    if(nullptr == tcp_socket_)
+    {
+        tcp_socket_ = new QTcpSocket(this);
+        connect(tcp_socket_, SIGNAL(connected()), this, SLOT(connected_cb()));
+        connect(tcp_socket_, SIGNAL(disconnected()), this, SLOT(disconnected_cb()));
+        connect(tcp_socket_, SIGNAL(stateChanged(QAbstractSocket::SocketState)), this, SLOT(state_changed_cb(QAbstractSocket::SocketState)));
+        connect(tcp_socket_, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(on_error_cb(QAbstractSocket::SocketError)));
+        connect(tcp_socket_, SIGNAL(readyRead()), this, SLOT(ready_read_cb()));
+
+
+        tcp_socket_->setSocketOption(QAbstractSocket::LowDelayOption, 1);// 禁用Nagle算法.
+        tcp_socket_->setSocketOption(QAbstractSocket::KeepAliveOption, 1);
+        if(cfg_->tcp_enable)
+            tcp_socket_->connectToHost(QHostAddress(cfg_->server_ip), cfg_->server_port);
+    }
+
+}
+
+
+
+// 获取本机地址
+QString if_tcp::get_local_ip()
+{
+    QList<QNetworkInterface> network =QNetworkInterface::allInterfaces();
+    foreach (QNetworkInterface  net, network)
+    {
+        QString netName=net.humanReadableName();
+        if(netName=="eth0")
+        {
+            QList<QNetworkAddressEntry> list=net.addressEntries();          // 获取IP地址与子掩码等
+            foreach(QNetworkAddressEntry address,list)
+            {
+                if(address.ip().protocol()==QAbstractSocket::IPv4Protocol)  // 获取IPv4的地址
+                {
+                    return address.ip().toString();
+                }
+            }
+
+        }
+    }
+    return QString();
+}
+
+
+
+void if_tcp::reconnect_cb()
+{
+    if(connect_state!=true)
+    {
+        QNetworkConfigurationManager mgr;
+        if(mgr.isOnline()==true)
+        {
+            if(cfg_->tcp_enable){
+                qDebug("network is online.");
+                tcp_socket_->connectToHost(QHostAddress(cfg_->server_ip), cfg_->server_port);
+            }
+        }
+        else
+        {
+            if(cfg_->tcp_enable){
+                qDebug("network is not online.");
+            }
+        }
+        // 设置为配置的ip地址
+        //if(QHostAddress(get_local_ip())!=QHostAddress(local_ip))
+        if(get_local_ip().isEmpty())
+        {
+            qDebug("modify local ip addr.");
+            QString str="ifconfig eth0 %1";
+            system(str.arg(cfg_->local_ip).toLocal8Bit().data());
+            str="route add default gw %1";
+            system(str.arg(cfg_->gateway_ip).toLocal8Bit().data());
+        }
+    }
+}
+
+
+
+void if_tcp::connected_cb()
+{
+    timer_reconnect_->start();
+    connect_state=true;
+    emit tcp_connected_signal();
+    qInfo("connected");
+}
+
+void if_tcp::disconnected_cb()
+{
+    connect_state=false;
+    qInfo("disconnected");
+}
+
+void if_tcp::state_changed_cb(QAbstractSocket::SocketState nSocketState)
+{
+    qInfo("state changed:%d",nSocketState);
+}
+
+
+void if_tcp::on_error_cb(QAbstractSocket::SocketError nErrCode)
+{
+    connect_state=false;
+    qWarning("on error:%d",nErrCode);
+}
+
+
+
+void if_tcp::ready_read_cb()
+{
+    QByteArray data = tcp_socket_->readAll();
+    timer_reconnect_->start();
+    if(irq_fun){
+        irq_fun(myarray(data));
+    }
+//    qInfo()<< "recv data from tcp:"<<crc::byte_array_to_string(recv)<<endl;
+}
+
+
+
+int if_tcp::write(myarray data)
+{
+    if(nullptr == tcp_socket_ || false == connect_state)
+    {
+        //qWarning() << "Can’t send data , TcpClient socket not connect.";
+        return 0;
+    }
+
+    int wb = tcp_socket_->write(data);
+    if(!tcp_socket_->flush())
+    {
+        //connect_state=false;
+        qWarning("write fial:[%s]",data.toHex(' ').data());
+    }
+    else
+    {
+        timer_reconnect_->start();
+    }
+    return wb;
+}
+
+
+InterFace *if_tcp_get()
+{
+    static InterFace *if_=nullptr;
+    if(if_==nullptr){
+        if_=new if_tcp();
+        QTimer::singleShot(0,if_,&if_->init);
+    }
+    return if_;
+}
+
+
+if_export(tcp,if_tcp_get);
diff --git a/interface/if_tcp.h b/interface/if_tcp.h
index 4248e39..95fb90a 100644
--- a/interface/if_tcp.h
+++ b/interface/if_tcp.h
@@ -3,6 +3,14 @@
 
 #include <QObject>
 #include <interface/interface.h>
+#include "QTimer"
+#include <QNetworkInterface>
+#include <QTcpSocket>
+#include <QObject>
+#include <QThread>
+#include <QTimer>
+#include "QByteArray"
+#include "base/mycfg.h"
 
 class if_tcp : public InterFace
 {
@@ -10,8 +18,31 @@ class if_tcp : public InterFace
 public:
   if_tcp();
   virtual ~if_tcp();
+  void init();
+  int write(myarray data);
 
 protected:
+  QString get_local_ip();
+
+protected slots:
+  void reconnect_cb();
+  void connected_cb();
+  void disconnected_cb();
+  void state_changed_cb(QAbstractSocket::SocketState nSocketState);
+  void on_error_cb(QAbstractSocket::SocketError nErrCode);
+  void ready_read_cb();
+signals:
+  void tcp_connected_signal();
+protected:
+  mycfg *cfg_;
+  QTimer *timer_reconnect_;
+  int reconnect_timeout_ms;
+  QTcpSocket *tcp_socket_;
+  bool connect_state;
+
+  QTimer *timer_recv_end_;
+  int recv_end_timeout_ms;
+
 };
 
 #endif // IF_TCP_H
diff --git a/interface/interface.cpp b/interface/interface.cpp
index 782d132..fc3df85 100644
--- a/interface/interface.cpp
+++ b/interface/interface.cpp
@@ -3,30 +3,30 @@
 #include "string.h"
 #include "QDebug"
 
-typedef struct
-{
-  InterFace *interface;
-  const char *name;
-} self_table_def;
 
-static self_table_def g_self_table[] =
-    {
-        {.interface = 0, .name = "default"},
-};
+
+
+
 
 InterFace *interFaceFind(const char *name)
 {
-  int num = sizeof(g_self_table) / sizeof(g_self_table[0]);
-  self_table_def *item = 0;
-  for (int i = 0; i < num; i++)
+    extern const int __start_ifdef;
+    extern const int __stop_ifdef;
+    if_def *start=(if_def *)&__start_ifdef;
+    if_def *end=(if_def *)&__stop_ifdef;
+  if_def *item = 0;
+  for (item=start;item<end;item++)
   {
-    item = &g_self_table[i];
     if (item != nullptr)
     {
       if (strcmp(name, item->name) == 0)
-        return item->interface;
+        return item->if_get_fun();
     }
   }
   qWarning("can not find interface named '%s'", name);
   return nullptr;
 }
+
+
+
+
diff --git a/interface/interface.h b/interface/interface.h
index e447dec..9202c6e 100644
--- a/interface/interface.h
+++ b/interface/interface.h
@@ -3,23 +3,45 @@
 
 #include <QObject>
 #include "base/base.h"
+#include "interface/codec.h"
 
 using namespace std;
 using namespace std::placeholders;
 
-typedef std::function<void(void)> irq_cb;
+typedef std::function<void(myarray data)> irq_cb;
 
 class InterFace : public QObject
 {
   Q_OBJECT
 public:
-  InterFace() {}
+  InterFace() {irq_fun=nullptr;}
   virtual ~InterFace() {}
   virtual void init() = 0;
   virtual int write(myarray data) = 0;
-  virtual void set_irq(irq_cb fun, myarray &data) = 0;
+  virtual void set_irq(irq_cb fun){
+      this->irq_fun=fun;
+  }
+protected:
+  irq_cb irq_fun;
 };
 
 InterFace *interFaceFind(const char *name);
 
+
+typedef struct{
+    const char *name;
+    InterFace *(*if_get_fun)();
+}if_def;
+
+
+#define if_export(name_,fun_) \
+  const static char __if_##name_##_name[] __attribute__((section(".rodata.ifstr"))) = #name_; \
+  __attribute__((used)) static if_def _if_##name_ __attribute__((section("ifdef")))={\
+  .name=__if_##name_##_name,\
+  .if_get_fun=fun_,\
+}
+
+
+
+
 #endif // INTERFACE_H
diff --git a/main.cpp b/main.cpp
index 0bcaa31..0088a1e 100644
--- a/main.cpp
+++ b/main.cpp
@@ -6,6 +6,7 @@
 #include <QTextCodec>
 #include "base/base.h"
 #include "base/mycfg.h"
+#include "interface/interface.h"
 
 #define log(fmt, ...)                                    \
   {                                                      \
@@ -52,7 +53,8 @@ int main(int argc, char *argv[])
   //    Test test;
   //    test.bind();
 
-  qDebug("local ip=%s",syscfg()->local_ip);
+  qDebug("local ip=%s",syscfg()->local_ip.data());
+  InterFace *if_=interFaceFind("tcp");
 
   return app.exec();
 }
diff --git a/prot/prot_m4.cpp b/prot/prot_m4.cpp
new file mode 100644
index 0000000..358a00c
--- /dev/null
+++ b/prot/prot_m4.cpp
@@ -0,0 +1,88 @@
+#include "prot_m4.h"
+#include "QDebug"
+
+
+
+void prot_m4::init()
+{
+    if_=interFaceFind("uart_m4");
+    codec_=codecFind("codec_m4");
+
+    if_->set_irq([=](myarray recv){
+        if(codec_->packCheck(recv_data)==true){
+            int cmd,src,dst;
+            myarray data=codec_->decode(src,dst,cmd,recv_data);
+            if(exe_cb_fun(data)==false){
+                qWarning("can not find cb fun with:\"%s\"",data);
+            }
+            recv_data.clear();
+        }
+    });
+}
+
+void prot_m4::send_data_slot(myarray data)
+{
+    if((if_!=nullptr)&&(codec_!=nullptr)){
+        myarray send=codec_->encode(0,0,0,data);
+        if_->write(send);
+    }
+}
+
+
+bool prot_m4::exe_cb_fun(myarray data)
+{
+    int left;
+    for (int i=0;i<funs.size();i++){
+        left=funs[i].cmd.size();
+        if(data.left(left)==funs[i].cmd){
+            if(funs[i].fun!=nullptr){
+                funs[i].fun(myarray(data.mid(left)));
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+static prot_m4 *g_protm4;
+prot_m4 *protM4(){
+    if(g_protm4==nullptr){
+        g_protm4=new prot_m4();
+        g_protm4->init();
+    }
+    return g_protm4;
+}
+
+
+
+bool prot_m4::set_irq_fun(prot_m4_cb fun,myarray data)
+{
+    int left;
+    for (int i=0;i<funs.size();i++){
+        left=funs[i].cmd.size();
+        if(data.left(left)==funs[i].cmd){
+            return false;
+        }
+    }
+    HandleM4_def m4_cmd;
+    m4_cmd.cmd=data;
+    m4_cmd.fun=fun;
+    funs.append(m4_cmd);
+    return true;
+}
+
+bool prot_m4::del_irq_fun(prot_m4_cb fun,myarray data)
+{
+    int left;
+    for (int i=0;i<funs.size();i++){
+        left=funs[i].cmd.size();
+        if(data.left(left)==funs[i].cmd){
+            funs.removeAt(i);
+            return true;
+        }
+    }
+    return false;
+}
+
+
+
diff --git a/prot/prot_m4.h b/prot/prot_m4.h
new file mode 100644
index 0000000..829e2ee
--- /dev/null
+++ b/prot/prot_m4.h
@@ -0,0 +1,53 @@
+#ifndef PROT_M4_H
+#define PROT_M4_H
+
+
+#include "QObject"
+#include "base/base.h"
+#include "QList"
+#include "interface/codec.h"
+#include "interface/interface.h"
+#include "base/mycfg.h"
+#include "QThread"
+
+
+
+using namespace std;
+using namespace std::placeholders;
+
+typedef std::function<void(myarray data)> prot_m4_cb;
+
+
+typedef struct{
+    prot_m4_cb fun;
+    myarray cmd;
+}HandleM4_def;
+
+
+
+class prot_m4:public QObject
+{
+public:
+    prot_m4(){if_=nullptr;}
+    ~prot_m4(){}
+    void init();
+    bool set_irq_fun(prot_m4_cb fun,myarray data);
+    bool del_irq_fun(prot_m4_cb fun,myarray data);
+public slots:
+    void send_data_slot(myarray data);
+protected:
+    bool exe_cb_fun(myarray data);
+protected:
+    InterFace *if_;
+    QList<HandleM4_def> funs;
+    Codec *codec_;
+    QThread thread;
+    myarray recv_data;
+};
+
+
+prot_m4 *protM4();
+
+#endif // PROT_M4_H
+
+
diff --git a/prot/prot_pc.cpp b/prot/prot_pc.cpp
new file mode 100644
index 0000000..7034160
--- /dev/null
+++ b/prot/prot_pc.cpp
@@ -0,0 +1,79 @@
+
+
+#include "prot_pc.h"
+#include "QDebug"
+
+
+HandlePc *handlePcFind(int cmd)
+{
+    extern const int __start_protpc;
+    extern const int __stop_protpc;
+    handlepc_def *start=(handlepc_def *)&__start_protpc;
+    handlepc_def *end=(handlepc_def *)&__stop_protpc;
+  handlepc_def *item = 0;
+  for (item=start;item<end;item++)
+  {
+    if (item != nullptr)
+    {
+      if (item->cmd==cmd)
+        return item->handle_get_fun();
+    }
+  }
+  qWarning("can not find protpc cmd= '%02x'", cmd);
+  return nullptr;
+}
+
+protpc_export(0xff,nullptr);
+
+
+void ProtPc::init()
+{
+    if_=interFaceFind("tcp");
+    codec_=codecFind("codec_ym");
+
+    if_->set_irq([=](myarray recv){
+        recv_data+=recv;
+        if(codec_->packCheck(recv_data)==true){
+            int cmd,src,dst;
+            myarray data=codec_->decode(src,dst,cmd,recv_data);
+            if(handle_!=nullptr){
+                if(handle_->busy==0){
+                    disconnect(handle_,&HandlePc::send_data_signal,this,send_data_slot);
+                    delete handle_;
+                }else{
+                    qWarning("prot_pc is busy.");
+                    return;
+                }
+            }
+            handle_=handlePcFind(cmd);
+            if(handle_!=nullptr){
+                connect(handle_,&HandlePc::send_data_signal,this,send_data_slot);
+                handle_->dolater(cmd,data);
+            }
+            recv_data.clear();
+        }
+    });
+}
+
+void ProtPc::send_data_slot(int cmd,myarray data)
+{
+    if((if_!=nullptr)&&(codec_!=nullptr)){
+        myarray send=codec_->encode(0,0,cmd,data);
+        if_->write(send);
+    }
+}
+
+
+
+static ProtPc *g_protpc;
+ProtPc *protPc(){
+    if(g_protpc==nullptr){
+        g_protpc=new ProtPc();
+        g_protpc->init();
+    }
+    return g_protpc;
+}
+
+
+
+
diff --git a/prot/prot_pc.h b/prot/prot_pc.h
new file mode 100644
index 0000000..9d4709e
--- /dev/null
+++ b/prot/prot_pc.h
@@ -0,0 +1,75 @@
+
+
+#ifndef prot_pc_h__
+#define prot_pc_h__
+
+#include "QObject"
+#include "base/base.h"
+#include "QList"
+#include "interface/codec.h"
+#include "interface/interface.h"
+#include "base/mycfg.h"
+#include "QThread"
+
+
+// 定义处理命令的类
+class HandlePc:public QObject{
+  Q_OBJECT
+public:
+  HandlePc(){busy=0;}
+  virtual ~HandlePc(){}
+  virtual int dolater(int cmd,myarray data)=0;
+  int busy;
+signals:
+  void send_data_signal(int cmd,myarray data);
+};
+
+
+
+
+
+
+class ProtPc:public QObject{
+  Q_OBJECT
+public:
+  ProtPc(){if_=nullptr;codec_=nullptr;handle_=nullptr;}
+  ~ProtPc(){}
+  void init();
+protected slots:
+  void send_data_slot(int cmd,myarray data);
+protected:
+  InterFace *if_;
+  Codec *codec_;
+  HandlePc *handle_;
+  QThread thread;
+  myarray recv_data;
+};
+
+
+ProtPc *protPc();
+
+
+
+
+
+typedef struct{
+    int cmd;
+    HandlePc *(*handle_get_fun)();
+}handlepc_def;
+
+
+
+#define protpc_export(cmd_,fun_) \
+  __attribute__((used)) static handlepc_def _handlepc_##name_ __attribute__((section("protpc")))={\
+  .cmd=cmd_,\
+  .handle_get_fun=fun_,\
+}
+
+
+
+
+
+#endif
+
+
+
diff --git a/prot/prot_slave.cpp b/prot/prot_slave.cpp
new file mode 100644
index 0000000..66b1af2
--- /dev/null
+++ b/prot/prot_slave.cpp
@@ -0,0 +1,77 @@
+#include "prot_slave.h"
+#include "QDebug"
+
+
+
+
+void prot_slave::init()
+{
+    if_=interFaceFind("can");
+    codec_=codecFind("codec_slave");
+    mycfg *cfg_=syscfg();
+    for(int i=0;i<cfg_->slave_num;i++){
+        slaves.append(nullptr);
+    }
+    if_->set_irq([=](myarray recv){
+        if(codec_->packCheck(recv)==true){
+            int cmd,src,dst;
+            HandleSlave *handle=nullptr;
+            myarray data=codec_->decode(src,dst,cmd,recv);
+            if((src>slaves.size())||(src<=0)){
+                qWarning("slave addr err:%d",src);
+            }else{
+                handle=slaves[src-1];
+                if(handle!=nullptr){
+                    handle->dolater(cmd,data);
+                }else{
+                    qWarning("slave addr=%d not have handle.",src);
+                }
+            }
+        }
+    });
+}
+
+
+bool prot_slave::set_slave_handle(int addr,HandleSlave *handle)
+{
+    if((addr>slaves.size())||(addr<=0)){
+        delete handle;
+        return false;
+    }
+    HandleSlave *temp;
+    temp=slaves[addr-1];
+    if(temp!=nullptr){
+        if(temp->busy!=0){
+            delete handle;
+            return false;
+        }else{
+            delete temp;
+        }
+    }
+    connect(handle,&HandleSlave::send_data_signal,this,&prot_slave::send_data_slot);
+    slaves.replace(addr-1,handle);
+    return true;
+}
+
+
+void prot_slave::send_data_slot(int addr,int cmd,myarray data){
+    if((if_!=nullptr)&&(codec_!=nullptr)){
+        myarray send=codec_->encode(0,addr,cmd,data);
+        if_->write(send);
+    }
+}
+
+
+
+static prot_slave *g_protslave;
+prot_slave *protSlave(){
+    if(g_protslave==nullptr){
+        g_protslave=new prot_slave();
+        //g_protslave->init();
+    }
+    return g_protslave;
+}
+
+
+
+
diff --git a/prot/prot_slave.h b/prot/prot_slave.h
new file mode 100644
index 0000000..53c1036
--- /dev/null
+++ b/prot/prot_slave.h
@@ -0,0 +1,60 @@
+#ifndef PROT_SLAVE_H
+#define PROT_SLAVE_H
+
+
+#include "QObject"
+#include "base/base.h"
+#include "QList"
+#include "interface/codec.h"
+#include "interface/interface.h"
+#include "base/mycfg.h"
+#include "QThread"
+
+
+class HandleSlave:public QObject{
+    Q_OBJECT
+  public:
+    HandleSlave(){busy=0;}
+    virtual ~HandleSlave(){}
+    virtual int start(myarray data)=0;
+    virtual int dolater(int cmd,myarray data)=0;
+    int busy;
+  signals:
+    void send_data_signal(int addr,int cmd,myarray data);
+};
+
+
+
+
+
+
+
+
+
+
+
+
+class prot_slave:public QObject
+{
+    Q_OBJECT
+public:
+    prot_slave(){if_=nullptr;codec_=nullptr;busy=0;addr=0;}
+    ~prot_slave(){}
+    void init();
+    bool set_slave_handle(int addr,HandleSlave *handle);
+    int busy;
+    int addr;
+protected slots:
+    void send_data_slot(int addr,int cmd,myarray data);
+protected:
+    InterFace *if_;
+    Codec *codec_;
+    QList<HandleSlave *> slaves;
+};
+
+
+prot_slave *protSlave();
+
+
+
+#endif // PROT_SLAVE_H
diff --git a/prot_cmd/cmd_pc.cpp b/prot_cmd/cmd_pc.cpp
new file mode 100644
index 0000000..2459eba
--- /dev/null
+++ b/prot_cmd/cmd_pc.cpp
@@ -0,0 +1,70 @@
+#include "cmd_pc.h"
+#include "prot/prot_m4.h"
+#include "prot/prot_pc.h"
+#include "prot/prot_slave.h"
+#include "base/mycfg.h"
+#include "QDebug"
+
+
+typedef struct{
+    int moter_count;
+    int moter_run;
+}moter_def;
+static moter_def g_moter;
+
+myarray moter_ctrl(myarray op)
+{
+    mycfg *cfg_=syscfg();
+    moter_def *moter=&g_moter;
+    myarray r;
+    if(op=="up"){
+        int count=0;
+        if(moter->moter_count>0){
+            moter->moter_run=1;
+            count=-moter->moter_count-100;
+            moter->moter_count=0;
+            QString s=QString("moter %1").arg(count);
+            r=s.toLocal8Bit();
+        }else{
+            qWarning()<<"moter count out of range."<<endl;
+            return r;
+        }
+    }else if(op=="down"){
+        int count=0;
+        if(moter->moter_count<cfg_->moter_count){
+            moter->moter_run=1;
+            count=cfg_->moter_count-moter->moter_count;
+            moter->moter_count+=count;
+            QString s=QString("moter %1").arg(count);
+            r=s.toLocal8Bit();
+        }else{
+            qWarning()<<"moter count out of range."<<endl;
+            return r;
+        }
+    }
+    return 0;
+}
+
+
+
+int selfdev_check::dolater(int cmd, myarray data)
+{
+  prot_m4 *m4=protM4();
+  connect(this,send_to_m4_signal,m4,&prot_m4::send_data_slot);
+  m4->set_irq_fun([=](myarray data){
+      m4->del_irq_fun(nullptr,"moter ");
+      if(data=="down"){
+          // 这里开始检测
+      }
+  },"moter ");
+  emit send_to_m4_signal(moter_ctrl("up"));
+  return 0;
+}
+
+
+
+
+
+
+
+
diff --git a/prot_cmd/cmd_pc.h b/prot_cmd/cmd_pc.h
new file mode 100644
index 0000000..a35fed2
--- /dev/null
+++ b/prot_cmd/cmd_pc.h
@@ -0,0 +1,28 @@
+#ifndef cmd_pc_h__
+#define cmd_pc_h__
+
+#include "prot/prot_pc.h"
+
+
+// 检测 自研批检仪
+class selfdev_check:public HandlePc {
+    Q_OBJECT
+public:
+    selfdev_check():HandlePc(){}
+    ~selfdev_check(){}
+    int dolater(int cmd, myarray data);
+signals:
+    void send_to_m4_signal(myarray data);
+};
+
+
+
+
+
+
+
+
+
+
+#endif
+
diff --git a/prot_cmd/cmd_slave.cpp b/prot_cmd/cmd_slave.cpp
new file mode 100644
index 0000000..27c219d
--- /dev/null
+++ b/prot_cmd/cmd_slave.cpp
@@ -0,0 +1,12 @@
+#include "cmd_slave.h"
+
+
+
+
+
+int slave_check::start(myarray data)
+{
+    return 0;
+}
+
+
diff --git a/prot_cmd/cmd_slave.h b/prot_cmd/cmd_slave.h
new file mode 100644
index 0000000..87fa4f1
--- /dev/null
+++ b/prot_cmd/cmd_slave.h
@@ -0,0 +1,14 @@
+#ifndef CMD_SLAVE_H
+#define CMD_SLAVE_H
+
+#include "prot/prot_slave.h"
+
+
+class slave_check:public HandleSlave
+{
+public:
+    slave_check():HandleSlave(){}
+    int start(myarray data);
+};
+
+#endif // CMD_SLAVE_H