newspark110/device/deviceproxy.cpp

#include "deviceproxy.h"
#include "rsensortozero.h"
#include "machcode.h"
#include "tohomecode.h"
#include "csscancode.h"
#include "sscancode.h"
#include "mhcompcode.h"
#include "rscompcode.h"
#include "myexception.h"
#include "exceptioncode.h"
#include "ptpcode.h"
#include "maxisabsmovecode.h"
#include "rs_settings.h"
#include "deviceinfo.h"
#include "buffer0autoexecode.h"
#include <QDebug>
#include <QDateTime>
#include <QFile>

#include "cmvcamera.h"
#include "modbustcp.h"
#include "Barometer.h"
#include "PanasonicHeightFind.h"
#include "PowerMeter.h"
#include "lightsource.h"
#include "PowerAttenuator.h"
#include "IPG_laser.h"
#include <string>
#include "cppcodec/base64_default_rfc4648.hpp"

#include "specificareaswidget.h"

//注释


using namespace cv;

//std::string base64_encode(const std::string& input) {
//    return cppcodec::base64_rfc4648::encode(input);
//}
//RMS_Dll rms;
DeviceProxy* DeviceProxy::uniqueInstance = nullptr;
DeviceProxy* DeviceProxy::instance()
{
    if (!uniqueInstance) {
        uniqueInstance = new DeviceProxy();
    }
    return uniqueInstance;
}

DeviceProxy::DeviceProxy():
    acsCtl(new ACSController()),thread(this)
{
    timer = new QTimer(this);
    timer->setInterval(100);
    connect(timer,SIGNAL(timeout()),this,SLOT(stateDetection()));

    worker = new CDeviceProxyWorker(this);
    connect(worker,SIGNAL(finished()),&thread,SLOT(quit()));
    worker->moveToThread(&thread);




    connect(&thread, SIGNAL(started()), worker, SLOT(doWork_custom()),Qt::UniqueConnection);
    connect(&thread, &QThread::finished, worker, &QObject::deleteLater);

    bRunning = false;
    emit RunSGL(!bRunning);
    lRunStopTime[0] = 0;
    lRunStopTime[1] = 0;
    thread.start();
    step = 0;

    bool ret = false;
    Sleep(5000);
    pLaserMark = nullptr;
    //    pLaserMark = new LaserMark();
    //    ret = pLaserMark->Init("C:\\JCZ");
    //    if (!ret)
    //    {
    //        if (pLaserMark != nullptr)
    //            delete pLaserMark;
    //        pLaserMark = nullptr;

    //        pLaserMark = new LaserMark();
    //        ret = pLaserMark->Init("C:\\JCZ");
    //        if (!ret)
    //        {
    //            if (pLaserMark != nullptr)
    //                delete pLaserMark;
    //            pLaserMark = nullptr;

    //        }
    //    }

    //    pCoordinate = nullptr;
    //    pCoordinate = new Coordinate();

    server = new QTcpServer(this);
    connect(server, &QTcpServer::newConnection, this, &DeviceProxy::ClientConnect);

    server->listen(QHostAddress::Any, 6688);

    //    Mat img1 = cv::imread("1.bmp");
    //    srcImgs.push_back(img1);
    //    Mat img2 = cv::imread("2.bmp");
    //    srcImgs.push_back(img2);
    RS_SETTINGS->beginGroup("device/Rposition");

    p2tBuf[0] = RS_SETTINGS->readNumDEntry("/p2_t0");
    p2tBuf[1] = RS_SETTINGS->readNumDEntry("/p2_t5");
    p2tBuf[2] = RS_SETTINGS->readNumDEntry("/p2_t10");
    p2tBuf[3] = RS_SETTINGS->readNumDEntry("/p2_t15");
    p2tBuf[4] = RS_SETTINGS->readNumDEntry("/p2_t20");
    p2tBuf[5] = RS_SETTINGS->readNumDEntry("/p2_t25");
    p2tBuf[6] = RS_SETTINGS->readNumDEntry("/p2_t30");
    p2tBuf[7] = RS_SETTINGS->readNumDEntry("/p2_t35");
    p2tBuf[8] = RS_SETTINGS->readNumDEntry("/p2_t40");
    p2tBuf[9] = RS_SETTINGS->readNumDEntry("/p2_t45");
    p2tBuf[10] = RS_SETTINGS->readNumDEntry("/p2_t50");
    p2tBuf[11] = RS_SETTINGS->readNumDEntry("/p2_t55");
    p2tBuf[12] = RS_SETTINGS->readNumDEntry("/p2_t60");
    p2tBuf[13] = RS_SETTINGS->readNumDEntry("/p2_t65");
    p2tBuf[14] = RS_SETTINGS->readNumDEntry("/p2_t70");
    p2tBuf[15] = RS_SETTINGS->readNumDEntry("/p2_t75");
    p2tBuf[16] = RS_SETTINGS->readNumDEntry("/p2_t80");
    p2tBuf[17] = RS_SETTINGS->readNumDEntry("/p2_t85");
    p2tBuf[18] = RS_SETTINGS->readNumDEntry("/p2_t90");
    p2tBuf[19] = RS_SETTINGS->readNumDEntry("/p2_t95");
    p2tBuf[20] = RS_SETTINGS->readNumDEntry("/p2_t100");

    p2sBuf[0] = RS_SETTINGS->readNumDEntry("/p2_s0");
    p2sBuf[1] = RS_SETTINGS->readNumDEntry("/p2_s5");
    p2sBuf[2] = RS_SETTINGS->readNumDEntry("/p2_s10");
    p2sBuf[3] = RS_SETTINGS->readNumDEntry("/p2_s15");
    p2sBuf[4] = RS_SETTINGS->readNumDEntry("/p2_s20");
    p2sBuf[5] = RS_SETTINGS->readNumDEntry("/p2_s25");
    p2sBuf[6] = RS_SETTINGS->readNumDEntry("/p2_s30");
    p2sBuf[7] = RS_SETTINGS->readNumDEntry("/p2_s35");
    p2sBuf[8] = RS_SETTINGS->readNumDEntry("/p2_s40");
    p2sBuf[9] = RS_SETTINGS->readNumDEntry("/p2_s45");
    p2sBuf[10] = RS_SETTINGS->readNumDEntry("/p2_s50");
    p2sBuf[11] = RS_SETTINGS->readNumDEntry("/p2_s55");
    p2sBuf[12] = RS_SETTINGS->readNumDEntry("/p2_s60");
    //    p2sBuf[13] = RS_SETTINGS->readNumDEntry("/p2_s65");
    //    p2sBuf[14] = RS_SETTINGS->readNumDEntry("/p2_s70");
    //    p2sBuf[15] = RS_SETTINGS->readNumDEntry("/p2_s75");
    //    p2sBuf[16] = RS_SETTINGS->readNumDEntry("/p2_s80");
    //    p2sBuf[17] = RS_SETTINGS->readNumDEntry("/p2_s85");
    //    p2sBuf[18] = RS_SETTINGS->readNumDEntry("/p2_s90");
    //    p2sBuf[19] = RS_SETTINGS->readNumDEntry("/p2_s95");
    //    p2sBuf[20] = RS_SETTINGS->readNumDEntry("/p2_s100");
    RS_SETTINGS->endGroup();
    for (int i=0;i<21;i++)
    {
        PPValues[i] = i*5;
    }

}

DeviceProxy::~DeviceProxy()
{
    bRunning = false;
    // pBLLaserLib->DisConnect();

    thread.quit();
    thread.wait();
    delete pLaserMark;
}
cv::Mat img_buf[22];
std::vector<cv::Mat> images;
cv::Mat DeviceProxy::Func_merge(int left,int right)
{

    //读取图片，截取拼接，NUMBER为张数
    //边界通过 int left = 200;int right = 500; 设置
    //函数返回拼接完成的cv::Mat
    //并且把cv::Mat转换为qimage放在img中
    //    std::string input_folder1 = "C:/Users/yining.wu/Documents/WXWork/1688855705521365/Cache/Image/2024-01/binary_mask.jpg";
    //    std::string input_folder2 = "C:/Users/yining.wu/Documents/WXWork/1688855705521365/Cache/Image/2024-01/企业微信截图_17062518386727.jpg";
    //    std::string input_folder3 = "C:/Users/yining.wu/Documents/WXWork/1688855705521365/Cache/Image/2024-01/企业微信截图_17062518386727.png";

    cv::Mat img_buf[22];
    std::vector<cv::Mat> images;
    //    unsigned int size = 22;

    //    // Loop through all the files and directories within directory
    for(int i =0;i<22;i++)
    {
        char buf[200];
        //sprintf(buf,"%s.jpg",datetime.toString("yyyyMMddHHmmsszzz").toLocal8Bit().data());
        sprintf(buf,"%d.jpg",i);

        img_buf[i] = imread(buf);

        // Crop the image
        //        int left = 200;
        //        int right = 500;
        cv::Rect roi(left, 0, right-left, img_buf[i].rows);
        cv::Mat cropped_image = img_buf[i](roi);

        images.push_back(cropped_image);

    }

    // Concatenate all images
    cv::Mat concatenated_image;
    cv::hconcat(images, concatenated_image);

    cv::imwrite("concatenated_image.jpg",concatenated_image);
    cv::cvtColor(concatenated_image, concatenated_image, cv::COLOR_BGR2RGB);        //讲BGR转换为RGB


    // Save the concatenated image
    return concatenated_image;
}

void DeviceProxy::Record_xiao()
{
    DEV->acsCtl->RToPointPos(DAXIS,90);//转到工作位
}
double DeviceProxy::getPP(double ap,bool flag)
{
    if (flag)
    {
        int i;
        for(i=0;i<20;i++)
        {
            if ((ap > p2tBuf[i]) && (ap <= p2tBuf[i+1]))
                break;
        }
        if (i>= 20)
        {
            return 0;
        }
        double ret = ((ap - p2tBuf[i])/(p2tBuf[i+1] - p2tBuf[i]))*(PPValues[i+1]-PPValues[i])+PPValues[i];
        return ret;
    }
    else
    {
        int i;
        for(i=0;i<12;i++)
        {
            if ((ap > p2sBuf[i]) && (ap <= p2sBuf[i+1]))
                break;
        }
        if (i>= 12)
        {
            return 0;
        }
        double ret = ((ap - p2sBuf[i])/(p2sBuf[i+1] - p2sBuf[i]))*(PPValues[i+1]-PPValues[i])+PPValues[i];
        return ret;
    }
}
void DeviceProxy::laserCtlCnn()
{
    //pBLLaserLib->BLStart();
    IPGLASER->OpenComm();
    //    using base64 = cppcodec::base64_rfc4648;
    //    std::vector<uint8_t> decoded = base64::decode("YW55IGNhcm5hbCBwbGVhc3VyZQ==");
    //    std::string str = base64_encode("kdkdkd");
}
void DeviceProxy::laserCtlClose()
{
    //pBLLaserLib->DisConnect();
    IPGLASER->LaserClose();
    IPGLASER->CloseComm();
}
void DeviceProxy::laserCtlSet(QString strParam)
{
    //pBLLaserLib->WriteParam(strParam);
    IPGLASER->SetParam(1);
}
void DeviceProxy::laserSetMode(int param) //设置出发模式   =》 0为TOD模式， 1为GATE模式
{
    //pBLLaserLib->SetMode(param);
}
void DeviceProxy::laserSetEmissionOnOff(int param) //设置内部激光器开光关光状态   =》   1为激光器出光， 0为激光器关光
{
    //pBLLaserLib->SetEmissionOnOff(param);
}
void DeviceProxy::laserSetExtTrigEnable(int param) //设置外部激光器触发使能状态   =》   1为激光器使能开， 0为激光器使能关
{
    //pBLLaserLib->SetExtTrigEnable(param);
}
void DeviceProxy::DEVInit()
{

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("设备初始化中...");
        if(!devIsInit)
        {
            lastTaskIsFinish=true;
            devIsReset = false;
            RS_SETTINGS->beginGroup("device/Comm/NET");
            QString ip = RS_SETTINGS->readEntry("/ip");
            int port = RS_SETTINGS->readNumEntry("/port");
            RS_SETTINGS->endGroup();

            QByteArray qByAddr = ip.toLatin1();
            char* addr = qByAddr.data();
            acsCtl->connect(addr,port);

            acsCtl->resetMapEtherCatInputOutput();
            RS_SETTINGS->beginGroup("device/DO");
            int DOECATAddr = RS_SETTINGS->readNumEntry("/ECATAddr");
            RS_SETTINGS->endGroup();
            RS_SETTINGS->beginGroup("device/DI");
            int DIECATAddr = RS_SETTINGS->readNumEntry("/ECATAddr");
            RS_SETTINGS->endGroup();
            acsCtl->mapEtherCatOutput(DOECATAddr,QString("DO1"));
            acsCtl->mapEtherCatOutput(DOECATAddr+2,QString("DO2"));
            acsCtl->mapEtherCatInput(DIECATAddr,QString("DI1"));
            acsCtl->mapEtherCatInput(DIECATAddr+2,QString("DI2"));

            char vname[] = ACSCTL_DO1_V;
            int do1 = acsCtl->getGlobalInt(vname);
            char vname2[] = ACSCTL_DO2_V;
            int do2 = acsCtl->getGlobalInt(vname2);

            RS_SETTINGS->beginGroup("device/DO");
            QString vacuumSuckerDONumStr = RS_SETTINGS->readEntry("/vacuumSucker");
            RS_SETTINGS->endGroup();

            int vacuumSuckerDONum = vacuumSuckerDONumStr.toInt();

            int mask = 1;
            mask = mask<<vacuumSuckerDONum;
            mask = (do1&mask);
            if(mask)
            {
                emit vacuumSuckerOpenFSGL();
                devWorkpieceLockState = 1;
            }
            else
            {
                emit vacuumSuckerCloseFSGL();
                devWorkpieceLockState = 0;
            }


            do1 = acsCtl->getGlobalInt(vname);

            RS_SETTINGS->beginGroup("device/DO");
            QString laserDONumStr = RS_SETTINGS->readEntry("/laser");
            RS_SETTINGS->endGroup();

            int laserDONum = laserDONumStr.toInt();
            devLaserNum = laserDONum;
            mask = 1;
            mask = mask<<laserDONum;
            mask = (do1&mask);
            if(mask)
            {
                emit laserOpenFSGL();
                IPGLASER->LaserOpen();
                devLaserState = 1;
            }
            else
            {
                emit laserCloseFSGL();
                IPGLASER->LaserClose();
                devLaserState = 0;
            }

            emit MHCompCloseFSGL();

            if(acsCtl->getBufferRunState(1))
            {
                acsCtl->stopBuffer(1);
            }
            if(acsCtl->getBufferRunState(8))
            {
                acsCtl->stopBuffer(8);
            }
            acsCtl->disableComp(ZAXIS);
            if(acsCtl->getBufferRunState(5))
            {
                acsCtl->stopBuffer(5);
            }
            emit MotionCompCloseFSGL();

            acsCtl->stopBuffer(0);
            Buffer0AutoExeCode buffer0AutoExeCode;
            QByteArray qbyCode = buffer0AutoExeCode.getCode().toLatin1();
            char* code = qbyCode.data();
            acsCtl->loadBuffer(0,code);
            acsCtl->compileBuffer(0);
            RS_SETTINGS->beginGroup("device/RS");
            int RSECATAddr = RS_SETTINGS->readNumEntry("/ECATAddr");
            RS_SETTINGS->endGroup();
            char RCECATAddrName[] = ACSCTL_RCECATADDR_V;
            acsCtl->setGlobalInt(RCECATAddrName,RSECATAddr);
            acsCtl->runBuffer(0);

            startStateDetection();
            devIsInit = true;
            getResetState();
            emit DEVInitStateChangedSGL(devIsInit && devIsReset);
            //emit DEVResetStateChangedSGL(devIsReset);
        }
        DEVICE_INFO->printDeviceSystemInfo("设备初始化完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("设备初始化失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::setAlarm(bool flag)
{
    devIsAlarm = flag;
}
void DeviceProxy::setDataCheck(bool flag)
{
    DataCheckFlag = flag;
}

void DeviceProxy::reset()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行复位操作。请先初始化。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行复位操作。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("复位中...");
        lastTaskIsFinish=false;
        lastTaskName="复位";
        devIsReset = false;
        //emit DEVResetStateChangedSGL(devIsReset);
        emit DEVInitStateChangedSGL(devIsInit && devIsReset);

        acsCtl->stopBuffer(1);

        RS_SETTINGS->beginGroup("device/toHome/Pos");
        double XAxisToHomePos = RS_SETTINGS->readNumDEntry("/XAxis");
        double YAxisToHomePos = RS_SETTINGS->readNumDEntry("/YAxis");
        double ZAxisToHomePos = RS_SETTINGS->readNumDEntry("/ZAxis");
        double ZAAxisToHomePos = RS_SETTINGS->readNumDEntry("/ZAAxis");
        double DAxisToHomePos = RS_SETTINGS->readNumDEntry("/DAxis");
        double Z0AxisToHomePos = RS_SETTINGS->readNumDEntry("/Z0Axis");
        double Z2AxisToHomePos = RS_SETTINGS->readNumDEntry("/Z2Axis");
        RS_SETTINGS->endGroup();

        RS_SETTINGS->beginGroup("device/toHome/zeroPosOffset");
        double XAxisZeroPosOffset = RS_SETTINGS->readNumDEntry("/XAxis");
        double YAxisZeroPosOffset = RS_SETTINGS->readNumDEntry("/YAxis");
        double ZAxisZeroPosOffset = RS_SETTINGS->readNumDEntry("/ZAxis");
        double ZAAxisZeroPosOffset = RS_SETTINGS->readNumDEntry("/ZAAxis");
        double DAxisZeroPosOffset = RS_SETTINGS->readNumDEntry("/DAxis");
        double Z0AxisZeroPosOffset = RS_SETTINGS->readNumDEntry("/Z0Axis");
        double Z2AxisZeroPosOffset = RS_SETTINGS->readNumDEntry("/Z2Axis");
        RS_SETTINGS->endGroup();

        RS_SETTINGS->beginGroup("device/leftSLimit");
        double XAxisLeftSLimit = RS_SETTINGS->readNumDEntry("/XAxis");
        double YAxisLeftSLimit = RS_SETTINGS->readNumDEntry("/YAxis");
        double ZAxisLeftSLimit = RS_SETTINGS->readNumDEntry("/ZAxis");
        double ZAAxisLeftSLimit = RS_SETTINGS->readNumDEntry("/ZAAxis");
        double DAxisLeftSLimit = RS_SETTINGS->readNumDEntry("/DAxis");
        double Z0AxisLeftSLimit = RS_SETTINGS->readNumDEntry("/Z0Axis");
        double Z2AxisLeftSLimit = RS_SETTINGS->readNumDEntry("/Z2Axis");
        RS_SETTINGS->endGroup();

        RS_SETTINGS->beginGroup("device/rightSLimit");
        double XAxisRightSLimit = RS_SETTINGS->readNumDEntry("/XAxis");
        double YAxisRightSLimit = RS_SETTINGS->readNumDEntry("/YAxis");
        double ZAxisRightSLimit = RS_SETTINGS->readNumDEntry("/ZAxis");
        double ZAAxisRightSLimit = RS_SETTINGS->readNumDEntry("/ZAAxis");
        double DAxisRightSLimit = RS_SETTINGS->readNumDEntry("/DAxis");
        double Z0AxisRightSLimit = RS_SETTINGS->readNumDEntry("/Z0Axis");
        double Z2AxisRightSLimit = RS_SETTINGS->readNumDEntry("/Z2Axis");
        RS_SETTINGS->endGroup();

        RS_SETTINGS->beginGroup("device/toHome/Vel");
        double XAxisVel = RS_SETTINGS->readNumDEntry("/XAxis");
        double YAxisVel = RS_SETTINGS->readNumDEntry("/YAxis");
        double ZAxisVel = RS_SETTINGS->readNumDEntry("/ZAxis");
        double ZAAxisVel = RS_SETTINGS->readNumDEntry("/ZAAxis");
        double DAxisVel = RS_SETTINGS->readNumDEntry("/DAxis");
        double Z0AxisVel = RS_SETTINGS->readNumDEntry("/Z0Axis");
        double Z2AxisVel = RS_SETTINGS->readNumDEntry("/Z2Axis");
        RS_SETTINGS->endGroup();

        RS_SETTINGS->beginGroup("device/tohome/findINDXVel");
        double XAxisFindINDXVel = RS_SETTINGS->readNumDEntry("/XAxis");
        double YAxisFindINDXVel = RS_SETTINGS->readNumDEntry("/YAxis");
        double ZAxisFindINDXVel = RS_SETTINGS->readNumDEntry("/ZAxis");
        double ZAAxisFindINDXVel = RS_SETTINGS->readNumDEntry("/ZAAxis");
        double DAxisFindINDXVel = RS_SETTINGS->readNumDEntry("/DAxis");
        double Z0AxisFindINDXVel = RS_SETTINGS->readNumDEntry("/Z0Axis");
        double Z2AxisFindINDXVel = RS_SETTINGS->readNumDEntry("/Z2Axis");
        RS_SETTINGS->endGroup();

        RS_SETTINGS->beginGroup("device/ZAAxisSafe");
        double ZAAxisToSafePosVel = 10;//RS_SETTINGS->readNumEntry("/vel");
        RS_SETTINGS->endGroup();


        ToHomeCode tohomeCode;
        tohomeCode.setZAAxisToSafePosVel(ZAAxisToSafePosVel);
        tohomeCode.setXAxisToHomePos(XAxisToHomePos);
        tohomeCode.setYAxisToHomePos(YAxisToHomePos);
        tohomeCode.setZAxisToHomePos(ZAxisToHomePos);
        tohomeCode.setZAAxisToHomePos(ZAAxisToHomePos);
        tohomeCode.setDAxisToHomePos(DAxisToHomePos);
        tohomeCode.setZ0AxisToHomePos(Z0AxisToHomePos);
        tohomeCode.setZ2AxisToHomePos(Z2AxisToHomePos);
        tohomeCode.setXAxisFindINDVel(XAxisFindINDXVel);
        tohomeCode.setYAxisFindINDVel(YAxisFindINDXVel);
        tohomeCode.setZAxisFindINDVel(ZAxisFindINDXVel);
        tohomeCode.setZAAxisFindINDVel(ZAAxisFindINDXVel);
        tohomeCode.setDAxisFindINDVel(DAxisFindINDXVel);
        tohomeCode.setZ0AxisFindINDVel(Z0AxisFindINDXVel);
        tohomeCode.setZ2AxisFindINDVel(Z2AxisFindINDXVel);
        tohomeCode.setXAxisINDZeroOffset(XAxisZeroPosOffset);
        tohomeCode.setYAxisINDZeroOffset(YAxisZeroPosOffset);
        tohomeCode.setZAxisINDZeroOffset(ZAxisZeroPosOffset);
        tohomeCode.setZAAxisINDZeroOffset(ZAAxisZeroPosOffset);
        tohomeCode.setDAxisINDZeroOffset(DAxisZeroPosOffset);
        tohomeCode.setZ0AxisINDZeroOffset(Z0AxisZeroPosOffset);
        tohomeCode.setZ2AxisINDZeroOffset(Z2AxisZeroPosOffset);
        tohomeCode.setXAxisSLLimit(XAxisLeftSLimit);
        tohomeCode.setXAxisSRLimit(XAxisRightSLimit);
        tohomeCode.setYAxisSLLimit(YAxisLeftSLimit);
        tohomeCode.setYAxisSRLimit(YAxisRightSLimit);
        tohomeCode.setZAxisSLLimit(ZAxisLeftSLimit);
        tohomeCode.setZAxisSRLimit(ZAxisRightSLimit);
        tohomeCode.setZAAxisSLLimit(ZAAxisLeftSLimit);
        tohomeCode.setZAAxisSRLimit(ZAAxisRightSLimit);
        tohomeCode.setDAxisSLLimit(DAxisLeftSLimit);
        tohomeCode.setDAxisSRLimit(DAxisRightSLimit);
        tohomeCode.setZ0AxisSLLimit(Z0AxisLeftSLimit);
        tohomeCode.setZ0AxisSRLimit(Z0AxisRightSLimit);
        tohomeCode.setZ2AxisSLLimit(Z2AxisLeftSLimit);
        tohomeCode.setZ2AxisSRLimit(Z2AxisRightSLimit);
        tohomeCode.setXAxisVel(XAxisVel);
        tohomeCode.setYAxisVel(YAxisVel);
        tohomeCode.setZAxisVel(ZAxisVel);
        tohomeCode.setZAAxisVel(ZAAxisVel);
        tohomeCode.setDAxisVel(DAxisVel);
        tohomeCode.setZ0AxisVel(Z0AxisVel);
        tohomeCode.setZ2AxisVel(Z2AxisVel);

        QByteArray qbyCode = tohomeCode.getCode().toLatin1();
        char* code = qbyCode.data();
        acsCtl->loadBuffer(1,code);
        acsCtl->compileBuffer(1);
        // 把所有轴回零状态变量置为0
        char runFVName[] = ACSCTL_RUNF_V;
        acsCtl->setGlobalInt(runFVName,0);

        char XToHomeFVName[] = ACSCTL_XTOHOMEF_V;
        acsCtl->setGlobalInt(XToHomeFVName,0);

        char YToHomeFVName[] = ACSCTL_YTOHOMEF_V;
        acsCtl->setGlobalInt(YToHomeFVName,0);

        char ZToHomeFVName[] = ACSCTL_ZTOHOMEF_V;
        acsCtl->setGlobalInt(ZToHomeFVName,0);

        char ZAToHomeFVName[] = ACSCTL_ZATOHOMEF_V;
        acsCtl->setGlobalInt(ZAToHomeFVName,0);

        char DToHomeFVName[] = ACSCTL_DTOHOMEF_V;
        acsCtl->setGlobalInt(DToHomeFVName,0);

        char Z0ToHomeFVName[] = ACSCTL_Z0TOHOMEF_V;
        acsCtl->setGlobalInt(Z0ToHomeFVName,0);

        char Z2ToHomeFVName[] = ACSCTL_Z2TOHOMEF_V;
        acsCtl->setGlobalInt(Z2ToHomeFVName,0);



        acsCtl->runBuffer(1);

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(resetFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("复位失败。",mye.getExceptCode()));
    }
}


void DeviceProxy::XAxisCMoveN()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，X轴无法执行负向连续运动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，X轴无法执行负向连续运动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    if(XAxisLimitState==LEFT_SLIMIT)
    {
        emit exceptSGL(MyException(QString("X轴在左软限位，无法执行负向连续运动。请先移开限位。"),MY_WARN));
        return;
    }

    if(XAxisLimitState==LEFT_LIMIT)
    {
        emit exceptSGL(MyException(QString("X轴在左限位，无法执行负向连续运动。请先移开限位。"),MY_WARN));
        return;
    }
    int axisBuf[4] = {0};
    axisBuf[0] = 1;
    int ret = AxisMoveSafeCheckXY(axisBuf,nullptr,nullptr);
    if(ret < 0)
    {
        emit exceptSGL(MyException(QString("晶碇与Z轴间距太小，不能执行动作。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("X轴负向连续运动中...");
        lastTaskIsFinish=false;
        lastTaskName="X轴负向连续运动";
        // 加载速度设置
        RS_SETTINGS->beginGroup("device/RMove/Vel");
        double XAxisVel = RS_SETTINGS->readNumDEntry("/XAxis");
        RS_SETTINGS->endGroup();
        acsCtl->setVELParams(XAXIS,XAxisVel);
        acsCtl->jogNeg(XAXIS);
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("X轴负方向连续运动失败。",mye.getExceptCode()));
    }

}

void DeviceProxy::XAxisCMoveNEnd()
{
    try
    {
        if(!devIsReset)
        {
            return;
        }
        if(lastTaskIsFinish&&(lastTaskName=="X轴负向连续运动"))
        {
            return;
        }
        acsCtl->halt(XAXIS);
        lastTaskIsFinish=true;
        DEVICE_INFO->printDeviceSystemInfo(QString("X轴负向连续运动完成"));
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("X轴负方向连续运动停止失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::XAxisCMoveP()
{   
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，X轴无法执行正向连续运动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，X轴无法执行正向连续运动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    if(XAxisLimitState==RIGHT_SLIMIT)
    {
        emit exceptSGL(MyException(QString("X轴在右软限位，无法执行正向连续运动。请先移开限位。"),MY_WARN));
        return;
    }

    if(XAxisLimitState==RIGHT_LIMIT)
    {
        emit exceptSGL(MyException(QString("X轴在右限位，无法执行正向连续运动。请先移开限位。"),MY_WARN));
        return;
    }
    int axisBuf[4] = {0};
    axisBuf[0] = 1;
    int ret = AxisMoveSafeCheckXY(axisBuf,nullptr,nullptr);
    if(ret < 0)
    {
        emit exceptSGL(MyException(QString("晶碇与Z轴间距太小，不能执行动作。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("X轴正向连续运动中...");
        lastTaskIsFinish=false;
        lastTaskName="X轴正向连续运动";
        // 加载速度设置
        RS_SETTINGS->beginGroup("device/RMove/Vel");
        double XAxisVel = RS_SETTINGS->readNumDEntry("/XAxis");
        RS_SETTINGS->endGroup();
        acsCtl->setVELParams(XAXIS,XAxisVel);
        acsCtl->jogPos(XAXIS);
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("X轴正向连续运动失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::XAxisCMovePEnd()
{
    try
    {
        if(!devIsReset)
        {
            return;
        }
        if(lastTaskIsFinish&&(lastTaskName=="X轴正向连续运动"))
        {
            return;
        }
        acsCtl->halt(XAXIS);
        lastTaskIsFinish=true;
        DEVICE_INFO->printDeviceSystemInfo(QString("X轴正向连续运动完成"));
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("X轴正方向连续运动停止失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::YAxisCMoveN()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，Y轴无法执行负向连续运动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，Y轴无法执行负向连续运动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    if(YAxisLimitState==LEFT_SLIMIT)
    {
        emit exceptSGL(MyException(QString("Y轴在左软限位，无法执行负向连续运动。请先移开限位。"),MY_WARN));
        return;
    }

    if(YAxisLimitState==LEFT_LIMIT)
    {
        emit exceptSGL(MyException(QString("Y轴在左限位，无法执行负向连续运动。请先移开限位。"),MY_WARN));
        return;
    }
    int axisBuf[4] = {0};
    axisBuf[1] = 1;
    int ret = AxisMoveSafeCheckXY(axisBuf,nullptr,nullptr);
    if(ret < 0)
    {
        emit exceptSGL(MyException(QString("晶碇与Z轴间距太小，不能执行动作。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Y轴负向连续运动中...");
        lastTaskIsFinish=false;
        lastTaskName="Y轴负向连续运动";
        // 加载速度设置
        RS_SETTINGS->beginGroup("device/RMove/Vel");
        double YAxisVel = RS_SETTINGS->readNumDEntry("/YAxis");
        RS_SETTINGS->endGroup();
        acsCtl->setVELParams(YAXIS,YAxisVel);
        acsCtl->jogNeg(YAXIS);
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Y轴负向连续运动失败。",mye.getExceptCode()));
    }

}

void DeviceProxy::YAxisCMoveNEnd()
{
    try
    {
        if(!devIsReset)
        {
            return;
        }
        if(lastTaskIsFinish&&(lastTaskName=="Y轴负向连续运动"))
        {
            return;
        }
        acsCtl->halt(YAXIS);
        lastTaskIsFinish=true;
        DEVICE_INFO->printDeviceSystemInfo(QString("Y轴负向连续运动完成"));
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Y轴负向连续运动停止失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::YAxisCMoveP()
{

    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，Y轴无法执行正向连续运动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，Y轴无法执行正向连续运动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    if(YAxisLimitState==RIGHT_SLIMIT)
    {
        emit exceptSGL(MyException(QString("Y轴在右软限位，无法执行正向连续运动。请先移开限位。"),MY_WARN));
        return;
    }

    if(YAxisLimitState==RIGHT_LIMIT)
    {
        emit exceptSGL(MyException(QString("Y轴在右限位，无法执行正向连续运动。请先移开限位。"),MY_WARN));
        return;
    }
    int axisBuf[] = {0};
    axisBuf[1] = 1;
    int ret = AxisMoveSafeCheckXY(axisBuf,nullptr,nullptr);
    if(ret < 0)
    {
        emit exceptSGL(MyException(QString("晶碇与Z轴间距太小，不能执行动作。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Y轴正向连续运动中...");
        lastTaskIsFinish=false;
        lastTaskName="Y轴正向连续运动";
        // 加载速度设置
        RS_SETTINGS->beginGroup("device/RMove/Vel");
        double YAxisVel = RS_SETTINGS->readNumDEntry("/YAxis");
        RS_SETTINGS->endGroup();
        acsCtl->setVELParams(YAXIS,YAxisVel);
        acsCtl->jogPos(YAXIS);
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Y轴正向连续运动失败。",mye.getExceptCode()));
    }

}

void DeviceProxy::YAxisCMovePEnd()
{
    try
    {
        if(!devIsReset)
        {
            return;
        }
        if(lastTaskIsFinish&&(lastTaskName=="Y轴正向连续运动"))
        {
            return;
        }
        acsCtl->halt(YAXIS);
        lastTaskIsFinish=true;
        DEVICE_INFO->printDeviceSystemInfo(QString("Y轴正向连续运动完成"));
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Y轴正向连续运动停止失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::ZAxisCMoveN()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，Z1轴无法执行负向连续运动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，Z1轴无法执行负向连续运动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    if(ZAxisLimitState==LEFT_SLIMIT)
    {
        emit exceptSGL(MyException(QString("Z1轴在左软限位，无法执行负向连续运动。请先移开限位。"),MY_WARN));
        return;
    }

    if(ZAxisLimitState==LEFT_LIMIT)
    {
        emit exceptSGL(MyException(QString("Z1轴在左限位，无法执行负向连续运动。请先移开限位。"),MY_WARN));
        return;
    }

    {
        int axisBuf[] = {0};
        double distPos[] = {0};
        int moveMode[2] = {0};
        axisBuf[0] = 0;
        axisBuf[1] = 0;
        axisBuf[2] = 1;
        axisBuf[3] = 0;
        RS_SETTINGS->beginGroup("device/RMove");
        double RMoveStepDistZ = RS_SETTINGS->readNumDEntry("/stepDist");
        RS_SETTINGS->endGroup();
        distPos[0] = XAxisCtPos;
        distPos[1] = YAxisCtPos;
        distPos[2] = ZAxisCtPos - RMoveStepDistZ;
        distPos[3] = ZAAxisCtPos;
        moveMode[0] = 1;
        moveMode[1] = 0;

        int ret = AxisMoveSafeCheckXY(axisBuf,distPos,moveMode);
        if(ret < 0)
        {
            emit exceptSGL(MyException(QString("晶碇与Z轴间距太小，不能执行动作。"),MY_WARN));
            return;
        }
    }
    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Z1轴负向连续运动中...");
        lastTaskIsFinish=false;
        lastTaskName="Z1轴负向连续运动";
        // 加载速度设置
        RS_SETTINGS->beginGroup("device/RMove/Vel");
        double ZAxisVel = RS_SETTINGS->readNumDEntry("/ZAxis");
        RS_SETTINGS->endGroup();
        acsCtl->setVELParams(ZAXIS,ZAxisVel);
        acsCtl->jogNeg(ZAXIS);
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z1轴负向连续运动失败。",mye.getExceptCode()));
    }

}

void DeviceProxy::ZAxisCMoveNEnd()
{
    try
    {
        if(!devIsReset)
        {
            return;
        }
        if(lastTaskIsFinish&&(lastTaskName=="Z1轴负向连续运动"))
        {
            return;
        }
        acsCtl->halt(ZAXIS);
        lastTaskIsFinish=true;
        ZZAPosCheckFlag = false;
        DEVICE_INFO->printDeviceSystemInfo(QString("Z1轴负向连续运动完成"));
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z1轴负向连续运动停止失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::ZAxisCMoveP()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，Z1轴无法执行正向连续运动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，Z1轴无法执行正向连续运动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    if(ZAxisLimitState==RIGHT_SLIMIT)
    {
        emit exceptSGL(MyException(QString("Z1轴在右软限位，无法执行正向连续运动。请先移开限位。"),MY_WARN));
        return;
    }

    if(ZAxisLimitState==RIGHT_LIMIT)
    {
        emit exceptSGL(MyException(QString("Z1轴在左限位，无法执行正向连续运动。请先移开限位。"),MY_WARN));
        return;
    }


    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Z1轴正向连续运动中...");
        lastTaskIsFinish=false;
        lastTaskName="Z1轴正向连续运动";
        // 加载速度设置

        if (!DEV->airValveDiCloseSts)
        {
            DEV->AirValveClose();
            //DEV->AirValveClose2();
            Sleep(2000);
        }
        RS_SETTINGS->beginGroup("device/RMove/Vel");
        double ZAxisVel = RS_SETTINGS->readNumDEntry("/ZAxis");
        RS_SETTINGS->endGroup();
        acsCtl->setVELParams(ZAXIS,ZAxisVel);
        acsCtl->jogPos(ZAXIS);
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z1轴正向连续运动失败。",mye.getExceptCode()));
    }

}


void DeviceProxy::ZAxisCMovePEnd()
{
    try
    {
        if(!devIsReset)
        {
            return;
        }
        if(lastTaskIsFinish&&(lastTaskName=="Z1轴正向连续运动"))
        {
            return;
        }
        acsCtl->halt(ZAXIS);
        lastTaskIsFinish=true;
        ZZAPosCheckFlag = false;
        DEVICE_INFO->printDeviceSystemInfo(QString("Z1轴正向连续运动完成"));
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z1轴正向连续运动停止失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::ZAAxisCMoveN()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，Z轴无法执行负向连续运动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，Z轴无法执行负向连续运动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    if(ZAAxisLimitState==LEFT_SLIMIT)
    {
        emit exceptSGL(MyException(QString("Z轴在左软限位，无法执行负向连续运动。请先移开限位。"),MY_WARN));
        return;
    }

    if(ZAAxisLimitState==LEFT_LIMIT)
    {
        emit exceptSGL(MyException(QString("Z轴在左限位，无法执行负向连续运动。请先移开限位。"),MY_WARN));
        return;
    }
    {
        int axisBuf[4] = {0};
        double distPos[4] = {0};
        int moveMode[2] = {0};
        axisBuf[0] = 0;
        axisBuf[1] = 0;
        axisBuf[2] = 0;
        axisBuf[3] = 1;
        RS_SETTINGS->beginGroup("device/RMove");
        double RMoveStepDistZA = RS_SETTINGS->readNumDEntry("/stepDist");
        RS_SETTINGS->endGroup();
        distPos[0] = XAxisCtPos;
        distPos[1] = YAxisCtPos;
        distPos[2] = ZAxisCtPos;
        distPos[3] = ZAAxisCtPos - RMoveStepDistZA;
        moveMode[0] = 0;
        moveMode[1] = 1;

        int ret = AxisMoveSafeCheckXY(axisBuf,distPos,moveMode);
        if(ret < 0)
        {
            emit exceptSGL(MyException(QString("晶碇与Z轴间距太小，不能执行动作。"),MY_WARN));
            return;
        }
    }
    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Z轴负向连续运动中...");
        lastTaskIsFinish=false;
        lastTaskName="Z轴负向连续运动";
        // 加载速度设置
        RS_SETTINGS->beginGroup("device/RMove/Vel");
        double ZAAxisVel = RS_SETTINGS->readNumDEntry("/ZAAxis");
        RS_SETTINGS->endGroup();
        acsCtl->setVELParams(ZAAXIS,ZAAxisVel);
        acsCtl->jogNeg(ZAAXIS);
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z轴负向连续运动失败。",mye.getExceptCode()));
    }

}


void DeviceProxy::ZAAxisCMoveNEnd()
{
    try
    {
        if(!devIsReset)
        {
            return;
        }
        if(lastTaskIsFinish&&(lastTaskName=="Z轴负向连续运动"))
        {
            return;
        }
        acsCtl->halt(ZAAXIS);
        lastTaskIsFinish=true;
        ZZAPosCheckFlag = false;
        DEVICE_INFO->printDeviceSystemInfo(QString("Z轴负向连续运动完成"));
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z轴负向连续运动停止失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::ZAAxisCMoveP()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，Z无法执行正向连续运动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，Z无法执行正向连续运动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    if(ZAAxisLimitState==RIGHT_SLIMIT)
    {
        emit exceptSGL(MyException(QString("Z轴在右软限位，无法执行正向连续运动。请先移开限位。"),MY_WARN));
        return;
    }

    if(ZAAxisLimitState==RIGHT_LIMIT)
    {
        emit exceptSGL(MyException(QString("Z轴在右限位，无法执行正向连续运动。请先移开限位。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Z轴正向连续运动中...");
        lastTaskIsFinish=false;
        lastTaskName="Z轴正向连续运动";
        // 加载速度设置
        RS_SETTINGS->beginGroup("device/RMove/Vel");
        double ZAAxisVel = RS_SETTINGS->readNumDEntry("/ZAAxis");
        RS_SETTINGS->endGroup();
        acsCtl->setVELParams(ZAAXIS,ZAAxisVel);
        acsCtl->jogPos(ZAAXIS);
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z轴向正向连续运动失败。",mye.getExceptCode()));
    }

}

void DeviceProxy::ZAAxisCMovePEnd()
{
    try
    {
        if(!devIsReset)
        {
            return;
        }
        if(lastTaskIsFinish&&(lastTaskName=="Z轴正向连续运动"))
        {
            return;
        }
        acsCtl->halt(ZAAXIS);
        lastTaskIsFinish=true;
        ZZAPosCheckFlag = false;
        DEVICE_INFO->printDeviceSystemInfo(QString("Z轴正向连续运动完成"));
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z轴正向连续运动停止失败。",mye.getExceptCode()));
    }
}


void DeviceProxy::XAxisSMoveN()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，X轴无法执行负向点动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，X轴无法执行负向点动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    int axisBuf[4] = {0};
    axisBuf[0] = 1;
    int ret = AxisMoveSafeCheckXY(axisBuf,nullptr,nullptr);
    if(ret < 0)
    {
        emit exceptSGL(MyException(QString("晶碇与Z轴间距太小，不能执行动作。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("X轴负向点动中...");
        lastTaskIsFinish=false;
        lastTaskName="X轴负向点动";
        // 加载速度设置
        RS_SETTINGS->beginGroup("device/RMove/Vel");
        double XAxisVel = RS_SETTINGS->readNumDEntry("/XAxis");
        acsCtl->setVELParams(XAXIS,XAxisVel);
        acsCtl->stopBuffer(1);
        char vname[]= ACSCTL_RUNF_V;
        acsCtl->setGlobalInt(vname,0);

        // 加载点动步距设置
        RS_SETTINGS->beginGroup("device/RMove");
        double RMoveStepDist = RS_SETTINGS->readNumDEntry("/stepDist");
        RS_SETTINGS->endGroup();

        PTPCode ptpCode;
        ptpCode.setMoveAxis(QString("X"));
        ptpCode.setMoveType(false);
        ptpCode.setTargetPos(QString("-%1").arg(RMoveStepDist,0,'f',4));
        char *code;
        QByteArray byCode = ptpCode.getCode().toLatin1();
        code = byCode.data();

        acsCtl->loadBuffer(1,code);
        acsCtl->compileBuffer(1);
        acsCtl->runBuffer(1);

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(XAxisSMoveNFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("X轴负向点动失败。",mye.getExceptCode()));
    }

}

void DeviceProxy::XAxisSMoveP()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，X轴无法执行正向点动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，X轴无法执行正向点动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    int axisBuf[4] = {0};
    axisBuf[0] = 1;
    int ret = AxisMoveSafeCheckXY(axisBuf,nullptr,nullptr);
    if(ret < 0)
    {
        emit exceptSGL(MyException(QString("晶碇与Z轴间距太小，不能执行动作。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("X轴正向点动中...");
        lastTaskIsFinish=false;
        lastTaskName="X轴正向点动";
        // 加载速度设置
        RS_SETTINGS->beginGroup("device/RMove/Vel");
        double XAxisVel = RS_SETTINGS->readNumDEntry("/XAxis");
        acsCtl->setVELParams(XAXIS,XAxisVel);
        acsCtl->stopBuffer(1);

        char vname[]= ACSCTL_RUNF_V;
        acsCtl->setGlobalInt(vname,0);

        // 加载点动步距设置
        RS_SETTINGS->beginGroup("device/RMove");
        double RMoveStepDist = RS_SETTINGS->readNumDEntry("/stepDist");
        RS_SETTINGS->endGroup();

        PTPCode ptpCode;
        ptpCode.setMoveAxis(QString("X"));
        ptpCode.setMoveType(false);
        ptpCode.setTargetPos(QString("%1").arg(RMoveStepDist,0,'f',4));
        char *code;
        QByteArray byCode = ptpCode.getCode().toLatin1();
        code = byCode.data();

        acsCtl->loadBuffer(1,code);
        acsCtl->compileBuffer(1);
        acsCtl->runBuffer(1);

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(XAxisSMovePFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("X轴正向点动失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::YAxisSMoveN()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，Y轴无法执行负向点动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，Y轴无法执行负向点动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    int axisBuf[4] = {0};
    axisBuf[1] = 1;
    int ret = AxisMoveSafeCheckXY(axisBuf,nullptr,nullptr);
    if(ret < 0)
    {
        emit exceptSGL(MyException(QString("晶碇与Z轴间距太小，不能执行动作。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Y轴负向点动中...");
        lastTaskIsFinish=false;
        lastTaskName="Y轴负向点动";
        // 加载速度设置
        RS_SETTINGS->beginGroup("device/RMove/Vel");
        double YAxisVel = RS_SETTINGS->readNumDEntry("/YAxis");
        acsCtl->setVELParams(YAXIS,YAxisVel);
        acsCtl->stopBuffer(1);

        char vname[]= ACSCTL_RUNF_V;
        acsCtl->setGlobalInt(vname,0);
        PTPCode ptpCode;
        ptpCode.setMoveAxis(QString("Y"));
        ptpCode.setMoveType(false);

        // 加载点动步距设置
        RS_SETTINGS->beginGroup("device/RMove");
        double RMoveStepDist = RS_SETTINGS->readNumDEntry("/stepDist");
        RS_SETTINGS->endGroup();

        ptpCode.setTargetPos(QString("-%1").arg(RMoveStepDist,0,'f',4));
        char *code;
        QByteArray byCode = ptpCode.getCode().toLatin1();
        code = byCode.data();

        acsCtl->loadBuffer(1,code);
        acsCtl->compileBuffer(1);
        acsCtl->runBuffer(1);

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(YAxisSMoveNFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Y轴负向点动失败。",mye.getExceptCode()));
    }

}

void DeviceProxy::YAxisSMoveP()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，Y轴无法执行正向点动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，Y轴无法执行正向点动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    int axisBuf[4] = {0};
    axisBuf[1] = 1;
    int ret = AxisMoveSafeCheckXY(axisBuf,nullptr,nullptr);
    if(ret < 0)
    {
        emit exceptSGL(MyException(QString("晶碇与Z轴间距太小，不能执行动作。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Y轴正向点动中...");
        lastTaskIsFinish=false;
        lastTaskName="Y轴正向点动";
        // 加载速度设置
        RS_SETTINGS->beginGroup("device/RMove/Vel");
        double YAxisVel = RS_SETTINGS->readNumDEntry("/YAxis");
        acsCtl->setVELParams(YAXIS,YAxisVel);
        acsCtl->stopBuffer(1);

        char vname[]= ACSCTL_RUNF_V;
        acsCtl->setGlobalInt(vname,0);
        PTPCode ptpCode;
        ptpCode.setMoveAxis(QString("Y"));
        ptpCode.setMoveType(false);

        // 加载点动步距设置
        RS_SETTINGS->beginGroup("device/RMove");
        double RMoveStepDist = RS_SETTINGS->readNumDEntry("/stepDist");
        RS_SETTINGS->endGroup();

        ptpCode.setTargetPos(QString("%1").arg(RMoveStepDist,0,'f',4));
        char *code;
        QByteArray byCode = ptpCode.getCode().toLatin1();
        code = byCode.data();

        acsCtl->loadBuffer(1,code);
        acsCtl->compileBuffer(1);
        acsCtl->runBuffer(1);

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(YAxisSMovePFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Y轴正向点动失败。",mye.getExceptCode()));
    }

}

void DeviceProxy::ZAxisSMoveN()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，Z1轴无法执行负向点动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，Z1轴无法执行负向点动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    {
        int axisBuf[4] = {0};
        double distPos[4] = {0};
        int moveMode[2] = {0};
        axisBuf[0] = 0;
        axisBuf[1] = 0;
        axisBuf[2] = 1;
        axisBuf[3] = 0;
        RS_SETTINGS->beginGroup("device/RMove");
        double RMoveStepDistZ = RS_SETTINGS->readNumDEntry("/stepDist");
        RS_SETTINGS->endGroup();
        distPos[0] = XAxisCtPos;
        distPos[1] = YAxisCtPos;
        distPos[2] = ZAxisCtPos - RMoveStepDistZ;
        distPos[3] = ZAAxisCtPos;
        moveMode[0] = 0;
        moveMode[1] = 0;

        int ret = AxisMoveSafeCheckXY(axisBuf,distPos,moveMode);
        if(ret < 0)
        {
            emit exceptSGL(MyException(QString("晶碇与Z轴间距太小，不能执行动作。"),MY_WARN));
            return;
        }
    }


    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Z1轴负向点动中...");
        lastTaskIsFinish=false;
        lastTaskName="Z1轴负向点动";
        // 加载速度设置
        RS_SETTINGS->beginGroup("device/RMove/Vel");
        double ZAxisVel = RS_SETTINGS->readNumDEntry("/ZAxis");
        acsCtl->setVELParams(ZAXIS,ZAxisVel);
        acsCtl->stopBuffer(1);

        char vname[]= ACSCTL_RUNF_V;
        acsCtl->setGlobalInt(vname,0);
        PTPCode ptpCode;
        ptpCode.setMoveAxis(QString("Z"));
        ptpCode.setMoveType(false);

        // 加载点动步距设置
        RS_SETTINGS->beginGroup("device/RMove");
        double RMoveStepDist = RS_SETTINGS->readNumDEntry("/stepDist");
        RS_SETTINGS->endGroup();

        ptpCode.setTargetPos(QString("-%1").arg(RMoveStepDist,0,'f',4));
        char *code;
        QByteArray byCode = ptpCode.getCode().toLatin1();
        code = byCode.data();

        acsCtl->loadBuffer(1,code);
        acsCtl->compileBuffer(1);
        acsCtl->runBuffer(1);

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(ZAxisSMoveNFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z1轴负向点动失败。",mye.getExceptCode()));
    }

}

void DeviceProxy::ZAxisSMoveP()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，Z1轴无法执行正向点动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，Z1轴无法执行正向点动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }


    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Z1轴正向点动中...");
        lastTaskIsFinish=false;
        lastTaskName="Z1轴正向点动";
        if (!DEV->airValveDiCloseSts)
        {
            DEV->AirValveClose();
            //DEV->AirValveClose2();
            Sleep(2000);
        }

        // 加载速度设置
        RS_SETTINGS->beginGroup("device/RMove/Vel");
        double ZAxisVel = RS_SETTINGS->readNumDEntry("/ZAxis");
        acsCtl->setVELParams(ZAXIS,ZAxisVel);
        acsCtl->stopBuffer(1);

        char vname[]=ACSCTL_RUNF_V;
        acsCtl->setGlobalInt(vname,0);
        PTPCode ptpCode;
        ptpCode.setMoveAxis(QString("Z"));
        ptpCode.setMoveType(false);

        // 加载点动步距设置
        RS_SETTINGS->beginGroup("device/RMove");
        double RMoveStepDist = RS_SETTINGS->readNumDEntry("/stepDist");
        RS_SETTINGS->endGroup();

        ptpCode.setTargetPos(QString("%1").arg(RMoveStepDist,0,'f',4));
        char *code;
        QByteArray byCode = ptpCode.getCode().toLatin1();
        code = byCode.data();

        acsCtl->loadBuffer(1,code);
        acsCtl->compileBuffer(1);
        acsCtl->runBuffer(1);

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(ZAxisSMovePFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z1轴正向点动失败。",mye.getExceptCode()));
    }

}

void DeviceProxy::ZAAxisSMoveN()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，Z轴无法执行负向点动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，Z轴无法执行负向点动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    {
        int axisBuf[4] = {0};
        double distPos[4] = {0};
        int moveMode[2] = {0};
        axisBuf[0] = 0;
        axisBuf[1] = 0;
        axisBuf[2] = 0;
        axisBuf[3] = 1;
        RS_SETTINGS->beginGroup("device/RMove");
        double RMoveStepDistZA = RS_SETTINGS->readNumDEntry("/stepDist");
        RS_SETTINGS->endGroup();
        distPos[0] = XAxisCtPos;
        distPos[1] = YAxisCtPos;
        distPos[2] = ZAxisCtPos;
        distPos[3] = ZAAxisCtPos - RMoveStepDistZA;
        moveMode[0] = 0;
        moveMode[1] = 0;

        int ret = AxisMoveSafeCheckXY(axisBuf,distPos,moveMode);
        if(ret < 0)
        {
            emit exceptSGL(MyException(QString("晶碇与Z轴间距太小，不能执行动作。"),MY_WARN));
            return;
        }
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Z轴负向点动中...");
        lastTaskIsFinish=false;
        lastTaskName="Z轴负向点动";
        // 加载速度设置
        RS_SETTINGS->beginGroup("device/RMove/Vel");
        double ZAAxisVel = RS_SETTINGS->readNumDEntry("/ZAAxis");
        acsCtl->setVELParams(ZAAXIS,ZAAxisVel);
        acsCtl->stopBuffer(1);

        char vname[]= ACSCTL_RUNF_V;
        acsCtl->setGlobalInt(vname,0);
        PTPCode ptpCode;
        ptpCode.setMoveAxis(QString("ZA"));
        ptpCode.setMoveType(false);

        // 加载点动步距设置
        RS_SETTINGS->beginGroup("device/RMove");
        double RMoveStepDist = RS_SETTINGS->readNumDEntry("/stepDist");
        RS_SETTINGS->endGroup();

        ptpCode.setTargetPos(QString("-%1").arg(RMoveStepDist,0,'f',4));
        char *code;
        QByteArray byCode = ptpCode.getCode().toLatin1();
        code = byCode.data();

        acsCtl->loadBuffer(1,code);
        acsCtl->compileBuffer(1);
        acsCtl->runBuffer(1);

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(ZAAxisSMoveNFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z轴负向点动失败。",mye.getExceptCode()));
    }

}

void DeviceProxy::ZAAxisSMoveP()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，Z轴无法执行正向点动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，Z轴无法执行正向点动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Z轴正向点动中...");
        lastTaskIsFinish=false;
        lastTaskName="Z轴正向点动";
        // 加载速度设置
        RS_SETTINGS->beginGroup("device/RMove/Vel");
        double ZAAxisVel = RS_SETTINGS->readNumDEntry("/ZAAxis");
        acsCtl->setVELParams(ZAAXIS,ZAAxisVel);
        acsCtl->stopBuffer(1);

        char vname[]= ACSCTL_RUNF_V;
        acsCtl->setGlobalInt(vname,0);
        PTPCode ptpCode;
        ptpCode.setMoveAxis(QString("ZA"));
        ptpCode.setMoveType(false);

        // 加载点动步距设置
        RS_SETTINGS->beginGroup("device/RMove");
        double RMoveStepDist = RS_SETTINGS->readNumDEntry("/stepDist");
        RS_SETTINGS->endGroup();

        ptpCode.setTargetPos(QString("%1").arg(RMoveStepDist,0,'f',4));
        char *code;
        QByteArray byCode = ptpCode.getCode().toLatin1();
        code = byCode.data();

        acsCtl->loadBuffer(1,code);
        acsCtl->compileBuffer(1);
        acsCtl->runBuffer(1);

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(ZAAxisSMovePFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z轴正向点动失败。",mye.getExceptCode()));
    }

}
void DeviceProxy::DAxisSMoveN()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，DD马达无法执行负向点动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，DD马达无法执行负向点动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("DD马达负向点动中...");
        lastTaskIsFinish=false;
        lastTaskName="DD马达负向点动";
        // 加载速度设置
        RS_SETTINGS->beginGroup("device/DDMotor");
        double DAxisVel = RS_SETTINGS->readNumDEntry("/Vel");
        RS_SETTINGS->endGroup();
        acsCtl->setVELParams(DAXIS,DAxisVel);
        acsCtl->stopBuffer(1);

        char vname[]= ACSCTL_RUNF_V;
        acsCtl->setGlobalInt(vname,0);
        PTPCode ptpCode;
        ptpCode.setMoveAxis(QString("D"));
        ptpCode.setMoveType(false);

        // 加载点动步距设置
        RS_SETTINGS->beginGroup("device/DDMotor");
        double RMoveStepDist = RS_SETTINGS->readNumDEntry("/step");
        RS_SETTINGS->endGroup();

        ptpCode.setTargetPos(QString("-%1").arg(RMoveStepDist));
        char *code;
        QByteArray byCode = ptpCode.getCode().toLatin1();
        code = byCode.data();

        acsCtl->loadBuffer(1,code);
        acsCtl->compileBuffer(1);
        acsCtl->runBuffer(1);

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(DAxisSMoveNFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("DD马达负向点动失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::DAxisSMoveP()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，DD马达无法执行正向点动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，DD马达无法执行正向点动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("DD马达正向点动中...");
        lastTaskIsFinish=false;
        lastTaskName="DD马达正向点动";
        // 加载速度设置
        RS_SETTINGS->beginGroup("device/DDMotor");
        double DAxisVel = RS_SETTINGS->readNumDEntry("/Vel");
        RS_SETTINGS->endGroup();
        acsCtl->setVELParams(DAXIS,DAxisVel);
        acsCtl->stopBuffer(1);

        char vname[]= ACSCTL_RUNF_V;
        acsCtl->setGlobalInt(vname,0);
        PTPCode ptpCode;
        ptpCode.setMoveAxis(QString("D"));
        ptpCode.setMoveType(false);

        // 加载点动步距设置
        RS_SETTINGS->beginGroup("device/DDMotor");
        double RMoveStepDist = RS_SETTINGS->readNumDEntry("/step");
        RS_SETTINGS->endGroup();

        ptpCode.setTargetPos(QString("%1").arg(RMoveStepDist));
        char *code;
        QByteArray byCode = ptpCode.getCode().toLatin1();
        code = byCode.data();

        acsCtl->loadBuffer(1,code);
        acsCtl->compileBuffer(1);
        acsCtl->runBuffer(1);

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(DAxisSMovePFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("DD马达正向点动失败。",mye.getExceptCode()));
    }
}
//lihongchang
void DeviceProxy::Z2AxisSMoveN()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，Z2轴无法执行负向点动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，Z2轴无法执行负向点动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    {
        //安全检查
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Z2轴负向点动中...");
        lastTaskIsFinish=false;
        lastTaskName="Z2轴负向点动";
        // 加载速度设置
        // 加载速度设置
        RS_SETTINGS->beginGroup("device/DDMotor");
        double DAxisVel = RS_SETTINGS->readNumDEntry("/Vel");
        RS_SETTINGS->endGroup();
        acsCtl->setVELParams(Z2AXIS,DAxisVel);
        acsCtl->stopBuffer(1);

        char vname[]= ACSCTL_RUNF_V;
        acsCtl->setGlobalInt(vname,0);
        PTPCode ptpCode;
        ptpCode.setMoveAxis(QString("Z2"));
        ptpCode.setMoveType(false);

        // 加载点动步距设置
        RS_SETTINGS->beginGroup("device/DDMotor");
        double RMoveStepDist = RS_SETTINGS->readNumDEntry("/step");
        RS_SETTINGS->endGroup();

        ptpCode.setTargetPos(QString("-%1").arg(RMoveStepDist));
        char *code;
        QByteArray byCode = ptpCode.getCode().toLatin1();
        code = byCode.data();

        acsCtl->loadBuffer(1,code);
        acsCtl->compileBuffer(1);
        acsCtl->runBuffer(1);

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(Z2AxisSMoveNFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z2轴负向点动失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::Z2AxisSMoveP()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，Z2轴无法执行正向点动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，Z2轴无法执行正向点动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    {
        //安全检查
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Z2轴正向点动中...");
        lastTaskIsFinish=false;
        lastTaskName="Z2轴正向点动";
        // 加载速度设置
        RS_SETTINGS->beginGroup("device/DDMotor");
        double DAxisVel = RS_SETTINGS->readNumDEntry("/Vel");
        RS_SETTINGS->endGroup();
        acsCtl->setVELParams(Z2AXIS,DAxisVel);
        acsCtl->stopBuffer(1);

        char vname[]= ACSCTL_RUNF_V;
        acsCtl->setGlobalInt(vname,0);
        PTPCode ptpCode;
        ptpCode.setMoveAxis(QString("Z2"));
        ptpCode.setMoveType(false);

        // 加载点动步距设置
        RS_SETTINGS->beginGroup("device/DDMotor");
        double RMoveStepDist = RS_SETTINGS->readNumDEntry("/step");
        RS_SETTINGS->endGroup();

        ptpCode.setTargetPos(QString("%1").arg(RMoveStepDist));
        char *code;
        QByteArray byCode = ptpCode.getCode().toLatin1();
        code = byCode.data();

        acsCtl->loadBuffer(1,code);
        acsCtl->compileBuffer(1);
        acsCtl->runBuffer(1);

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(Z2AxisSMovePFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z轴正向点动失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::Z0AxisSMoveN()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，Z0轴无法执行负向点动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，Z0轴无法执行负向点动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    {
        //安全检查
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Z0轴负向点动中...");
        lastTaskIsFinish=false;
        lastTaskName="Z0轴负向点动";
        // 加载速度设置
        RS_SETTINGS->beginGroup("device/DDMotor");
        double DAxisVel = RS_SETTINGS->readNumDEntry("/Vel");
        RS_SETTINGS->endGroup();
        acsCtl->setVELParams(Z0AXIS,DAxisVel);
        acsCtl->stopBuffer(1);

        char vname[]= ACSCTL_RUNF_V;
        acsCtl->setGlobalInt(vname,0);
        PTPCode ptpCode;
        ptpCode.setMoveAxis(QString("Z0"));
        ptpCode.setMoveType(false);

        // 加载点动步距设置
        RS_SETTINGS->beginGroup("device/DDMotor");
        double RMoveStepDist = RS_SETTINGS->readNumDEntry("/step");
        RS_SETTINGS->endGroup();

        ptpCode.setTargetPos(QString("-%1").arg(RMoveStepDist));
        char *code;
        QByteArray byCode = ptpCode.getCode().toLatin1();
        code = byCode.data();
        //qDebug()<< byCode;
        acsCtl->loadBuffer(1,code);
        acsCtl->compileBuffer(1);
        acsCtl->runBuffer(1);

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(Z0AxisSMoveNFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z0轴负向点动失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::Z0AxisSMoveP()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，Z0轴无法执行正向点动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，Z0轴无法执行正向点动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    {
        //安全检查
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Z0轴正向点动中...");
        lastTaskIsFinish=false;
        lastTaskName="Z0轴正向点动";
        // 加载速度设置
        RS_SETTINGS->beginGroup("device/DDMotor");
        double DAxisVel = RS_SETTINGS->readNumDEntry("/Vel");
        RS_SETTINGS->endGroup();
        acsCtl->setVELParams(Z0AXIS,DAxisVel);
        acsCtl->stopBuffer(1);

        char vname[]= ACSCTL_RUNF_V;
        acsCtl->setGlobalInt(vname,0);
        PTPCode ptpCode;
        ptpCode.setMoveAxis(QString("Z0"));
        ptpCode.setMoveType(false);

        // 加载点动步距设置
        RS_SETTINGS->beginGroup("device/DDMotor");
        double RMoveStepDist = RS_SETTINGS->readNumDEntry("/step");
        RS_SETTINGS->endGroup();

        ptpCode.setTargetPos(QString("%1").arg(RMoveStepDist));
        char *code;
        QByteArray byCode = ptpCode.getCode().toLatin1();
        code = byCode.data();

        acsCtl->loadBuffer(1,code);
        acsCtl->compileBuffer(1);
        acsCtl->runBuffer(1);

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(Z0AxisSMovePFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z0轴正向点动失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::Z0AxisCMoveN()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，Z0轴无法执行负向连续运动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，Z0轴无法执行负向连续运动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    if(Z0AxisLimitState==LEFT_SLIMIT)
    {
        emit exceptSGL(MyException(QString("Z0轴在左软限位，无法执行负向连续运动。请先移开限位。"),MY_WARN));
        return;
    }

    if(Z0AxisLimitState==LEFT_LIMIT)
    {
        emit exceptSGL(MyException(QString("Z0轴在左限位，无法执行负向连续运动。请先移开限位。"),MY_WARN));
        return;
    }
    {
        //安全检查
    }
    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Z0轴负向连续运动中...");
        lastTaskIsFinish=false;
        lastTaskName="Z0轴负向连续运动";
        // 加载速度设置

        RS_SETTINGS->beginGroup("device/DDMotor");
        double DAxisVel = RS_SETTINGS->readNumDEntry("/Vel");
        RS_SETTINGS->endGroup();


        acsCtl->setVELParams(Z0AXIS,DAxisVel);
        acsCtl->jogNeg(Z0AXIS);
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z轴负向连续运动失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::Z0AxisCMoveNEnd()
{
    try
    {
        if(!devIsReset)
        {
            return;
        }
        if(lastTaskIsFinish&&(lastTaskName=="Z0轴负向连续运动"))
        {
            return;
        }
        acsCtl->halt(Z0AXIS);
        lastTaskIsFinish=true;
        //ZZAPosCheckFlag = false;
        DEVICE_INFO->printDeviceSystemInfo(QString("Z0轴负向连续运动完成"));
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z0轴负向连续运动停止失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::Z0AxisCMoveP()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，Z0无法执行正向连续运动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，Z0无法执行正向连续运动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    if(Z0AxisLimitState==RIGHT_SLIMIT)
    {
        emit exceptSGL(MyException(QString("Z0轴在右软限位，无法执行正向连续运动。请先移开限位。"),MY_WARN));
        return;
    }

    if(Z0AxisLimitState==RIGHT_LIMIT)
    {
        emit exceptSGL(MyException(QString("Z0轴在右限位，无法执行正向连续运动。请先移开限位。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Z0轴正向连续运动中...");
        lastTaskIsFinish=false;
        lastTaskName="Z0轴正向连续运动";
        // 加载速度设置

        RS_SETTINGS->beginGroup("device/DDMotor");
        double DAxisVel = RS_SETTINGS->readNumDEntry("/Vel");
        RS_SETTINGS->endGroup();

        acsCtl->setVELParams(Z0AXIS,DAxisVel);
        acsCtl->jogPos(Z0AXIS);
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z0轴向正向连续运动失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::Z0AxisCMovePEnd()
{
    try
    {
        if(!devIsReset)
        {
            return;
        }
        if(lastTaskIsFinish&&(lastTaskName=="Z0轴正向连续运动"))
        {
            return;
        }
        acsCtl->halt(Z0AXIS);
        lastTaskIsFinish=true;
        //ZZAPosCheckFlag = false;
        DEVICE_INFO->printDeviceSystemInfo(QString("Z0轴正向连续运动完成"));
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z0轴负向连续运动停止失败。",mye.getExceptCode()));
    }
}
//lihongchang
void DeviceProxy::Z2AxisCMoveN()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，Z2轴无法执行负向连续运动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，Z2轴无法执行负向连续运动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    if(Z2AxisLimitState==LEFT_SLIMIT)
    {
        emit exceptSGL(MyException(QString("Z2轴在左软限位，无法执行负向连续运动。请先移开限位。"),MY_WARN));
        return;
    }

    if(Z2AxisLimitState==LEFT_LIMIT)
    {
        emit exceptSGL(MyException(QString("Z2轴在左限位，无法执行负向连续运动。请先移开限位。"),MY_WARN));
        return;
    }
    {
        //安全检查
    }
    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Z2轴负向连续运动中...");
        lastTaskIsFinish=false;
        lastTaskName="Z2轴负向连续运动";
        // 加载速度设置

        RS_SETTINGS->beginGroup("device/DDMotor");
        double DAxisVel = RS_SETTINGS->readNumDEntry("/Vel");
        RS_SETTINGS->endGroup();


        acsCtl->setVELParams(Z2AXIS,DAxisVel);
        acsCtl->jogNeg(Z2AXIS);
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z2轴负向连续运动失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::Z2AxisCMoveNEnd()
{
    try
    {
        if(!devIsReset)
        {
            return;
        }
        if(lastTaskIsFinish&&(lastTaskName=="Z2轴负向连续运动"))
        {
            return;
        }
        acsCtl->halt(Z2AXIS);
        lastTaskIsFinish=true;
        //ZZAPosCheckFlag = false;
        DEVICE_INFO->printDeviceSystemInfo(QString("Z2轴负向连续运动完成"));
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z2轴负向连续运动停止失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::Z2AxisCMoveP()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，Z2无法执行正向连续运动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，Z2无法执行正向连续运动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    if(Z2AxisLimitState==RIGHT_SLIMIT)
    {
        emit exceptSGL(MyException(QString("Z2轴在右软限位，无法执行正向连续运动。请先移开限位。"),MY_WARN));
        return;
    }

    if(Z2AxisLimitState==RIGHT_LIMIT)
    {
        emit exceptSGL(MyException(QString("Z2轴在右限位，无法执行正向连续运动。请先移开限位。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Z2轴正向连续运动中...");
        lastTaskIsFinish=false;
        lastTaskName="Z2轴正向连续运动";
        // 加载速度设置

        RS_SETTINGS->beginGroup("device/DDMotor");
        double DAxisVel = RS_SETTINGS->readNumDEntry("/Vel");
        RS_SETTINGS->endGroup();

        acsCtl->setVELParams(Z2AXIS,DAxisVel);
        acsCtl->jogPos(Z2AXIS);
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z2轴向正向连续运动失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::Z2AxisCMovePEnd()
{
    try
    {
        if(!devIsReset)
        {
            return;
        }
        if(lastTaskIsFinish&&(lastTaskName=="Z2轴正向连续运动"))
        {
            return;
        }
        acsCtl->halt(Z2AXIS);
        lastTaskIsFinish=true;
        //ZZAPosCheckFlag = false;
        DEVICE_INFO->printDeviceSystemInfo(QString("Z2轴正向连续运动完成"));
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z2轴负向连续运动停止失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::DAxisCMoveN()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，DD马达无法执行负向连续运动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，DD马达无法执行负向连续运动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    {
        //安全检查
    }
    try
    {
        DEVICE_INFO->printDeviceSystemInfo("DD马达负向连续运动中...");
        lastTaskIsFinish=false;
        lastTaskName="DD马达负向连续运动";
        // 加载速度设置

        RS_SETTINGS->beginGroup("device/DDMotor");
        double DAxisVel = RS_SETTINGS->readNumDEntry("/Vel");
        RS_SETTINGS->endGroup();


        acsCtl->setVELParams(DAXIS,DAxisVel);
        acsCtl->jogNeg(DAXIS);
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("DD马达负向连续运动失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::DAxisCMoveNEnd()
{
    try
    {
        if(!devIsReset)
        {
            return;
        }
        if(lastTaskIsFinish&&(lastTaskName=="DD马达负向连续运动"))
        {
            return;
        }
        acsCtl->halt(DAXIS);
        lastTaskIsFinish=true;
        //ZZAPosCheckFlag = false;
        DEVICE_INFO->printDeviceSystemInfo(QString("DD马达负向连续运动完成"));
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("DD马达负向连续运动停止失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::DAxisCMoveP()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，DD马达无法执行正向连续运动。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，DD马达无法执行正向连续运动。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("DD马达正向连续运动中...");
        lastTaskIsFinish=false;
        lastTaskName="DD马达正向连续运动";
        // 加载速度设置

        RS_SETTINGS->beginGroup("device/DDMotor");
        double DAxisVel = RS_SETTINGS->readNumDEntry("/Vel");
        RS_SETTINGS->endGroup();

        acsCtl->setVELParams(DAXIS,DAxisVel);
        acsCtl->jogPos(DAXIS);
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("DD马达向正向连续运动失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::DAxisCMovePEnd()
{
    try
    {
        if(!devIsReset)
        {
            return;
        }
        if(lastTaskIsFinish&&(lastTaskName=="DD马达正向连续运动"))
        {
            return;
        }
        acsCtl->halt(DAXIS);
        lastTaskIsFinish=true;
        //ZZAPosCheckFlag = false;
        DEVICE_INFO->printDeviceSystemInfo(QString("DD马达正向连续运动完成"));
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("DD马达负向连续运动停止失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::ABSMove_DZ0Z2()
{
    // 加载PTP轴选择设置
    RS_SETTINGS->beginGroup("device/DDMotor");
    int AxisIsMove = RS_SETTINGS->readNumEntry("/motor",0);
    RS_SETTINGS->endGroup();

    QString temp;

    if(AxisIsMove == 0)
    {
        temp+="DD马达";
    }
    else if(AxisIsMove == 1)
    {
        temp+="Z0";
    }
    else if(AxisIsMove == 2)
    {
        temp+="Z2";
    }

    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，%1无法执行绝对定位。请先完成复位。").arg(temp),MY_WARN));
        return;
    }
    //
    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，%2无法执行绝对定位。请先停止运动或等待任务结束。").arg(lastTaskName).arg(temp),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    //if(((XAxisIsMove)||(YAxisIsMove)) && (ZAxisIsMove || ZAAxisIsMove))
    {
        //安全检查
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("DD绝对定位执行中...");
        lastTaskIsFinish=false;
        lastTaskName="DD绝对定位";
        //        acsCtl->stopBuffer(1);
        //        char vname[]= ACSCTL_RUNF_V;
        //        acsCtl->setGlobalInt(vname,0);


        // 加载PTP位置设置
        RS_SETTINGS->beginGroup("device/DDMotor");
        double dsbStepDDt = RS_SETTINGS->readNumDEntry("/step");
        double dsbVelDD = RS_SETTINGS->readNumDEntry("/Vel");
        RS_SETTINGS->endGroup();

        QString moveAxis;
        if(AxisIsMove == 0)
        {
            moveAxis+="D";
        }
        else if(AxisIsMove == 1)
        {
            moveAxis+="Z0";
        }
        else if(AxisIsMove == 2)
        {
            moveAxis+="Z2";
        }

        QString surCode{""};
        surCode+=
                QString("ENABLE (%1)\n").arg(moveAxis);

        if(AxisIsMove == 0)
        {
            surCode +=
                    QString("VEL(D) = %1\n").arg(dsbVelDD)+
                    QString("ACC(D) = %1\n").arg(dsbVelDD*10)+
                    QString("DEC(D) = %1\n").arg(dsbVelDD*10)+
                    QString("JERK(D) = %1\n").arg(dsbVelDD*100)+
                    QString("KDEC(D) = %1\n").arg(dsbVelDD*100)+
                    QString("PTP/e (D),%1\n").arg(dsbStepDDt);

        }
        else if(AxisIsMove == 1)
        {

            {
                surCode+=
                        QString("VEL(Z0) = %1\n").arg(dsbVelDD)+
                        QString("ACC(Z0) = %1\n").arg(dsbVelDD*10)+
                        QString("DEC(Z0) = %1\n").arg(dsbVelDD*10)+
                        QString("JERK(Z0) = %1\n").arg(dsbVelDD*100)+
                        QString("KDEC(Z0) = %1\n").arg(dsbVelDD*100)+
                        QString("PTP/e (Z0),%1\n").arg(dsbStepDDt);
            }
        }
        else
        {
            {
                surCode+=
                        QString("VEL(Z2) = %1\n").arg(dsbVelDD)+
                        QString("ACC(Z2) = %1\n").arg(dsbVelDD*10)+
                        QString("DEC(Z2) = %1\n").arg(dsbVelDD*10)+
                        QString("JERK(Z2) = %1\n").arg(dsbVelDD*100)+
                        QString("KDEC(Z2) = %1\n").arg(dsbVelDD*100)+
                        QString("PTP/e (Z2),%1\n").arg(dsbStepDDt);
            }

        }

        surCode+=
                "runF = 1\n"
                "STOP";
        char *code;
        QByteArray byCode = surCode.toLatin1();
        code = byCode.data();

        acsCtl->loadBuffer(1,code);
        acsCtl->compileBuffer(1);
        acsCtl->runBuffer(1);

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(ABSMoveFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException(QString("%1绝对定位失败。").arg(temp),mye.getExceptCode()));
    }
}
void DeviceProxy::ABSMove_Z0_test()
{
    acsCtl->ABSToPoint(Z0AXIS,0);
}
void DeviceProxy::ABSMove()
{
    // 加载PTP轴选择设置
    RS_SETTINGS->beginGroup("device/ABSMove/isMove");
    int XAxisIsMove = RS_SETTINGS->readNumEntry("/XAxis",0);
    int YAxisIsMove = RS_SETTINGS->readNumEntry("/YAxis",0);
    int ZAxisIsMove = RS_SETTINGS->readNumEntry("/ZAxis",0);
    int ZAAxisIsMove = RS_SETTINGS->readNumEntry("/ZAAxis",0);
    RS_SETTINGS->endGroup();
    QString temp;
    if(XAxisIsMove)
        temp+="X轴";
    if(YAxisIsMove)
    {
        if(temp.isEmpty())
            temp+="Y轴";
        else
            temp+=",Y轴";
    }
    if(ZAxisIsMove)
    {
        if(temp.isEmpty())
            temp+="Z1轴";
        else
            temp+=",Z1轴";
    }
    if(ZAAxisIsMove)
    {
        if(temp.isEmpty())
            temp+="Z轴";
        else
            temp+=",Z轴";
    }

    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，%1无法执行绝对定位。请先完成复位。").arg(temp),MY_WARN));
        return;
    }
    //
    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，%2无法执行绝对定位。请先停止运动或等待任务结束。").arg(lastTaskName).arg(temp),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    if((!XAxisIsMove)&&(!YAxisIsMove)&&(!ZAxisIsMove)&&(!ZAAxisIsMove))
    {
        emit exceptSGL(MyException(QString("没有选择执行绝对定位的轴。请选择待定位轴。"),MY_WARN));
        return;
    }

    //if(((XAxisIsMove)||(YAxisIsMove)) && (ZAxisIsMove || ZAAxisIsMove))
    {
        int axisBuf[4] = {0};
        double distPos[4] = {0};
        int moveMode[2] = {0};
        RS_SETTINGS->beginGroup("device/ABSMove/Pos");
        double myXAxisABSPos = RS_SETTINGS->readNumDEntry("/XAxis");
        double myYAxisABSPos = RS_SETTINGS->readNumDEntry("/YAxis");
        double myZAxisABSPos = RS_SETTINGS->readNumDEntry("/ZAxis");
        double myZAAxisABSPos = RS_SETTINGS->readNumDEntry("/ZAAxis");
        RS_SETTINGS->endGroup();
        axisBuf[0] = XAxisIsMove;
        axisBuf[1] = YAxisIsMove;
        axisBuf[2] = ZAxisIsMove;
        axisBuf[3] = ZAAxisIsMove;
        distPos[0] = myXAxisABSPos;
        distPos[1] = myYAxisABSPos;
        distPos[2] = myZAxisABSPos;
        distPos[3] = myZAAxisABSPos;
        moveMode[0] = 0;
        moveMode[1] = 0;

        int ret = AxisMoveSafeCheckXY(axisBuf,distPos,moveMode);
        if(ret < 0)
        {
            emit exceptSGL(MyException(QString("晶碇与Z轴间距太小，不能执行动作。"),MY_WARN));
            return;
        }
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("绝对定位执行中...");
        lastTaskIsFinish=false;
        lastTaskName="绝对定位";
        acsCtl->stopBuffer(1);
        char vname[]= ACSCTL_RUNF_V;
        acsCtl->setGlobalInt(vname,0);
        MAxisABSMoveCode mAxisABSMoveCode;

        RS_SETTINGS->beginGroup("device/ZAAxisSafe");
        double ZAAxisSafePos = RS_SETTINGS->readNumEntry("/pos");
        double ZAAxisToSafePosVel = RS_SETTINGS->readNumEntry("/vel");
        RS_SETTINGS->endGroup();

        mAxisABSMoveCode.setZAAxisSafePos(ZAAxisSafePos);
        mAxisABSMoveCode.setZAAxisToSafePosVel(ZAAxisToSafePosVel);

        mAxisABSMoveCode.setXAxisIsMove(XAxisIsMove);
        mAxisABSMoveCode.setYAxisIsMove(YAxisIsMove);
        mAxisABSMoveCode.setZAxisIsMove(ZAxisIsMove);
        mAxisABSMoveCode.setZAAxisIsMove(ZAAxisIsMove);

        //if((!XAxisIsMove)&&(!YAxisIsMove))
        {
            mAxisABSMoveCode.disableZAAxisToSafePos(true);
        }

        // 加载PTP位置设置
        RS_SETTINGS->beginGroup("device/ABSMove/Pos");
        double XAxisABSPos = RS_SETTINGS->readNumDEntry("/XAxis");
        double YAxisABSPos = RS_SETTINGS->readNumDEntry("/YAxis");
        double ZAxisABSPos = RS_SETTINGS->readNumDEntry("/ZAxis");
        double ZAAxisABSPos = RS_SETTINGS->readNumDEntry("/ZAAxis");
        RS_SETTINGS->endGroup();

        mAxisABSMoveCode.setXAxisTGPos(XAxisABSPos);
        mAxisABSMoveCode.setYAxisTGPos(YAxisABSPos);
        mAxisABSMoveCode.setZAxisTGPos(ZAxisABSPos);
        mAxisABSMoveCode.setZAAxisTGPos(ZAAxisABSPos);

        // 加载PTP位置设置
        RS_SETTINGS->beginGroup("device/ABSMove/Vel");
        double XAxisVel = RS_SETTINGS->readNumDEntry("/XAxis");
        double YAxisVel = RS_SETTINGS->readNumDEntry("/YAxis");
        double ZAxisVel = RS_SETTINGS->readNumDEntry("/ZAxis");
        double ZAAxisVel = RS_SETTINGS->readNumDEntry("/ZAAxis");
        RS_SETTINGS->endGroup();

        mAxisABSMoveCode.setXAxisVel(XAxisVel);
        mAxisABSMoveCode.setYAxisVel(YAxisVel);
        mAxisABSMoveCode.setZAxisVel(ZAxisVel);
        mAxisABSMoveCode.setZAAxisVel(ZAAxisVel);
        char *code;
        QByteArray byCode = mAxisABSMoveCode.getCode().toLatin1();
        code = byCode.data();

        acsCtl->loadBuffer(1,code);
        acsCtl->compileBuffer(1);
        acsCtl->runBuffer(1);

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(ABSMoveFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException(QString("%1绝对定位失败。").arg(temp),mye.getExceptCode()));
    }
}

void DeviceProxy:: RSToZero()
{

    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，无法执行测距传感器对零。请先完成复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行测距传感器对零。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    try
    {
        lastTaskIsFinish=false;
        lastTaskName="测距传感器对零";
        compCloseInSide();
        acsCtl->disableComp(ZAXIS);
        if(acsCtl->getBufferRunState(5))
        {
            acsCtl->stopBuffer(5);
        }
        emit MotionCompCloseFSGL();
        RSToZeroInSide();
        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(RSToZeroFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("测距传感器对零失败。",mye.getExceptCode()));
    }
}

void DeviceProxy:: MachSmallArea()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，无法执行特定区域加工。请先完成复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行特定区域加工。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    int axisBuf[4] = {0};
    axisBuf[1] = 1;
    int ret = AxisMoveSafeCheckXY(axisBuf,nullptr,nullptr);
    if(ret < 0)
    {
        emit exceptSGL(MyException(QString("晶碇与Z轴间距太小，不能执行动作。"),MY_WARN));
        return;
    }

    try
    {
        lastTaskIsFinish=false;
        lastTaskName="特定区域加工";
        MachSmallAreaInSide();
        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(MachSmallAreaFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("特定区域加工失败。",mye.getExceptCode()));
    }
}


void DeviceProxy::SScan()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，无法执行面扫描。请先完成复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行面扫描。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    try
    {
        lastTaskIsFinish=false;
        lastTaskName="面扫描";
        SScanInSide();
        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(SScanFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("面扫描失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::readSScanData()
{
    try
    {
        DEVICE_INFO->printDeviceSystemInfo("面扫描数据读取中...");
        lastTaskIsFinish=false;
        lastTaskName="读取面扫描数据";
        int totalNum = 0;
        SScanArMsrZ = acsCtl->getGlobalReal("ArMsrZ",2,0,totalNum-1);
        SScanArPosY = acsCtl->getGlobalReal("ArPosY",2,0,totalNum-1);
        lastTaskIsFinish=true;
        DEVICE_INFO->printDeviceSystemInfo("读取面扫描数据完成...");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("读取面扫描数据失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::saveSScanData()
{
    try{
        DEVICE_INFO->printDeviceSystemInfo("保存面扫描数据中...");
        lastTaskIsFinish=false;
        lastTaskName="保存面扫描数据";
        QDateTime datetime = QDateTime::currentDateTime();
        QString timestr = datetime.toString("ddHHmmzzz");
        QString path = "";
        if(path.right(1)!=QString("/"))
        {
            path+=QString("/");
        }
        QFile zData(path+"scanArMsrZ_"+timestr+".csv");
        QFile yData(path+"scanArMsrY_"+timestr+".csv");
        if(zData.open(QFile::WriteOnly|QFile::Truncate)&&yData.open(QFile::WriteOnly|QFile::Truncate))
        {
            QTextStream zOut(&zData);
            QTextStream yOut(&yData);
            for(auto i=0;i<SScanArMsrZ.size();i++)
            {
                zOut << SScanArMsrZ.at(i)<<"\n";
                yOut << SScanArPosY.at(i) << "\n";
            }
        }
        else
        {
            throw MyException(QString("保存面扫描数据错误！"));
        }
        zData.close();
        yData.close();
        //添加异常代码
        lastTaskIsFinish = true;
        DEVICE_INFO->printDeviceSystemInfo("保存面扫描数据完成");
    }
    catch(MyException mye)
    {
        exceptHandl(MyException("保存面扫描数据失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::buildSScanDataTable()
{
    //找Y0,Y1
    // startPos x y z zA

    RS_SETTINGS->beginGroup("device/SSCS");
    double yWorkRange = RS_SETTINGS->readNumDEntry("/YRange",1.0);
    double yInterval = RS_SETTINGS->readNumDEntry("/YInterval",1.0);
    RS_SETTINGS->endGroup();

    double ySampNum = int(yWorkRange/yInterval);
    const double sampPointInterval = 0.5;      // v=100mm/s t采样时间间隔 = 1ms
    QVector<int> startYIndexOdd,startYIndexEven;
    QVector<double> realStartYOdd,realStartYEven;

    double startY=SSStartYPos;

    for(auto i=0;i<SScanArPosY.size()-1;i++)
    {
        if((startY>=SScanArPosY.at(i))&&(startY<=SScanArPosY.at(i+1)))
        {
            startYIndexOdd.append(i);
            realStartYOdd.append(SScanArPosY.at(i));
        }

        if((startY<=SScanArPosY.at(i))&&(startY>=SScanArPosY.at(i+1)))
        {
            if(0==int(SScanArPosY.at(i+1)))
            {
                continue;
            }
            startYIndexEven.append(i+1);
            realStartYEven.append(SScanArPosY.at(i+1));
        }
    }
    //根据Y的索引号提取Z
    QVector<QVector<double>> surfaceScanDataTableTemp;
    for(auto i=0;i<startYIndexOdd.size();i++)
    {
        int index = startYIndexOdd.at(i);
        QVector<double> arMsrZValidOdd;
        arMsrZValidOdd.append(SScanArMsrZ.at(index));
        for(auto j=1;j<=ySampNum;j++)
        {
            index +=  int(yInterval/sampPointInterval);
            arMsrZValidOdd.append(SScanArMsrZ.at(index));
        }

        surfaceScanDataTableTemp.append(arMsrZValidOdd);
        if(i>= startYIndexEven.size())
        {
            continue;
        }
        index = startYIndexEven.at(i);
        QVector<double> arMsrZValidEven;
        arMsrZValidEven.append(SScanArMsrZ.at(index));
        for(auto j=1;j<=ySampNum;j++)
        {
            index -=  int(yInterval/sampPointInterval);
            arMsrZValidEven.append(SScanArMsrZ.at(index));
        }

        surfaceScanDataTableTemp.append(arMsrZValidEven);
    }

    SScanDataTable = surfaceScanDataTableTemp;
}


void DeviceProxy::saveSScanDataTable()
{
    try{
        DEVICE_INFO->printDeviceSystemInfo("保存面扫描数据2中...");
        lastTaskIsFinish=false;
        lastTaskName="保存面扫描数据2";
        QDateTime datetime = QDateTime::currentDateTime();
        QString timestr = datetime.toString("ddHHmmzzz");
        RS_SETTINGS->beginGroup("device/SSCS");
        QString path = RS_SETTINGS->readEntry("/dataSavePath");
        RS_SETTINGS->endGroup();

        if(path.right(1)!=QString("/"))
        {
            path+=QString("/");
        }
        QFile surfaceScanDataTableFile(path+"ScanDataTable_"+timestr+".csv");

        if(surfaceScanDataTableFile.open(QFile::WriteOnly|QFile::Truncate))
        {
            QTextStream surfaceScanDataTableOut(&surfaceScanDataTableFile);

            int cols = SScanDataTable.at(0).size();
            int rows = SScanDataTable.size();

            // y为行

            for(auto i=0;i<rows;i++)
            {
                for(auto j=0;j<cols;j++)
                {
                    surfaceScanDataTableOut << SScanDataTable.at(i).at(j)<<",";
                }
                surfaceScanDataTableOut << "\n";
            }
            // x为行
            //            for(auto i=0;i<cols;i++)
            //            {
            //                for(auto j=0;j<rows;j++)
            //                {
            //                    lookUpTableOut << lookupTable.at(j).at(i)<<",";
            //                }
            //                lookUpTableOut << "\n";
            //            }
        }
        else
        {
            throw MyException(QString("保存查找表错误！"));
        }
        surfaceScanDataTableFile.close();

        DEVICE_INFO->printDeviceSystemInfo("保存面扫描数据2完成");
        lastTaskIsFinish=true;
    }
    catch(MyException mye)
    {
        exceptHandl(MyException("保存面扫描数据2失败。",mye.getExceptCode()));
    }
}



void DeviceProxy::compSScan()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，无法执行扫描补偿。请先完成复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行扫描补偿。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    int axisBuf[4] = {0};
    axisBuf[1] = 1;
    int ret = AxisMoveSafeCheckXY(axisBuf,nullptr,nullptr);
    if(ret < 0)
    {
        emit exceptSGL(MyException(QString("晶碇与Z轴间距太小，不能执行动作。"),MY_WARN));
        return;
    }
    //    {
    //        short value = 0;
    //        if (BAROMETER->m_hComm == nullptr)
    //        {
    //            BAROMETER->getSerialSet("barometer");
    //            bool ret = BAROMETER->OpenComm();
    //            if (!ret)
    //            {
    //                emit exceptSGL(MyException(QString("检查真空吸盘状态失败！"),MY_WARN));
    //                return;
    //            }
    //        }
    //        int ret = BAROMETER->GetHeightValue(18,1,&value);
    //        if (ret != 0)
    //        {
    //            emit exceptSGL(MyException(QString("检查真空吸盘状态失败！"),MY_WARN));
    //            return;
    //        }
    //        double tmp = value / 10.0;
    //        if (tmp > -10)
    //        {
    //            emit exceptSGL(MyException(QString("真空吸盘未开启真空！"),MY_WARN));
    //            return;
    //        }
    //    }
    try
    {
        lastTaskIsFinish=false;
        lastTaskName="补偿面扫描";

        compSScanInSide();

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(compSScanFHandl()));

        reqCMDRunFState = true;

    }
    catch (MyException mye)
    {
        exceptHandl(MyException(mye.getExceptInfo(),mye.getExceptCode()));
    }

}


void DeviceProxy::readCompSScanData()
{
    DEVICE_INFO->printDeviceSystemInfo("补偿面扫描数据读取中...");
    char vname[]= ACSCTL_SAMPTOTALNUM;
    int totalNum = acsCtl->getGlobalInt(vname);
    char RSData[] = ACSCTL_RSDATA_V;
    char xPosData[] = ACSCTL_XPOSDATA_V ;
    CSS_RSData = acsCtl->getGlobalReal(RSData,1,0,totalNum-1);
    CSS_XPosData = acsCtl->getGlobalReal(xPosData,1,0,totalNum-1);
    DEVICE_INFO->printDeviceSystemInfo("读取补偿面扫描数据完成");
}


void DeviceProxy::saveCompSScanData()
{
    DEVICE_INFO->printDeviceSystemInfo("补偿面扫描数据保存中...");
    QDateTime datetime = QDateTime::currentDateTime();
    QString timestr = datetime.toString("ddHHmmzzz");
    RS_SETTINGS->beginGroup("device/SSCS");
    QString path = RS_SETTINGS->readEntry("/dataSavePath");
    RS_SETTINGS->endGroup();

    if(path.right(1)!=QString("/"))
    {
        path+=QString("/");
    }
    QFile zData(path+"CSS_RSData_"+timestr+".csv");
    QFile yData(path+"CSS_YPosData_"+timestr+".csv");
    if(zData.open(QFile::WriteOnly|QFile::Truncate)&&yData.open(QFile::WriteOnly|QFile::Truncate))
    {
        QTextStream zOut(&zData);
        QTextStream yOut(&yData);
        for(auto i=0;i<CSS_RSData.size();i++)
        {
            zOut << CSS_RSData.at(i)<<"\n";
            yOut << CSS_XPosData.at(i) << "\n";
        }
    }
    else
    {
        throw MyException(QString("保存补偿面扫描数据错误！"));
    }
    zData.close();
    yData.close();
    DEVICE_INFO->printDeviceSystemInfo("补偿面扫描数据保存成功...");
    //添加异常代码
}
void my_sort(double *a,int len)
{
    int i=0;
    int j;
    double t;
    for(i=0;i<len-1;i++)
    {
        for(j=0;j<len-i-1;j++)
        {
            if(a[j]>a[j+1])
            {
                t=a[j];
                a[j]=a[j+1];
                a[j+1]=t;
            }
        }
    }
}
double my_cal_data(double *a,int len)
{
    int i=0;
    double t = 0;
    for(i=0;i<len;i++)
    {
        t = t + a[i];
    }
    return t/len;
}
double cal_data(double *a,int len,int postion)
{
    double data_buf_k[100];
    double data_buf_k_abs[100];
    double data_mean = 0.0003;
    int i;
    if (len > 100)
        return a[postion];
    data_buf_k[0] = 0;
    for (i=1; i<len; i++)
    {
        data_buf_k[i] = a[i] - a[i-1];
    }

    for (i=0; i<len; i++)
    {
        if (fabs(data_buf_k[i]) > data_mean)// = a[i] - a[i-1];
        {
            break;
        }
    }
    if (i>=len) return a[postion];


    double maxData = 0;
    int max_index = 0;
    for (i=0; i<len; i++)
    {
        if (fabs(data_buf_k[i]) > maxData)
        {
            maxData = fabs(data_buf_k[i]);
            max_index = i;
        }

    }

    for (i=0; i<len; i++)
    {
        data_buf_k_abs[i] = fabs(data_buf_k[i]);

    }
    my_sort(data_buf_k_abs,len);
    data_mean = my_cal_data(&data_buf_k_abs[5],len-10);

    for (i=max_index; i<len-1; i++)
    {
        //if (i< len-2)
        {
            if (fabs(data_buf_k[i]) <= data_mean)
            {

                break;
            }
        }
    }
    int fangw_max = i;
    for (i=max_index; i>=0; i--)
    {
        //if (i< len-2)
        {
            if (fabs(data_buf_k[i]) <= data_mean)
            {

                break;
            }
        }
    }
    int fangw_min = i;

    if ((postion < fangw_min) || (postion > fangw_max))
    {
        return a[postion];
    }
    else
    {
        int lange1,lange2;
        lange1 = postion - fangw_min;
        lange2 = fangw_max - postion;
        if (lange1 <= lange2)
            return a[fangw_min];
        else
            return a[fangw_max];
    }
    //return max_index;
}
int my_cal_k(double *a,int len)
{
    double data_buf_k[100];
    double data_buf_k_abs[100];
    //double data_mean_max = 0.001;
    double data_mean = 0.0003;
    int i;
    if (len > 100)
        return 0;
    data_buf_k[0] = 0;
    for (i=1; i<len; i++)
    {
        data_buf_k[i] = a[i] - a[i-1];
    }
    double maxData = 0;
    int max_index = 0;
    for (i=0; i<len; i++)
    {
        if (fabs(data_buf_k[i]) > maxData)
        {
            maxData = fabs(data_buf_k[i]);
            max_index = i;
        }

    }
    for (i=0; i<len; i++)
    {
        data_buf_k_abs[i] = fabs(data_buf_k[i]);

    }
    //    my_sort(data_buf_k_abs,100);
    //    data_mean = my_cal_data(&data_buf_k_abs[25],50);
    //    if (data_mean > data_mean_max) data_mean = data_mean_max;
    for (i=max_index; i<len-1; i++)
    {
        //if (i< len-2)
        {
            if (fabs(data_buf_k[i]) <= data_mean)
            {

                break;
            }
        }
    }
    max_index = i;
    return max_index;
}
//void DeviceProxy::buildLookupTable_lhc()
//{
//    RS_SETTINGS->beginGroup("device/SSCS");
//    double yWorkRange = RS_SETTINGS->readNumDEntry("/YRange",1.0);
//    double yInterval = RS_SETTINGS->readNumDEntry("/YInterval",1.0);
//    RS_SETTINGS->endGroup();

//    //找Y0,Y1
//    // startPos x y z zA

//    double ySampNum = int(yWorkRange/yInterval);
//    const double sampPointInterval = 0.1;      // v=100mm/s t采样时间间隔 = 1ms
//    QVector<int> startYIndexOdd,startYIndexEven;
//    QVector<double> realStartYOdd,realStartYEven;

//    double startY=SSStartYPos;

//    for(auto i=0;i<CSS_YPosData.size()-1;i++)
//    {
//        // 获取奇数列的Y起始位置索引（列数从1算起）
//        if((startY>=CSS_YPosData.at(i))&&(startY<=CSS_YPosData.at(i+1)))
//        {
//            startYIndexOdd.append(i);
//            // 找到的实际Y起始位置
//            realStartYOdd.append(CSS_YPosData.at(i));  // Y位置起始值
//        }
//        // 偶数列
//        if((startY<=CSS_YPosData.at(i))&&(startY>=CSS_YPosData.at(i+1)))
//        {
//            if(0==int(CSS_YPosData.at(i+1)))
//            {
//                continue;
//            }
//            startYIndexEven.append(i+1);
//            realStartYEven.append(CSS_YPosData.at(i+1));
//        }
//    }
//    //根据Y的索引号提取Z
//    QVector<QVector<double>> lookupTableTemp;
//    for(auto i=0;i<startYIndexOdd.size();i++)
//    {

//        int index = startYIndexOdd.at(i);//截取测距值的起始索引
//        QVector<double> startRSValueIndexOdd;
//        startRSValueIndexOdd.append(CSS_RSData.at(index));
//         // 从第一列开始取测距值，随着循环开始取第三列、第四列...
//        for(auto j=1;j<=ySampNum;j++)
//        {
//            //取数据的步距
//            double data;
//            index +=  int(yInterval/sampPointInterval);
//            {
//                //double data;
//                double data_buf[20];
//                data = CSS_RSData.at(index);
//                if (data > -10)
//                {
//                    int tmp_index,point_num;
//                    tmp_index = index;
//                    point_num = 15;
//                    if (CSS_RSData.at(tmp_index-point_num) < -10)
//                    {
//                        int tmpkk;
//                        for (tmpkk = point_num;tmpkk>0;tmpkk--)
//                        {
//                            if (CSS_RSData.at(tmp_index-tmpkk) > -10)
//                            {
//                                break;
//                            }
//                        }
//                        tmp_index = tmp_index + (point_num - tmpkk);
//                    }
//                    if (CSS_RSData.at(tmp_index+point_num) < -10)
//                    {
//                        int tmpkk;
//                        for (tmpkk = point_num;tmpkk>0;tmpkk--)
//                        {
//                            if (CSS_RSData.at(tmp_index+tmpkk) > -10)
//                            {
//                                break;
//                            }
//                        }
//                        tmp_index = tmp_index - (point_num - tmpkk);
//                    }
//                   for (auto kkk=0;kkk<20;kkk++)
//                   {

//                       data_buf[kkk] = CSS_RSData.at(tmp_index-10+kkk);
//                   }
//                   my_sort(data_buf,20);
//                    data = my_cal_data(&data_buf[5],10);

//                }
//            }
//            startRSValueIndexOdd.append(data);
//        }

//        lookupTableTemp.append(startRSValueIndexOdd);

//        // 偶数列比奇数列少一列
//        if(i>= startYIndexEven.size())
//        {
//            continue;
//        }

//        // 取偶数列数据
//        index = startYIndexEven.at(i);
//        QVector<double> arMsrZValidEven;
//        arMsrZValidEven.append(CSS_RSData.at(index));
//        for(auto j=1;j<=ySampNum;j++)
//        {
//            double data;
//            index -=  int(yInterval/sampPointInterval);
//            {
//                double data_buf[20];
//                data = CSS_RSData.at(index);
//                if (data > -10)
//                {
//                    int tmp_index,point_num;
//                    point_num = 15;
//                    tmp_index = index;
//                    if (CSS_RSData.at(tmp_index-point_num) < -10)
//                    {
//                        int tmpkk;
//                        for (tmpkk = point_num;tmpkk>0;tmpkk--)
//                        {
//                            if (CSS_RSData.at(tmp_index-tmpkk) > -10)
//                            {
//                                break;
//                            }
//                        }
//                        tmp_index = tmp_index + (point_num - tmpkk);
//                    }
//                    if (CSS_RSData.at(tmp_index+point_num) < -10)
//                    {
//                        int tmpkk;
//                        for (tmpkk = point_num;tmpkk>0;tmpkk--)
//                        {
//                            if (CSS_RSData.at(tmp_index+tmpkk) > -10)
//                            {
//                                break;
//                            }
//                        }
//                        tmp_index = tmp_index - (point_num - tmpkk);
//                    }
//                   for (auto kkk=0;kkk<20;kkk++)
//                   {

//                       data_buf[kkk] = CSS_RSData.at(tmp_index-10+kkk);
//                   }
//                   my_sort(data_buf,20);
//                    data = my_cal_data(&data_buf[5],10);

//                }
//            }
//            arMsrZValidEven.append(data);
//        }

//        lookupTableTemp.append(arMsrZValidEven);
//    }

//    lookupTable = lookupTableTemp;

//}
void DeviceProxy::buildLookupTable_lhc()
{
    RS_SETTINGS->beginGroup("device/SSCS");
    double xWorkRange = RS_SETTINGS->readNumDEntry("/XRange",1.0);
    double xInterval = RS_SETTINGS->readNumDEntry("/XInterval",1.0);
    RS_SETTINGS->endGroup();

    //找Y0,Y1
    // startPos x y z zA
    double dbHeightCheck = -0.03;

    double ySampNum = int(xWorkRange/xInterval);
    const double sampPointInterval = 0.5;      // v=100mm/s t采样时间间隔 = 1ms
    QVector<int> startXIndexOdd,startXIndexEven;
    QVector<double> realStartXOdd,realStartXEven;

    double startX=SSStartXPos;
    //double data_buf[100];
    const int PointNum = 4;//int(yInterval/sampPointInterval);

    for(auto i=0;i<CSS_XPosData.size()-1;i++)
    {
        // 获取奇数列的Y起始位置索引（列数从1算起）
        if((startX>=CSS_XPosData.at(i))&&(startX<=CSS_XPosData.at(i+1)))
        {
            startXIndexOdd.append(i);
            // 找到的实际Y起始位置
            realStartXOdd.append(CSS_XPosData.at(i));  // Y位置起始值
        }
        // 偶数列
        if((startX<=CSS_XPosData.at(i))&&(startX>=CSS_XPosData.at(i+1)))
        {
            if(0==int(CSS_XPosData.at(i+1)))
            {
                continue;
            }
            startXIndexEven.append(i+1);
            realStartXEven.append(CSS_XPosData.at(i+1));
        }
    }
    //根据Y的索引号提取Z
    QVector<QVector<double>> lookupTableTemp;
    for(auto i=0;i<startXIndexOdd.size();i++)
    {

        int index = startXIndexOdd.at(i);//截取测距值的起始索引
        QVector<double> startRSValueIndexOdd;
        startRSValueIndexOdd.append(CSS_RSData.at(index));
        // 从第一列开始取测距值，随着循环开始取第三列、第四列...
        for(auto j=1;j<=ySampNum;j++)
        {
            //取数据的步距
            double data;
            index +=  int(xInterval/sampPointInterval);
            {
                //double data;

                data = CSS_RSData.at(index);
                if (data > dbHeightCheck)
                {
                    int tmp_index,point_num;
                    tmp_index = index;

                    point_num = int(xInterval/sampPointInterval);
                    if (CSS_RSData.at(tmp_index-point_num) < dbHeightCheck)
                    {
                        int tmpkk;
                        for (tmpkk = point_num;tmpkk>0;tmpkk--)
                        {
                            if (CSS_RSData.at(tmp_index-tmpkk) > dbHeightCheck)
                            {
                                break;
                            }
                        }
                        int s_index = tmp_index-tmpkk;
                        if ((s_index + PointNum) > tmp_index)
                            data = CSS_RSData.at(s_index + PointNum);

                        startRSValueIndexOdd[startRSValueIndexOdd.size()-1] = CSS_RSData.at(s_index + PointNum);


                    }
                    else if (CSS_RSData.at(tmp_index+point_num) < dbHeightCheck)
                    {
                        int tmpkk;
                        for (tmpkk = point_num;tmpkk>0;tmpkk--)
                        {
                            if (CSS_RSData.at(tmp_index+tmpkk) > dbHeightCheck)
                            {
                                break;
                            }
                        }
                        //tmp_index = tmp_index - (point_num - tmpkk);
                        //tmp_index = tmp_index+tmpkk;
                        int s_index = tmp_index+tmpkk;

                        if ((s_index - PointNum) < tmp_index)
                            data = CSS_RSData.at(s_index - PointNum);
                    }


                }
                else
                {
                    int tmp_index,point_num;//,tmp_index_p,tmp_index_n;
                    tmp_index = index;
                    point_num = int(xInterval/sampPointInterval);
                    if (CSS_RSData.at(tmp_index-point_num)  > dbHeightCheck)
                    {
                        int tmpkk;
                        for (tmpkk =0;tmpkk<point_num;tmpkk++)
                        {
                            if (CSS_RSData.at(tmp_index-tmpkk) > dbHeightCheck)
                            {
                                break;
                            }
                        }
                        int s_index = tmp_index-tmpkk;
                        data = CSS_RSData.at(s_index - PointNum);
                    }
                }


            }
            startRSValueIndexOdd.append(data);

        }

        lookupTableTemp.append(startRSValueIndexOdd);

        // 偶数列比奇数列少一列
        if(i>= startXIndexEven.size())
        {
            continue;
        }

        // 取偶数列数据
        index = startXIndexEven.at(i);
        QVector<double> arMsrZValidEven;
        arMsrZValidEven.append(CSS_RSData.at(index));
        for(auto j=1;j<=ySampNum;j++)
        {
            double data;
            index -=  int(xInterval/sampPointInterval);
            {

                data = CSS_RSData.at(index);
                if (data > dbHeightCheck)
                {
                    int tmp_index,point_num;
                    tmp_index = index;

                    point_num = int(xInterval/sampPointInterval);
                    if (CSS_RSData.at(tmp_index-point_num) < dbHeightCheck)
                    {
                        int tmpkk;
                        for (tmpkk = point_num;tmpkk>0;tmpkk--)
                        {
                            if (CSS_RSData.at(tmp_index-tmpkk) > dbHeightCheck)
                            {
                                break;
                            }
                        }
                        int s_index = tmp_index-tmpkk;
                        if ((s_index + PointNum) > tmp_index)
                            data = CSS_RSData.at(s_index + PointNum);




                    }
                    else if (CSS_RSData.at(tmp_index+point_num) < dbHeightCheck)
                    {
                        int tmpkk;
                        for (tmpkk = point_num;tmpkk>0;tmpkk--)
                        {
                            if (CSS_RSData.at(tmp_index+tmpkk) > dbHeightCheck)
                            {
                                break;
                            }
                        }
                        //tmp_index = tmp_index - (point_num - tmpkk);
                        //tmp_index = tmp_index+tmpkk;
                        int s_index = tmp_index+tmpkk;

                        if ((s_index - PointNum) < tmp_index)
                            data = CSS_RSData.at(s_index - PointNum);
                        arMsrZValidEven[arMsrZValidEven.size()-1] = CSS_RSData.at(s_index - PointNum);
                    }


                }
                else
                {
                    int tmp_index,point_num;//,tmp_index_p,tmp_index_n;
                    tmp_index = index;
                    point_num = int(xInterval/sampPointInterval);
                    if (CSS_RSData.at(tmp_index+point_num)  > dbHeightCheck)
                    {
                        int tmpkk;
                        for (tmpkk =0;tmpkk<point_num;tmpkk++)
                        {
                            if (CSS_RSData.at(tmp_index+tmpkk) > dbHeightCheck)
                            {
                                break;
                            }
                        }
                        int s_index = tmp_index+tmpkk;
                        data = CSS_RSData.at(s_index + PointNum);
                    }
                }

            }
            arMsrZValidEven.append(data);
        }

        lookupTableTemp.append(arMsrZValidEven);
    }

    lookupTable = lookupTableTemp;

}
void DeviceProxy::buildLookupTable_lhc2()
{
    RS_SETTINGS->beginGroup("device/SSCS");
    double xWorkRange = RS_SETTINGS->readNumDEntry("/XRange",1.0);
    double xInterval = RS_SETTINGS->readNumDEntry("/XInterval",1.0);
    RS_SETTINGS->endGroup();

    //找Y0,Y1
    // startPos x y z zA

    double ySampNum = int(xWorkRange/xInterval);
    double dbHeightCheck = -0.03;
    const double sampPointInterval = 0.5;      // v=100mm/s t采样时间间隔 = 1ms
    const int PointNum = 4;//int(yInterval/sampPointInterval);


    QVector<double> realStartXOdd,realStartXEven;
    QVector<QVector<int>> startXIndexOddTable,startXIndexEvenTable;
    QVector<int> startXIndexOdd,startXIndexEven;
    double startX=SSStartXPos;
    QVector<QVector<double>> lookupTableTemp;
    for (int k=0;k<=ySampNum;k++)
    {

        for(auto i=0;i<CSS_XPosData.size()-1;i++)
        {
            // 获取奇数列的Y起始位置索引（列数从1算起）
            if((startX>=CSS_XPosData.at(i))&&(startX<=CSS_XPosData.at(i+1)))
            {
                startXIndexOdd.append(i);
                // 找到的实际Y起始位置
                realStartXOdd.append(CSS_XPosData.at(i));  // Y位置起始值
            }
            // 偶数列
            if((startX<=CSS_XPosData.at(i))&&(startX>=CSS_XPosData.at(i+1)))
            {
                if(0==int(CSS_XPosData.at(i+1)))
                {
                    continue;
                }
                startXIndexEven.append(i+1);
                realStartXEven.append(CSS_XPosData.at(i+1));
            }
        }
        startX += xInterval;
        startXIndexOddTable.append(startXIndexOdd);
        startXIndexEvenTable.append(startXIndexEven);
        QVector<int>().swap(startXIndexOdd);
        QVector<int>().swap(startXIndexEven);
    }

    for (int i=0;i<startXIndexOddTable[0].size();i++)
    {
        int index;// = startXIndexOddTable[0][i];//截取测距值的起始索引
        QVector<double> startRSValueIndexOdd;

        // 从第一列开始取测距值，随着循环开始取第三列、第四列...
        for(auto j=0;j<=ySampNum;j++)
        {
            index = startXIndexOddTable[j][i];//截取测距值的起始索引
            double data;
            {
                //double data;

                data = CSS_RSData.at(index);
                if (data > dbHeightCheck)
                {
                    int tmp_index,point_num;
                    tmp_index = index;

                    point_num = int(xInterval/sampPointInterval);
                    if (CSS_RSData.at(tmp_index-point_num) < dbHeightCheck)
                    {
                        int tmpkk;
                        for (tmpkk = point_num;tmpkk>0;tmpkk--)
                        {
                            if (CSS_RSData.at(tmp_index-tmpkk) > dbHeightCheck)
                            {
                                break;
                            }
                        }
                        int s_index = tmp_index-tmpkk;
                        if ((s_index + PointNum) > tmp_index)
                            data = CSS_RSData.at(s_index + PointNum);
                        if (startRSValueIndexOdd.size() >= 1)
                            startRSValueIndexOdd[startRSValueIndexOdd.size()-1] = CSS_RSData.at(s_index + PointNum);


                    }
                    else if (CSS_RSData.at(tmp_index+point_num) < dbHeightCheck)
                    {
                        int tmpkk;
                        for (tmpkk = point_num;tmpkk>0;tmpkk--)
                        {
                            if (CSS_RSData.at(tmp_index+tmpkk) > dbHeightCheck)
                            {
                                break;
                            }
                        }
                        //tmp_index = tmp_index - (point_num - tmpkk);
                        //tmp_index = tmp_index+tmpkk;
                        int s_index = tmp_index+tmpkk;

                        if ((s_index - PointNum) < tmp_index)
                            data = CSS_RSData.at(s_index - PointNum);
                    }


                }
                else
                {
                    int tmp_index,point_num;//,tmp_index_p,tmp_index_n;
                    tmp_index = index;
                    point_num = int(xInterval/sampPointInterval);
                    if (CSS_RSData.at(tmp_index-point_num)  > dbHeightCheck)
                    {
                        int tmpkk;
                        for (tmpkk =0;tmpkk<point_num;tmpkk++)
                        {
                            if (CSS_RSData.at(tmp_index-tmpkk) > dbHeightCheck)
                            {
                                break;
                            }
                        }
                        int s_index = tmp_index-tmpkk;
                        data = CSS_RSData.at(s_index - PointNum);
                    }
                }


            }
            startRSValueIndexOdd.append(data);
            //startRSValueIndexOdd.append(CSS_RSData.at(index));
        }
        lookupTableTemp.append(startRSValueIndexOdd);

        if(i>= startXIndexEvenTable[0].size())
        {
            continue;
        }

        QVector<double> arMsrZValidEven;
        for(auto j=0;j<=ySampNum;j++)
        {
            double data;
            index = startXIndexEvenTable[j][i];//截取测距值的起始索引
            {

                data = CSS_RSData.at(index);
                if (data > dbHeightCheck)
                {
                    int tmp_index,point_num;
                    tmp_index = index;

                    point_num = int(xInterval/sampPointInterval);
                    if (CSS_RSData.at(tmp_index-point_num) < dbHeightCheck)
                    {
                        int tmpkk;
                        for (tmpkk = point_num;tmpkk>0;tmpkk--)
                        {
                            if (CSS_RSData.at(tmp_index-tmpkk) > dbHeightCheck)
                            {
                                break;
                            }
                        }
                        int s_index = tmp_index-tmpkk;
                        if ((s_index + PointNum) > tmp_index)
                            data = CSS_RSData.at(s_index + PointNum);




                    }
                    else if (CSS_RSData.at(tmp_index+point_num) < dbHeightCheck)
                    {
                        int tmpkk;
                        for (tmpkk = point_num;tmpkk>0;tmpkk--)
                        {
                            if (CSS_RSData.at(tmp_index+tmpkk) > dbHeightCheck)
                            {
                                break;
                            }
                        }
                        //tmp_index = tmp_index - (point_num - tmpkk);
                        //tmp_index = tmp_index+tmpkk;
                        int s_index = tmp_index+tmpkk;

                        if ((s_index - PointNum) < tmp_index)
                            data = CSS_RSData.at(s_index - PointNum);
                        if (arMsrZValidEven.size() >= 1)
                            arMsrZValidEven[arMsrZValidEven.size()-1] = CSS_RSData.at(s_index - PointNum);
                    }


                }
                else
                {
                    int tmp_index,point_num;//,tmp_index_p,tmp_index_n;
                    tmp_index = index;
                    point_num = int(xInterval/sampPointInterval);
                    if (CSS_RSData.at(tmp_index+point_num)  > dbHeightCheck)
                    {
                        int tmpkk;
                        for (tmpkk =0;tmpkk<point_num;tmpkk++)
                        {
                            if (CSS_RSData.at(tmp_index+tmpkk) > dbHeightCheck)
                            {
                                break;
                            }
                        }
                        int s_index = tmp_index+tmpkk;
                        data = CSS_RSData.at(s_index + PointNum);
                    }
                }

            }
            arMsrZValidEven.append(data);

            //arMsrZValidEven.append(CSS_RSData.at(index));
        }

        lookupTableTemp.append(arMsrZValidEven);


    }


    lookupTable = lookupTableTemp;

}
void DeviceProxy::buildLookupTable2()
{
    RS_SETTINGS->beginGroup("device/SSCS");
    double xWorkRange = RS_SETTINGS->readNumDEntry("/XRange",1.0);
    double xInterval = RS_SETTINGS->readNumDEntry("/XInterval",1.0);
    RS_SETTINGS->endGroup();

    //找Y0,Y1
    // startPos x y z zA

    double ySampNum = int(xWorkRange/xInterval);
    double dbHeightCheck = -0.03;
    const double sampPointInterval = 0.5;      // v=100mm/s t采样时间间隔 = 1ms
    const int PointNum = 4;//int(yInterval/sampPointInterval);


    QVector<double> realStartXOdd,realStartXEven;
    QVector<QVector<int>> startXIndexOddTable,startXIndexEvenTable;
    QVector<int> startXIndexOdd,startXIndexEven;
    double startX=SSStartXPos;
    QVector<QVector<double>> lookupTableTemp;
    for (int k=0;k<=ySampNum;k++)
    {

        for(auto i=0;i<CSS_XPosData.size()-1;i++)
        {
            // 获取奇数列的Y起始位置索引（列数从1算起）
            if((startX>=CSS_XPosData.at(i))&&(startX<=CSS_XPosData.at(i+1)))
            {
                if ((startX - CSS_XPosData.at(i)) > (CSS_XPosData.at(i+1) - startX))
                {
                    startXIndexOdd.append(i+1);
                    realStartXOdd.append(CSS_XPosData.at(i+1));  // Y位置起始值
                }
                else
                {
                    startXIndexOdd.append(i);
                    realStartXOdd.append(CSS_XPosData.at(i));  // Y位置起始值
                }
                // 找到的实际Y起始位置

            }
            // 偶数列
            if((startX<=CSS_XPosData.at(i))&&(startX>=CSS_XPosData.at(i+1)))
            {
                if(0==int(CSS_XPosData.at(i+1)))
                {
                    continue;
                }
                if ((CSS_XPosData.at(i) - startX) > (startX - CSS_XPosData.at(i+1)))
                {
                    startXIndexEven.append(i+1);
                    realStartXEven.append(CSS_XPosData.at(i+1));
                }
                else
                {
                    startXIndexEven.append(i);
                    realStartXEven.append(CSS_XPosData.at(i));
                }

                //startXIndexEven.append(i+1);
                //realStartXEven.append(CSS_XPosData.at(i+1));
            }
        }
        startX += xInterval;
        startXIndexOddTable.append(startXIndexOdd);
        startXIndexEvenTable.append(startXIndexEven);
        QVector<int>().swap(startXIndexOdd);
        QVector<int>().swap(startXIndexEven);
    }

    for (int i=0;i<startXIndexOddTable[0].size();i++)
    {
        int index;// = startXIndexOddTable[0][i];//截取测距值的起始索引
        QVector<double> startRSValueIndexOdd;

        // 从第一列开始取测距值，随着循环开始取第三列、第四列...
        for(auto j=0;j<=ySampNum;j++)
        {
            index = startXIndexOddTable[j][i];//截取测距值的起始索引
            double data;
            {
                //double data;

                data = CSS_RSData.at(index);

            }
            startRSValueIndexOdd.append(data);
            //startRSValueIndexOdd.append(CSS_RSData.at(index));
        }
        lookupTableTemp.append(startRSValueIndexOdd);

        if(i>= startXIndexEvenTable[0].size())
        {
            continue;
        }

        QVector<double> arMsrZValidEven;
        for(auto j=0;j<=ySampNum;j++)
        {
            double data;
            index = startXIndexEvenTable[j][i];//截取测距值的起始索引
            {

                data = CSS_RSData.at(index);

            }
            arMsrZValidEven.append(data);

            //arMsrZValidEven.append(CSS_RSData.at(index));
        }

        lookupTableTemp.append(arMsrZValidEven);


    }


    lookupTable = lookupTableTemp;

}
void DeviceProxy::buildLookupTable()
{
    RS_SETTINGS->beginGroup("device/SSCS");
    double xWorkRange = RS_SETTINGS->readNumDEntry("/XRange",1.0);
    double xInterval = RS_SETTINGS->readNumDEntry("/XInterval",1.0);
    RS_SETTINGS->endGroup();

    //找Y0,Y1
    // startPos x y z zA

    double ySampNum = int(xWorkRange/xInterval);
    const double sampPointInterval = 0.5;      // v=100mm/s t采样时间间隔 = 1ms
    QVector<int> startXIndexOdd,startXIndexEven;
    QVector<double> realStartXOdd,realStartXEven;

    double startX=SSStartXPos;

    for(auto i=0;i<CSS_XPosData.size()-1;i++)
    {
        // 获取奇数列的Y起始位置索引（列数从1算起）
        if((startX>=CSS_XPosData.at(i))&&(startX<=CSS_XPosData.at(i+1)))
        {
            startXIndexOdd.append(i);
            // 找到的实际Y起始位置
            realStartXOdd.append(CSS_XPosData.at(i));  // Y位置起始值
        }
        // 偶数列
        if((startX<=CSS_XPosData.at(i))&&(startX>=CSS_XPosData.at(i+1)))
        {
            if(0==int(CSS_XPosData.at(i+1)))
            {
                continue;
            }
            startXIndexEven.append(i+1);
            realStartXEven.append(CSS_XPosData.at(i+1));
        }
    }
    //根据Y的索引号提取Z
    QVector<QVector<double>> lookupTableTemp;
    for(auto i=0;i<startXIndexOdd.size();i++)
    {

        int index = startXIndexOdd.at(i);//截取测距值的起始索引
        QVector<double> startRSValueIndexOdd;
        startRSValueIndexOdd.append(CSS_RSData.at(index));
        // 从第一列开始取测距值，随着循环开始取第三列、第四列...
        for(auto j=1;j<=ySampNum;j++)
        {
            //取数据的步距
            index +=  int(xInterval/sampPointInterval);
            startRSValueIndexOdd.append(CSS_RSData.at(index));
        }

        lookupTableTemp.append(startRSValueIndexOdd);

        // 偶数列比奇数列少一列
        if(i>= startXIndexEven.size())
        {
            continue;
        }

        // 取偶数列数据
        index = startXIndexEven.at(i);
        QVector<double> arMsrZValidEven;
        arMsrZValidEven.append(CSS_RSData.at(index));
        for(auto j=1;j<=ySampNum;j++)
        {
            index -=  int(xInterval/sampPointInterval);
            arMsrZValidEven.append(CSS_RSData.at(index));
        }

        lookupTableTemp.append(arMsrZValidEven);
    }

    lookupTable = lookupTableTemp;
    //    double realStartYSumOdd = std::accumulate(realStartYOdd.begin(),realStartYOdd.end(),0.0);
    //    double realStartYMeanOdd = realStartYSumOdd/realStartYOdd.size();
    //    double realStartYSumEven = std::accumulate(realStartYEven.begin(),realStartYEven.end(),0.0);
    //    double realStartYMeanEven = realStartYSumEven/realStartYEven.size();
    //    lookupTableStartY = (realStartYMeanOdd+realStartYMeanEven)/2;
}
void DeviceProxy::lookupTable_do_Gaussian()
{
    cv::Mat mat_power(0, lookupTable[0].size(), cv::DataType<double>::type);
    for (int i = 0; i < lookupTable.size(); ++i)
    {
        // Make a temporary cv::Mat row and add to NewSamples _without_ data copy
        cv::Mat Sample(1, lookupTable[0].size(), cv::DataType<double>::type, lookupTable[i].data());
        mat_power.push_back(Sample);
    }
    Mat mat_tmp;
    GaussianBlur(mat_power, mat_tmp, Size(3, 3), 0, 0);


    lookupTable_Gaussian.resize(lookupTable.size());
    for (int c = 0; c < lookupTable_Gaussian.size(); c++){
        lookupTable_Gaussian[c].resize(lookupTable[0].size());
    }

    for (int x = 0; x < mat_tmp.rows; x++)
    {
        for (int y = 0; y < mat_tmp.cols; y++)
        {
            lookupTable_Gaussian[x][y] = mat_tmp.ptr<double>(x)[y];
        }
    }
}
void DeviceProxy::lookupTableHeadEndDataHandl()
{

    RS_SETTINGS->beginGroup("device/SSCS");
    double LowerLimit = RS_SETTINGS->readNumDEntry("/lowerLimit");
    double upperLimit = RS_SETTINGS->readNumDEntry("/upperLimit");
    RS_SETTINGS->endGroup();

    int cols  = lookupTable.at(0).size();
    int rows = lookupTable.size();

    QVector<int> indexOfOutliersHead;
    QVector<int> indexOfOutliersEnd;
    for(auto i=0;i<rows;i++)
    {
        indexOfOutliersHead = QVector<int>();
        indexOfOutliersEnd = QVector<int>();
        //处理行
        for(auto j=0;j<cols;j++)
        {

            if((lookupTable.at(i).at(j)>upperLimit)||(lookupTable.at(i).at(j)<LowerLimit))
            {
                indexOfOutliersHead.append(j);
            }
            else
            {
                if(indexOfOutliersHead.size())
                {
                    for(auto k=0;k<indexOfOutliersHead.size();k++)
                    {
                        lookupTable[i][indexOfOutliersHead.at(k)] = lookupTable.at(i).at(j);
                    }

                    indexOfOutliersHead = QVector<int>();
                }
            }


            if((lookupTable.at(i).at(cols-1-j)>upperLimit)||(lookupTable.at(i).at(cols-1-j)<LowerLimit))
            {
                indexOfOutliersEnd.append(cols-1-j);
            }
            else
            {
                if(indexOfOutliersEnd.size())
                {
                    for(auto k=0;k<indexOfOutliersEnd.size();k++)
                    {
                        lookupTable[i][indexOfOutliersEnd.at(k)] = lookupTable.at(i).at(cols-1-j);
                    }

                    indexOfOutliersEnd = QVector<int>();
                }
            }
        }
    }

    //saveLookupTable();

    indexOfOutliersHead =  QVector<int>();
    indexOfOutliersEnd =  QVector<int>();
    // 处理列

    for(auto j=0;j<cols;j++)
    {
        indexOfOutliersHead = QVector<int>();
        indexOfOutliersEnd = QVector<int>();
        for(auto i=0;i<rows;i++)
        {
            if((lookupTable.at(i).at(j)>upperLimit)||(lookupTable.at(i).at(j)<LowerLimit))
            {
                indexOfOutliersHead.append(i);
            }
            else
            {
                if(indexOfOutliersHead.size())
                {
                    for(auto k=0;k<indexOfOutliersHead.size();k++)
                    {
                        lookupTable[indexOfOutliersHead.at(k)][j] = lookupTable.at(i).at(j);
                    }

                    indexOfOutliersHead = QVector<int>();
                }
            }


            if((lookupTable.at(rows-1-i).at(j)>upperLimit)||(lookupTable.at(rows-1-i).at(j)<LowerLimit))
            {
                indexOfOutliersEnd.append(rows-1-i);
            }
            else
            {
                if(indexOfOutliersEnd.size())
                {
                    for(auto k=0;k<indexOfOutliersEnd.size();k++)
                    {
                        lookupTable[indexOfOutliersEnd.at(k)][j] = lookupTable.at(rows-1-i).at(j);
                    }

                    indexOfOutliersEnd = QVector<int>();
                }
            }
        }
    }
}
double DeviceProxy::DataHandlCheck_lhc(double data[6])
{
    if ((data[3] > data[4]) && (data[4] > data[5]))
    {
        //        if ((data[0] > data[1]) && (data[1] > data[2]))
        //            return data[1];
        //        else
        {
            double tmpK = (data[4] - data[5]) / (data[3] - data[5]);
            data[1] = tmpK*(data[0] - data[2]) + data[2];
            return data[1];
        }
    }
    if ((data[3] < data[4]) && (data[4] < data[5]))
    {
        //        if ((data[0] < data[1]) && (data[1] < data[2]))
        //            return data[1];
        //        else
        {
            double tmpK = (data[4] - data[5]) / (data[3] - data[5]);
            data[1] = tmpK*(data[0] - data[2]) + data[2];
            return data[1];
        }
    }

    return data[1];
}
void DeviceProxy::lookupTableHeadEndDataHandl_lhc2()
{


    int cols  = lookupTable.at(0).size();
    int rows = lookupTable.size();
    QVector<QVector<double>> lookupTableTemp;

    QVector<double> chazhi1(cols);
    QVector<double> chazhi2(cols);

    lookupTableTemp = lookupTable;

    for(auto i=0;i<rows;i++)
    {
        //处理行
        chazhi1[0] = 0;
        for(auto j=1;j<cols;j++)
        {
            chazhi1[j] = lookupTableTemp.at(i).at(j) - lookupTableTemp.at(i).at(j-1);
        }
        chazhi2[0] = 0;
        for(auto j=1;j<cols;j++)
        {
            chazhi2[j] = chazhi1.at(j) - chazhi1.at(j-1);
        }
        double maxdata = 0;
        int num = 0;
        for(auto j=0;j<cols;j++)
        {
            if (fabs(chazhi2.at(j)) > maxdata )
            {
                maxdata = fabs(chazhi2.at(j));
            }
            num = j;
        }
        num = num - 1;
        if (num <= 0) continue;

        double nextK,preK,currentK;

        if (i==0)
        {
            currentK = lookupTableTemp.at(i).at(num) - lookupTableTemp.at(i).at(num-1);
            nextK = lookupTableTemp.at(i+1).at(num) - lookupTableTemp.at(i+1).at(num-1);
            if (fabs(currentK) > 0.0015)
            {
                if (fabs(nextK) < fabs(currentK))
                {
                    lookupTable[i][num] = lookupTableTemp.at(i).at(num-1) + nextK;

                }
            }
        }
        else if (i==(rows-1))
        {
            preK = lookupTableTemp.at(i-1).at(num) - lookupTableTemp.at(i-1).at(num-1);
            currentK = lookupTableTemp.at(i).at(num) - lookupTableTemp.at(i).at(num-1);
            //nextK = lookupTableTemp.at(i+1).at(num) - lookupTableTemp.at(i+1).at(num-1);
            if (fabs(currentK) > 0.0015)
            {
                if (fabs(preK) < fabs(currentK))
                {
                    lookupTable[i][num] = lookupTableTemp.at(i).at(num-1) + preK;

                }
            }

        }
        else
        {
            preK = lookupTableTemp.at(i-1).at(num) - lookupTableTemp.at(i-1).at(num-1);
            currentK = lookupTableTemp.at(i).at(num) - lookupTableTemp.at(i).at(num-1);
            nextK = lookupTableTemp.at(i+1).at(num) - lookupTableTemp.at(i+1).at(num-1);
            if (fabs(currentK) > 0.0015)
            {
                if ((fabs(preK) < fabs(currentK)) && (fabs(nextK) < fabs(currentK)))
                {
                    lookupTable[i][num] = lookupTableTemp.at(i).at(num-1) + (preK + nextK) / 2;

                }
                else if ((fabs(preK) < fabs(currentK)) && (fabs(nextK) >= fabs(currentK)))
                {
                    lookupTable[i][num] = lookupTableTemp.at(i).at(num-1) + preK;
                }
                else if ((fabs(preK) >= fabs(currentK)) && (fabs(nextK) < fabs(currentK)))
                {
                    lookupTable[i][num] = lookupTableTemp.at(i).at(num-1) + nextK;
                }
            }

        }

    }


}
void DeviceProxy::lookupTableHeadEndDataHandl_lhc()
{

    RS_SETTINGS->beginGroup("device/SSCS");
    double LowerLimit = RS_SETTINGS->readNumDEntry("/lowerLimit");
    double upperLimit = RS_SETTINGS->readNumDEntry("/upperLimit");
    double xinterval = RS_SETTINGS->readNumDEntry("/XInterval");
    double yinterval = RS_SETTINGS->readNumDEntry("/YInterval");
    double kxMax = 0.02 / xinterval;
    double kyMax = 0.02 / yinterval;
    RS_SETTINGS->endGroup();

    int cols  = lookupTable.at(0).size();
    int rows = lookupTable.size();
    QVector<QVector<double>> lookupTableTemp;
    double data[6];

    QVector<int> indexOfOutliersHead;
    QVector<int> indexOfOutliersEnd;
    int skipRow = rows / 10;

    //1、检查原始数据，有间隔合格不合格数据，做出标记。xy方向都跳过skipRow边缘行
    //2、分别记录符合条件的x、y行号和列号，
    //3、xy方向数据都处理完成后，根据步骤2所标记的行列号，检查数据
    //
    //
    lookupTableTemp = lookupTable;

    for(auto i=skipRow;i<rows-skipRow;i++)
    {
        indexOfOutliersHead = QVector<int>();
        indexOfOutliersEnd = QVector<int>();
        //处理行
        for(auto j=0;j<cols;j++)
        {

            if((lookupTable.at(i).at(j) > upperLimit) || (lookupTable.at(i).at(j)<LowerLimit))
            {
                indexOfOutliersHead.append(j);
            }
            else
            {
                if(indexOfOutliersHead.size())
                {
                    double tmp;
                    tmp = lookupTable.at(i).at(j);
                    if (j<cols-2)
                        if ((lookupTable.at(i).at(j+1) < upperLimit) && (lookupTable.at(i).at(j+1) > LowerLimit)
                                && (lookupTable.at(i).at(j+2) < upperLimit) && (lookupTable.at(i).at(j+2) > LowerLimit))
                        {
                            //验证当前值是否合理
                            if (j<cols-2)
                            {

                                double k1,k2;
                                k1 = (lookupTable.at(i).at(j) - lookupTable.at(i).at(j+1)) / yinterval;
                                k2 = (lookupTable.at(i).at(j+1)-lookupTable.at(i).at(j+2)) / yinterval;

                                if (fabs(k1-k2) > kyMax)
                                {
                                    lookupTable[i][j] = lookupTable.at(i).at(j+1) + (lookupTable.at(i).at(j+1)-lookupTable.at(i).at(j+2));
                                }
                                double chazhiY,chazhiY2;
                                chazhiY = lookupTable.at(i).at(j) - lookupTable.at(i).at(j+1);
                                chazhiY2 = lookupTable.at(i).at(j+1) - lookupTable.at(i).at(j+2);
                                if (((i > 0) && (i < rows-2)) && ((j < cols-2)&& (j > 0)))
                                    //if (((lookupTableTemp.at(i+1).at(j) < upperLimit) && (lookupTableTemp.at(i+1).at(j) > LowerLimit)))
                                {
                                    double chazhiX;
                                    if (i < rows / 2)
                                        chazhiX = lookupTable.at(i+1).at(j) - lookupTable.at(i+1).at(j+1);
                                    else
                                        chazhiX = lookupTable.at(i-1).at(j)- lookupTable.at(i-1).at(j+1);
                                    if (fabs(chazhiX) <= 0.0005)
                                    {
                                        if (chazhiY > 0.001)
                                            lookupTable[i][j] = lookupTable.at(i).at(j+1);
                                    }
                                    else
                                    {
                                        lookupTable[i][j] = lookupTable.at(i).at(j+1) + (chazhiY2 + chazhiX) / 2;
                                    }
                                }

                            }
                            //计算锭外第一补偿点值

                            if (j<cols-2)
                                tmp = lookupTable.at(i).at(j)+((lookupTable.at(i).at(j)-lookupTable.at(i).at(j+1))+(lookupTable.at(i).at(j+1)-lookupTable.at(i).at(j+2)))/2;
                            else
                                tmp = lookupTable.at(i).at(j);

                            if (((i > 0) && (i < rows-1)) && ((j < cols-2)&& (j > 0)))
                            {
                                if (((lookupTableTemp.at(i-1).at(j)  < upperLimit) && (lookupTableTemp.at(i-1).at(j)  > LowerLimit))
                                        && ((lookupTableTemp.at(i+1).at(j) < upperLimit) && (lookupTableTemp.at(i+1).at(j) > LowerLimit)))
                                {
                                    if (((lookupTableTemp.at(i-1).at(j-1)  < upperLimit) && (lookupTableTemp.at(i-1).at(j-1)  > LowerLimit))
                                            && ((lookupTableTemp.at(i+1).at(j-1) < upperLimit) && (lookupTableTemp.at(i+1).at(j-1) > LowerLimit)))
                                    {

                                        data[0] = lookupTableTemp.at(i-1).at(j-1);
                                        data[1] = tmp;
                                        data[2] = lookupTableTemp.at(i+1).at(j-1);
                                        data[3] = lookupTableTemp.at(i-1).at(j);
                                        data[4] = lookupTableTemp.at(i).at(j);
                                        data[5] = lookupTableTemp.at(i+1).at(j);
                                        tmp = DataHandlCheck_lhc(data);
                                    }
                                }
                            }

                            if (tmp < LowerLimit)
                                tmp = LowerLimit;
                            if (tmp > upperLimit)
                                tmp = upperLimit;
                        }

                    for(auto k=0;k<indexOfOutliersHead.size();k++)
                    {
                        lookupTable[i][indexOfOutliersHead.at(k)] = tmp;
                    }

                    indexOfOutliersHead = QVector<int>();
                }
            }


            if((lookupTable.at(i).at(cols-1-j)>upperLimit)||(lookupTable.at(i).at(cols-1-j)<LowerLimit))
            {
                indexOfOutliersEnd.append(cols-1-j);
            }
            else
            {
                if(indexOfOutliersEnd.size())
                {
                    double tmp;
                    tmp = lookupTable.at(i).at(cols-1-j);
                    if (j<cols-2)
                        if ((lookupTable.at(i).at(cols-1-j-1) < upperLimit) && (lookupTable.at(i).at(cols-1-j-1) > LowerLimit)
                                && (lookupTable.at(i).at(cols-1-j-2) < upperLimit) && (lookupTable.at(i).at(cols-1-j-2) > LowerLimit))
                        {
                            if (j<cols-2)
                            {
                                double k1,k2;
                                k1 = (lookupTable.at(i).at(cols-1-j)-lookupTable.at(i).at(cols-1-j-1)) / yinterval;
                                k2 = (lookupTable.at(i).at(cols-1-j-1)-lookupTable.at(i).at(cols-1-j-2)) / yinterval;
                                if (abs(k1-k2) > kyMax)
                                {
                                    lookupTable[i][cols-1-j] = lookupTable.at(i).at(cols-1-j-1) + (lookupTable.at(i).at(cols-1-j-1)-lookupTable.at(i).at(cols-1-j-2));
                                }
                                double chazhiY,chazhiY2;
                                chazhiY = lookupTable.at(i).at(cols-1-j) - lookupTable.at(i).at(cols-1-j-1);
                                chazhiY2 = lookupTable.at(i).at(cols-1-j-1) - lookupTable.at(i).at(cols-1-j-2);
                                if (((i > 0) && (i < rows-1)) && ((j < cols-2)&& (j > 0)))
                                    //if (((lookupTableTemp.at(i-1).at(cols-1-j) < upperLimit) && (lookupTableTemp.at(i-1).at(cols-1-j) > LowerLimit)))
                                {
                                    double chazhiX;
                                    if (i < rows / 2)
                                        chazhiX = lookupTable.at(i+1).at(cols-1-j) - lookupTable.at(i+1).at(cols-1-j-1);
                                    else
                                        chazhiX =  lookupTable.at(i-1).at(cols-1-j) - lookupTable.at(i-1).at(cols-1-j-1);
                                    if (fabs(chazhiX) <= 0.0005)
                                    {
                                        if (chazhiY > 0.001)
                                            lookupTable[i][cols-1-j] = lookupTable.at(i).at(cols-1-j-1);
                                    }
                                    else
                                    {
                                        lookupTable[i][cols-1-j] = lookupTable.at(i).at(cols-1-j-1) + (chazhiY2 + chazhiX) / 2;
                                    }
                                }



                            }

                            //double tmp;
                            if (j<cols-2)
                                tmp = lookupTable.at(i).at(cols-1-j)+((lookupTable.at(i).at(cols-1-j)-lookupTable.at(i).at(cols-1-j-1))+(lookupTable.at(i).at(cols-1-j-1)-lookupTable.at(i).at(cols-1-j-2)))/2;
                            else
                                tmp = lookupTable.at(i).at(cols-1-j);

                            if (((i > 0) && (i < rows-1)) && ((j < cols-2)&& (j > 0)))
                            {
                                if (((lookupTableTemp.at(i-1).at(cols-1-j)  < upperLimit) && (lookupTableTemp.at(i-1).at(cols-1-j)  > LowerLimit))
                                        && ((lookupTableTemp.at(i+1).at(cols-1-j) < upperLimit) && (lookupTableTemp.at(i+1).at(cols-1-j) > LowerLimit)))
                                {
                                    if (((lookupTableTemp.at(i-1).at(cols-1-j+1)  < upperLimit) && (lookupTableTemp.at(i-1).at(cols-1-j+1)  > LowerLimit))
                                            && ((lookupTableTemp.at(i+1).at(cols-1-j+1) < upperLimit) && (lookupTableTemp.at(i+1).at(cols-1-j+1) > LowerLimit)))
                                    {

                                        data[0] = lookupTableTemp.at(i-1).at(cols-1-j+1);
                                        data[1] = tmp;
                                        data[2] = lookupTableTemp.at(i+1).at(cols-1-j+1);
                                        data[3] = lookupTableTemp.at(i-1).at(cols-1-j);
                                        data[4] = lookupTableTemp.at(i).at(cols-1-j);
                                        data[5] = lookupTableTemp.at(i+1).at(cols-1-j);
                                        tmp = DataHandlCheck_lhc(data);
                                    }
                                }
                            }

                            if (tmp < LowerLimit)
                                tmp = LowerLimit;
                            if (tmp > upperLimit)
                                tmp = upperLimit;
                        }
                    for(auto k=0;k<indexOfOutliersEnd.size();k++)
                    {
                        lookupTable[i][indexOfOutliersEnd.at(k)] = tmp;
                    }

                    indexOfOutliersEnd = QVector<int>();
                }
            }
        }
    }

    //saveLookupTable();

    indexOfOutliersHead =  QVector<int>();
    indexOfOutliersEnd =  QVector<int>();
    // 处理列
    for(auto j=0;j<cols;j++)
    {
        indexOfOutliersHead = QVector<int>();
        indexOfOutliersEnd = QVector<int>();
        for(auto i=0;i<rows;i++)
        {
            if((lookupTable.at(i).at(j)>upperLimit)||(lookupTable.at(i).at(j)<LowerLimit))
            {
                indexOfOutliersHead.append(i);
            }
            else
            {
                if(indexOfOutliersHead.size())
                {
                    for(auto k=0;k<indexOfOutliersHead.size();k++)
                    {
                        lookupTable[indexOfOutliersHead.at(k)][j] = lookupTable.at(i).at(j);
                    }

                    indexOfOutliersHead = QVector<int>();
                }
            }


            if((lookupTable.at(rows-1-i).at(j)>upperLimit)||(lookupTable.at(rows-1-i).at(j)<LowerLimit))
            {
                indexOfOutliersEnd.append(rows-1-i);
            }
            else
            {
                if(indexOfOutliersEnd.size())
                {
                    for(auto k=0;k<indexOfOutliersEnd.size();k++)
                    {
                        lookupTable[indexOfOutliersEnd.at(k)][j] = lookupTable.at(rows-1-i).at(j);
                    }

                    indexOfOutliersEnd = QVector<int>();
                }
            }
        }
    }
}
//    for(auto j=0;j<cols;j++)
//    {
//        indexOfOutliersHead = QVector<int>();
//        indexOfOutliersEnd = QVector<int>();
//        for(auto i=0;i<rows;i++)
//        {
//            if((lookupTable.at(i).at(j)>upperLimit)||(lookupTable.at(i).at(j)<LowerLimit))
//            {
//                indexOfOutliersHead.append(i);
//            }
//            else
//            {
//                if(indexOfOutliersHead.size())
//                {
//                    double tmp;
//                    tmp = lookupTable.at(i).at(j);
//                    if (i<rows-2)
//                    if ((lookupTable.at(i+1).at(j) < upperLimit) && (lookupTable.at(i+1).at(j) > LowerLimit)
//                            && (lookupTable.at(i+2).at(j) < upperLimit) && (lookupTable.at(i+2).at(j) > LowerLimit))
//                    {
//                        if (i<rows-2)
//                        {
//                            double k1,k2;
//                            k1 = (lookupTable.at(i).at(j) - lookupTable.at(i+1).at(j)) / xinterval;
//                            k2 = (lookupTable.at(i+1).at(j)-lookupTable.at(i+2).at(j)) / xinterval;
//                            if (abs(k1-k2) > kxMax)
//                            {
//                                lookupTable[i][j] = lookupTable.at(i+1).at(j) + (lookupTable.at(i+1).at(j)-lookupTable.at(i+2).at(j));
//                            }
//                            double chazhiY,chazhiY2;
//                            chazhiY = lookupTable.at(i).at(j) - lookupTable.at(i+1).at(j);
//                            chazhiY2 = lookupTable.at(i+1).at(j) - lookupTable.at(i+2).at(j);
//                            if (((i > 0) && (i < rows-2)) && ((j < cols-2)&& (j > 0)))
//                            if (((lookupTableTemp.at(i).at(j+1) < upperLimit) && (lookupTableTemp.at(i).at(j+1) > LowerLimit)))
//                            {
//                                double chazhiX ;

//                                if (i < rows / 2)
//                                    chazhiX = lookupTable.at(i+1).at(j) - lookupTable.at(i+1).at(j+1);
//                                else
//                                    chazhiX = lookupTable.at(i-1).at(j) - lookupTable.at(i-1).at(j+1);

//                                if (fabs(chazhiX) <= 0.0005)
//                                {
//                                    if (chazhiY > 0.001)
//                                        lookupTable[i][j] = lookupTable.at(i+1).at(j);
//                                }
//                                else
//                                {
//                                    lookupTable[i][j] = lookupTable.at(i+1).at(j) + (chazhiY2 + chazhiX) / 2;
//                                }
//                            }

//                        }

//                        //double tmp;
//                        if (i<rows-2)
//                            tmp = lookupTable.at(i).at(j)+((lookupTable.at(i).at(j)-lookupTable.at(i+1).at(j))+(lookupTable.at(i+1).at(j)-lookupTable.at(i+2).at(j)))/2;
//                        else
//                            tmp = lookupTable.at(i).at(j);
//                        if (tmp < LowerLimit)
//                            tmp = LowerLimit;
//                        if (tmp > upperLimit)
//                            tmp = upperLimit;
//                    }
//                    for(auto k=0;k<indexOfOutliersHead.size();k++)
//                    {
//                        lookupTable[indexOfOutliersHead.at(k)][j] = tmp;
//                    }

//                    indexOfOutliersHead = QVector<int>();
//                }
//            }


//            if((lookupTable.at(rows-1-i).at(j)>upperLimit)||(lookupTable.at(rows-1-i).at(j)<LowerLimit))
//            {
//                indexOfOutliersEnd.append(rows-1-i);
//            }
//            else
//            {
//                if(indexOfOutliersEnd.size())
//                {
//                    double tmp;
//                    tmp = lookupTable.at(rows-1-i).at(j);
//                    if (i<rows-2)
//                    if ((lookupTable.at(rows-1-i-1).at(j) < upperLimit) && (lookupTable.at(rows-1-i-1).at(j) > LowerLimit)
//                            && (lookupTable.at(rows-1-i-2).at(j) < upperLimit) && (lookupTable.at(rows-1-i-2).at(j) > LowerLimit))
//                    {
//                        if (i<rows-2)
//                        {
//                            double k1,k2;
//                            k1 = (lookupTable.at(rows-1-i).at(j)-lookupTable.at(rows-1-i-1).at(j)) / xinterval;
//                            k2 = (lookupTable.at(rows-1-i-1).at(j)-lookupTable.at(rows-1-i-2).at(j)) / xinterval;
//                            if (abs(k1-k2) > kxMax)
//                            {
//                                lookupTable[rows-1-i][j] = lookupTable.at(rows-1-i-1).at(j) + (lookupTable.at(rows-1-i-1).at(j)-lookupTable.at(rows-1-i-2).at(j));
//                            }

//                            double chazhiY,chazhiY2;
//                            chazhiY = lookupTable.at(rows-1-i).at(j) - lookupTable.at(rows-1-i-1).at(j);
//                            chazhiY2 = lookupTable.at(rows-1-i-1).at(j) - lookupTable.at(rows-1-i-2).at(j);
//                            if (((i > 0) && (i < rows-2)) && ((j < cols-2)&& (j > 0)))
//                            if (((lookupTableTemp.at(rows-1-i).at(j+1) < upperLimit) && (lookupTableTemp.at(rows-1-i).at(j+1) > LowerLimit)))
//                            {
//                                double chazhiX ;//= lookupTable.at(rows-1-i).at(j+1) - lookupTable.at(rows-1-i-1).at(j+1);

//                                if (i < rows / 2)
//                                    chazhiX = lookupTable.at(rows-1-i).at(j+1) - lookupTable.at(rows-1-i-1).at(j+1);
//                                else
//                                    chazhiX = lookupTable.at(rows-1-i).at(j-1) - lookupTable.at(rows-1-i-1).at(j-1);


//                                if (fabs(chazhiX) <= 0.0005)
//                                {
//                                    if (chazhiY > 0.001)
//                                        lookupTable[rows-1-i][j] = lookupTable.at(rows-1-i-1).at(j);
//                                }
//                                else
//                                {
//                                    lookupTable[rows-1-i][j] = lookupTable.at(rows-1-i-1).at(j) + (chazhiY2 + chazhiX) / 2;
//                                    //lookupTable[i][cols-1-j] = lookupTable.at(i).at(cols-1-j-1) + (chazhiY2 + chazhiX) / 2;
//                                }
//                            }

//                        }

//                        double tmp;
//                        if (i<rows-2)
//                            tmp = lookupTable.at(rows-1-i).at(j)+((lookupTable.at(rows-1-i).at(j)-lookupTable.at(rows-1-i-1).at(j))+(lookupTable.at(rows-1-i-1).at(j)-lookupTable.at(rows-1-i-2).at(j)))/2;
//                        else
//                            tmp = lookupTable.at(rows-1-i).at(j);
//                        if (tmp < LowerLimit)
//                            tmp = LowerLimit;
//                        if (tmp > upperLimit)
//                            tmp = upperLimit;
//                    }
//                    for(auto k=0;k<indexOfOutliersEnd.size();k++)
//                    {
//                        lookupTable[indexOfOutliersEnd.at(k)][j] = tmp;
//                    }

//                    indexOfOutliersEnd = QVector<int>();
//                }
//            }
//        }
//    }
//}
void DeviceProxy::saveLookupTable_lhc()
{
    Sleep(100);
    QDateTime datetime = QDateTime::currentDateTime();
    QString timestr = datetime.toString("ddHHmmzzz");

    RS_SETTINGS->beginGroup("device/SSCS");
    QString path = RS_SETTINGS->readEntry("/dataSavePath");
    RS_SETTINGS->endGroup();

    if(path.right(1)!=QString("/"))
    {
        path+=QString("/");
    }
    QFile lookUpTableData(path+"LookupTable_"+timestr+"_test.csv");

    if(lookUpTableData.open(QFile::WriteOnly|QFile::Truncate))
    {
        QTextStream lookUpTableOut(&lookUpTableData);

        int cols = lookupTable.at(0).size();
        int rows = lookupTable.size();

        // y为行

        for(auto i=0;i<rows;i++)
        {
            for(auto j=0;j<cols;j++)
            {
                lookUpTableOut << lookupTable.at(i).at(j)<<",";
            }
            lookUpTableOut << "\n";
        }
        // x为行
        //            for(auto i=0;i<cols;i++)
        //            {
        //                for(auto j=0;j<rows;j++)
        //                {
        //                    lookUpTableOut << lookupTable.at(j).at(i)<<",";
        //                }
        //                lookUpTableOut << "\n";
        //            }
    }
    else
    {
        MyException myExc(QString("保存查找表错误！"));
        throw myExc;
    }
    lookUpTableData.close();
}

void DeviceProxy::saveLookupTable_load()
{
    Sleep(100);
    QDateTime datetime = QDateTime::currentDateTime();
    QString timestr = datetime.toString("ddHHmmzzz");

    RS_SETTINGS->beginGroup("device/SSCS");
    QString path = RS_SETTINGS->readEntry("/dataSavePath");
    RS_SETTINGS->endGroup();

    if(path.right(1)!=QString("/"))
    {
        path+=QString("/");
    }
    QFile lookUpTableData(path+"LookupTable_"+timestr+"_load.csv");

    if(lookUpTableData.open(QFile::WriteOnly|QFile::Truncate))
    {
        QTextStream lookUpTableOut(&lookUpTableData);

        int cols = lookupTable.at(0).size();
        int rows = lookupTable.size();

        // y为行

        for(auto i=0;i<rows;i++)
        {
            for(auto j=0;j<cols;j++)
            {
                lookUpTableOut << lookupTable.at(i).at(j)<<",";
            }
            lookUpTableOut << "\n";
        }
        // x为行
        //            for(auto i=0;i<cols;i++)
        //            {
        //                for(auto j=0;j<rows;j++)
        //                {
        //                    lookUpTableOut << lookupTable.at(j).at(i)<<",";
        //                }
        //                lookUpTableOut << "\n";
        //            }
    }
    else
    {
        MyException myExc(QString("保存查找表错误！"));
        throw myExc;
    }
    lookUpTableData.close();
}

void DeviceProxy::saveLookupTable()
{
    Sleep(100);
    QDateTime datetime = QDateTime::currentDateTime();
    QString timestr = datetime.toString("ddHHmmzzz");

    RS_SETTINGS->beginGroup("device/SSCS");
    QString path = RS_SETTINGS->readEntry("/dataSavePath");
    RS_SETTINGS->endGroup();

    if(path.right(1)!=QString("/"))
    {
        path+=QString("/");
    }
    QFile lookUpTableData(path+"LookupTable_"+timestr+".csv");

    if(lookUpTableData.open(QFile::WriteOnly|QFile::Truncate))
    {
        QTextStream lookUpTableOut(&lookUpTableData);

        int cols = lookupTable.at(0).size();
        int rows = lookupTable.size();

        // y为行

        for(auto i=0;i<rows;i++)
        {
            for(auto j=0;j<cols;j++)
            {
                lookUpTableOut << lookupTable.at(i).at(j)<<",";
            }
            lookUpTableOut << "\n";
        }
        // x为行
        //            for(auto i=0;i<cols;i++)
        //            {
        //                for(auto j=0;j<rows;j++)
        //                {
        //                    lookUpTableOut << lookupTable.at(j).at(i)<<",";
        //                }
        //                lookUpTableOut << "\n";
        //            }
    }
    else
    {
        MyException myExc(QString("保存查找表错误！"));
        throw myExc;
    }
    lookUpTableData.close();
}
void DeviceProxy::SScanDataCheck_lhc()
{
    DEVICE_INFO->printDeviceSystemInfo("补偿面扫描数据校验中...");
    RS_SETTINGS->beginGroup("device/SSCS");
    double LowerLimit = RS_SETTINGS->readNumDEntry("/lowerLimit");
    double upperLimit = RS_SETTINGS->readNumDEntry("/upperLimit");
    RS_SETTINGS->endGroup();

    RS_SETTINGS->beginGroup("device/SSCS");
    double AdjacentPoint = RS_SETTINGS->readNumDEntry("/AdjacentPoint");
    RS_SETTINGS->endGroup();
    if (AdjacentPoint < 0.001)
        AdjacentPoint = 0.001;

    RS_SETTINGS->beginGroup("device/SSCS");
    double AllRange = RS_SETTINGS->readNumDEntry("/AllRange");
    RS_SETTINGS->endGroup();
    if (AllRange < 0.02)
        AllRange = 0.02;

    int cols  = lookupTable.at(0).size();
    int rows = lookupTable.size();

    int vaildValueNum=0;
    double data_max = 0,data_min = 0;
    double DvalueMax = 0;
    for(auto i=0;i<rows;i++)
    {
        for(auto j=0;j<cols;j++)
        {
            if((lookupTable.at(i).at(j)<=upperLimit)&&(lookupTable.at(i).at(j)>=LowerLimit))
            {
                vaildValueNum++;
            }
        }
    }
    for(auto i=0;i<rows;i++)
    {
        for(auto j=0;j<cols;j++)
        {
            if(lookupTable.at(i).at(j) > -1)
            {
                if (lookupTable[i][j] > data_max) data_max = lookupTable[i][j];
                if (lookupTable[i][j] < data_min) data_min = lookupTable[i][j];
            }
        }
    }

    for(auto i=0;i<rows;i++)
    {
        for(auto j=0;j<cols-1;j++)
        {
            if((lookupTable.at(i).at(j) > -1) && (lookupTable.at(i).at(j+1) > -1))
            {
                double DvalueTmp = abs(lookupTable.at(i).at(j+1) - lookupTable.at(i).at(j));
                if (DvalueTmp > DvalueMax) DvalueMax = DvalueTmp;
            }
        }
    }


    if(!vaildValueNum)
    {
        throw MyException(QString("补偿面扫描无有效数据！"));
        DEVICE_INFO->printDeviceSystemInfo("补偿面扫描数据校验失败！");
        return;
    }

    if (DvalueMax > AdjacentPoint)
    {
        throw MyException(QString("加工件平面度不满足加工要求，请检查！"));
        DEVICE_INFO->printDeviceSystemInfo("补偿面扫描数据校验失败(1)！");
        return;
    }

    if ((data_max - data_min) > AllRange)
    {
        throw MyException(QString("加工件平面度不满足加工要求，请检查！"));
        DEVICE_INFO->printDeviceSystemInfo("补偿面扫描数据校验失败(2)！");
        return;
    }



    DEVICE_INFO->printDeviceSystemInfo("补偿面扫描数据校验完成");
}



void DeviceProxy::SScanDataCheck()
{
    DEVICE_INFO->printDeviceSystemInfo("补偿面扫描数据校验中...");
    RS_SETTINGS->beginGroup("device/SSCS");
    double LowerLimit = RS_SETTINGS->readNumDEntry("/lowerLimit");
    double upperLimit = RS_SETTINGS->readNumDEntry("/upperLimit");
    RS_SETTINGS->endGroup();

    int cols  = lookupTable.at(0).size();
    int rows = lookupTable.size();

    int vaildValueNum=0;

    for(auto i=0;i<rows;i++)
    {
        for(auto j=0;j<cols;j++)
        {
            if((lookupTable.at(i).at(j)<=upperLimit)&&(lookupTable.at(i).at(j)>=LowerLimit))
            {
                vaildValueNum++;
            }
        }
    }


    if(!vaildValueNum)
    {
        throw MyException(QString("补偿面扫描无有效数据！"));
        DEVICE_INFO->printDeviceSystemInfo("补偿面扫描有效数据校验失败！");
        return;
    }


    DEVICE_INFO->printDeviceSystemInfo("补偿面扫描有效数据校验完成");
}


void DeviceProxy::lookupPeripheralMakeUpZero()
{
    int cols = lookupTable.at(0).size();
    QVector<double> zero;
    for(auto i=0;i<cols;i++)
    {
        zero.append(0.0);
    }

    lookupTable.append(zero);
    lookupTable.insert(0,zero);

    int rows = lookupTable.size();

    QVector<QVector<double>> lookupTabelTemp;
    for(auto i=0;i<rows;i++)
    {
        QVector<double> temp;
        temp = lookupTable.at(i);
        temp.insert(0,0.0);
        temp.append(0.0);
        lookupTabelTemp.append(temp);
    }
    lookupTable = lookupTabelTemp;
}

void DeviceProxy::downLoadLookupTable()
{
    QVector<double> lookupTableTemp;
    for(auto i=0;i<lookupTable.size();i++)
    {
        lookupTableTemp = lookupTable.at(i);
        double *temp = lookupTableTemp.data();
        char vname[] = "LookupTable";
        acsCtl->setGlobalReal(vname,i,i,0,lookupTable.at(0).size()-1,temp);
    }
}

// 测距传感器回零
void DeviceProxy::RSToZeroInSide()
{
    DEVICE_INFO->printDeviceSystemInfo("测距传感器对零中...");

    acsCtl->stopBuffer(1);
    char vname[]= ACSCTL_RUNF_V;
    acsCtl->setGlobalInt(vname,0);
    RSensorToZero  rSensorToZero;

    RS_SETTINGS->beginGroup("device/ZAAxisSafe");
    double ZAAxisSafePos = RS_SETTINGS->readNumEntry("/pos");
    double ZAAxisToSafePosVel = RS_SETTINGS->readNumEntry("/vel");
    RS_SETTINGS->endGroup();

    rSensorToZero.setZAAxisSafePos(ZAAxisSafePos);
    rSensorToZero.setZAAxisToSafePosVel(ZAAxisToSafePosVel);

    // 加载PTP位置设置
    RS_SETTINGS->beginGroup("device/RSTZVel");
    double Vel1 = RS_SETTINGS->readNumDEntry("/Vel1");
    double Vel2 = RS_SETTINGS->readNumDEntry("/Vel2");
    double Vel3 = RS_SETTINGS->readNumDEntry("/Vel3");
    RS_SETTINGS->endGroup();
    if (Vel1 > 5) Vel1 = 5;
    if (Vel2 > 1) Vel2 = 1;
    if (Vel3 > 1) Vel3 = 1;
    rSensorToZero.setZAAxisToZero1Vel(Vel1);
    rSensorToZero.setZAAxisToZero2Vel(Vel2);
    rSensorToZero.setZAAxisToZero3Vel(Vel3);
    rSensorToZero.CuCeGaoDoNum = CuCeGaoDoNum;
    rSensorToZero.CuCeGaoDiNum = CuCeGaoDINum;

    QByteArray qByCode =  rSensorToZero.getCode().toLatin1();
    char* code = qByCode.data();
    acsCtl->loadBuffer(1,code);
    acsCtl->compileBuffer(1);
    acsCtl->runBuffer(1);
}

void getCoordinate(QVector<QVector<int>> &vec,int *row,int *col)
{

    QList<QString> dataInsert;

    QFile file("./binary_mask.csv"); // 新建QFile对象
    if (!file.open(QFile::ReadOnly | QFile::Text))
    {
        //        QMessageBox::warning(this, tr("打开csv文件"),
        //                             tr("无法读取文件 %1:\n%2.")
        //                             .arg("binary_mask.csv").arg(file.errorString()));
        return ;
    }

    QTextStream in(&file);///文件流in
    int i=0;
    while (!in.atEnd())
    {
        QString line = in.readLine();///一行一行的读取
        //QStringList fields = line.split(",");///逗号分隔123元素

        dataInsert.append(line);
    }

    *row = dataInsert.size();
    QStringList firstR = dataInsert[0].split(",");///逗号分隔123元素
    //QStringList firstR = dataInsert[0];
    *col = firstR.size();

    for(int i = 0;i<dataInsert.size();i++)//一共几行
    {//纵向切点
        int start = 0;
        int end = 0;
        firstR = dataInsert[i].split(",");///逗号分隔123元素
        for(int j = 0;j<firstR.size();j++)//一共几列
        {
            if(start == 0)
            {
                if((int)firstR[j].toFloat() != 0) start = j;
            }
            else
            {
                if(j == firstR.size()-1) end = j;
                if((int)firstR[j].toFloat() == 0) end = j-1;
            }

            if(start!=0 && end!=0 && start!=end)
            {
                //输出点
                //qDebug()<<"zong start:("<<i<<","<<start<<")"<<"end:("<<i<<","<<end<<")";
                QVector<int> v = {i, start, i, end};
                vec.append(v);
                start = 0;
                end = 0;
            }
        }
    }
}

Mat angleRotate(Mat& src, int angle)
{
    //角度转换
    float alpha = angle * CV_PI / 180;
    //构造旋转矩阵
    float rotateMat[3][3] = {
        {cos(alpha),-sin(alpha),0},
        {sin(alpha),cos(alpha),0},
        {0,0,1} };
    int nSrcRows = src.rows;
    int nSrcCols = src.cols;

    //计算旋转后图像矩阵的各个顶点位置
    float a1 = nSrcCols * rotateMat[0][0];
    float b1 = nSrcCols * rotateMat[1][0];
    float a2 = nSrcCols * rotateMat[0][0] + nSrcRows * rotateMat[0][1];
    float b2 = nSrcCols * rotateMat[1][0] + nSrcRows * rotateMat[1][1];
    float a3 = nSrcRows * rotateMat[0][1];
    float b3 = nSrcRows * rotateMat[1][1];
    //计算出极值点
    float kxMin = min(min(min(0.0f, a1), a2), a3);
    float kxMax = max(max(max(0.0f, a1), a2), a3);
    float kyMin = min(min(min(0.0f, b1), b2), b3);
    float kyMax = max(max(max(0.0f, b1), b2), b3);
    //计算输出矩阵的尺寸
    int nRows = abs(kyMax - kyMin);
    int nCols = abs(kxMax - kxMin);
    Mat dst(nRows, nCols, src.type(), Scalar::all(0));
    for (int i = 0; i < nRows; ++i)
    {
        for (int j = 0; j < nCols; ++j)
        {
            //旋转坐标变换
            int x = (j + kxMin) * rotateMat[0][0] - (i + kyMin) * rotateMat[0][1];
            int y = -(j + kxMin) * rotateMat[1][0] + (i + kyMin) * rotateMat[1][1];
            //区域旋转
            if (x >= 0 && x < nSrcCols && y >= 0 && y < nSrcRows)
            {
                dst.at<Vec<uchar, 1>>(i, j) = src.at<Vec<uchar, 1>>(y, x);
            }
        }
    }
    return dst;
}
int GetLineHeadNum(QVector<double>& vec_pos, int line)
{
    double value = vec_pos[0];
    int num = 0;
    int line_num = 1;
    for (int i = 0; i < vec_pos.size(); i++)
    {
        if (line_num <= line)
        {
            if (abs(vec_pos[i] - value) > 0.05)
            {
                line_num++;
                value = vec_pos[i];
            }
            num++;
        }
        else
        {
            return num-1;
        }
    }
    return vec_pos.size();
}
int GetLineTailNum(QVector<double>& vec_pos, int line)
{
    double value = vec_pos[vec_pos.size() - 1];
    int num = vec_pos.size();
    int line_num = 1;
    for (int i = vec_pos.size() -1; i >=0 ; i--)
    {
        if (line_num <= line)
        {
            if (abs(vec_pos[i] - value) > 0.05)
            {
                line_num++;
                value = vec_pos[i];
            }
            num--;
        }
        else
        {
            return num ;
        }
    }
    return 0;
}
void DeviceProxy::MachSmallAreaInSide()
{
    DEVICE_INFO->printDeviceSystemInfo("特定区域加工中...");
    //1、加载文件  pCoordinate
    //2、生成路径坐标
    //3、生成lci程序到buffer3，这里下载数据，开启lci，然后stop
    //4、生成加工代码到buffer8，这里有执行完成标记，并最后关闭lci
    //5、检查buffer8是否完成，置完成标记
    //
    //

    QVector<QVector<int>> vec;
    int row, col;
    RS_SETTINGS->beginGroup("device/Rposition");
    double XiaoVel = RS_SETTINGS->readNumDEntry("/XiaoVel");
    double XiaoInternal = RS_SETTINGS->readNumDEntry("/XiaoInternal");
    double GlobalPix = RS_SETTINGS->readNumDEntry("/GlobalPix");
    double XiaoAccDec = RS_SETTINGS->readNumDEntry("/XiaoAccDec");
    double XiaoOffset = RS_SETTINGS->readNumDEntry("/XiaoOffset");
    double XiaoXpos = RS_SETTINGS->readNumDEntry("/XiaoXAxis");
    double XLeftOffset = RS_SETTINGS->readNumDEntry("/XLeftOffset");
    double XRightOffset = RS_SETTINGS->readNumDEntry("/XRightOffset");
    int YOffset = RS_SETTINGS->readNumDEntry("/YOffset");
    int YOffset_N = RS_SETTINGS->readNumDEntry("/YOffset_N");
    int YTanslate = RS_SETTINGS->readNumDEntry("/YTanslate");
    RS_SETTINGS->endGroup();
    RS_SETTINGS->beginGroup("device/GlobalCameraPos");
    double XAxisPos = RS_SETTINGS->readNumDEntry("/XAxis");
    RS_SETTINGS->endGroup();

    double Xoffset = XAxisPos - XiaoXpos;
    //double Xoffset = 0;
    int offsetPix = abs(Xoffset*GlobalPix);
    //getCoordinate(vec,&row,&col);
    Mat src = cv::imread("binary_mask.jpg", 0);
    Mat dst = Mat::zeros(src.size(), CV_8UC1);

    if (Xoffset < 0)
    {
        Mat roi1 = dst(Rect(dst.cols - offsetPix , 0, offsetPix, dst.rows));
        Mat roi2 = dst(Rect(0 , 0, dst.cols - offsetPix, dst.rows));
        src(Rect(offsetPix , 0, src.cols - offsetPix, src.rows)).copyTo(roi2);
    }
    else
    {
        Mat roi1 = dst(Rect(0 , 0, offsetPix, dst.rows));
        Mat roi2 = dst(Rect(offsetPix , 0, dst.cols - offsetPix, dst.rows));
        src(Rect(0 , 0, src.cols - offsetPix, src.rows)).copyTo(roi2);
    }
    imwrite("result.jpg", dst);
    Mat Rotate_src = angleRotate(dst, 270);
    int maxIndexRow=0,minIndexRow=0;

    row = Rotate_src.rows;
    col = Rotate_src.cols;
    for (int i = 0; i < Rotate_src.rows; i++)    //参数2：Y方向起始值
    {
        bool flag=false;
        for (int j = 0; j < Rotate_src.cols; j++)
        {
            if (Rotate_src.at<unsigned char>(i, j) > 0)
            {
                flag = true;
                minIndexRow = i;
                break;
            }
        }
        if (flag)
            break;
    }
    for (int i = Rotate_src.rows-1; i >= 0; i--)    //参数2：Y方向起始值
    {
        bool flag=false;
        for (int j = 0; j < Rotate_src.cols; j++)
        {
            if (Rotate_src.at<unsigned char>(i, j) > 0)
            {
                flag = true;
                maxIndexRow = i;
                break;
            }
        }
        if (flag)
            break;
    }



    DEVICE_INFO->printDeviceSystemInfo("csv数据提取完成，...");

    RS_SETTINGS->beginGroup("device/MRHCamera/calibPos");
    double MHXAxis = RS_SETTINGS->readNumDEntry("/MHXAxis");
    double MHYAxis = RS_SETTINGS->readNumDEntry("/MHYAxis");
    RS_SETTINGS->endGroup();


    double internalPix = XiaoInternal * GlobalPix;
    int indexS=0;
    int indexE=0;
    int indexSNum=0;
    int indexENum=0;
    if (YOffset > 10)
        YOffset = 10;
    if (YOffset_N > 10)
        YOffset_N = 10;
    if (YTanslate > 10)
        YTanslate = 10;
    if (minIndexRow < row/2)
    {
        for(int i=0;i<(int)row/internalPix;i++)
        {
            if ((row/2 - i*internalPix-XiaoOffset*GlobalPix) <minIndexRow)
            {
                indexS = row/2 -XiaoOffset*GlobalPix - (i-1)*internalPix;
                indexSNum = (i - 1);
                break;
            }
        }
    }
    else
    {
        for(int i=0;i<(int)row/internalPix;i++)
        {
            if ((row/2 + i*internalPix-XiaoOffset*GlobalPix) >minIndexRow)
            {
                indexS = row/2-XiaoOffset*GlobalPix + i*internalPix;
                indexSNum = 0-i;
                break;
            }
        }
    }

    if (maxIndexRow < row/2)
    {
        for(int i=0;i<(int)row/internalPix;i++)
        {
            if ((row/2 - i*internalPix-XiaoOffset*GlobalPix) <maxIndexRow)
            {
                indexE =row/2-XiaoOffset*GlobalPix - i*internalPix;
                indexENum = i;
                break;
            }
        }
    }
    else
    {
        for(int i=0;i<(int)row/internalPix;i++)
        {
            if ((row/2 + i*internalPix-XiaoOffset*GlobalPix) >maxIndexRow)
            {
                indexE =row/2-XiaoOffset*GlobalPix +  (i-1)*internalPix;
                indexENum = 0-(i-1);
                break;
            }
        }
    }

    //    int VecIndexS,VecIndexE;
    //    for (int i=0;i<row;i++)
    //    {
    //        if (vec[i][0] == indexS)
    //        {
    //            VecIndexS = i;
    //            break;
    //        }
    //    }
    //    for (int i=0;i<row;i++)
    //    {
    //        if (vec[i][0] == indexE)
    //        {
    //            VecIndexE = i;
    //            break;
    //        }
    //    }
    QVector<double> vce_x_pos;
    QVector<double> vce_y_pos;
    QVector<int> vce_flag;

    double maxYpos,minYpos;

    minYpos = MHYAxis -XiaoInternal*indexSNum-XiaoOffset;
    maxYpos = MHYAxis -XiaoInternal*indexENum-XiaoOffset;


    //    minYpos = MHYAxis -XiaoInternal*indexSNum-XiaoOffset+(0-YOffset)*XiaoInternal;
    //    maxYpos = MHYAxis -XiaoInternal*indexENum-XiaoOffset-YOffset_N*XiaoInternal;

    //    minYpos = minYpos - YTanslate * XiaoInternal;
    //    maxYpos = maxYpos - YTanslate * XiaoInternal;


    double ystartpos = minYpos;
    int lineNum = 0;
    //原：YOffset < 0     YOffset_N > 0
    //
    //
    //

    for (int i=0;i<=((int)((indexE - indexS)/internalPix));i=i+1)
    {
        int start = 0;
        int end = 0;
        for (int j = 0; j < Rotate_src.cols; j++)
        {
            if(start == 0)
            {
                if (Rotate_src.at<unsigned char>((int)(indexS+i*internalPix), j) > 0)
                    start = j;
            }
            else
            {
                if(j == Rotate_src.cols-1)
                    end = j;
                if(Rotate_src.at<unsigned char>((int)(indexS+i*internalPix), j) == 0)
                    end = j-1;
            }

            if(start!=0 && end!=0 )
            {
                //输出点
                //qDebug()<<"zong start:("<<i<<","<<start<<")"<<"end:("<<i<<","<<end<<")";
                if (((end-start) > GlobalPix/2))
                {
                    QVector<int> v = {start, end};
                    vec.append(v);
                }

                start = 0;
                end = 0;
            }
        }
        if (vec.size() > 0)
        {
            for (int k=0;k<vec.size();k++)
            {
                vce_x_pos.append(MHXAxis +( col/2 - vec[k][0])/GlobalPix-0.15+(0-XLeftOffset));//-0.26
                vce_y_pos.append(ystartpos + lineNum*XiaoInternal);
                vce_flag.append(1);
                vce_x_pos.append(MHXAxis +( col/2 - vec[k][1])/GlobalPix-0.15+(0-XRightOffset));//+0.12
                vce_y_pos.append(ystartpos + lineNum*XiaoInternal);
                vce_flag.append(0);
            }
            for (int k=vec.size()-1;k>=0;k--)
            {
                vce_x_pos.append(MHXAxis +( col/2 - vec[k][1])/GlobalPix-0.15+(0-XRightOffset));//+0.12
                vce_y_pos.append(ystartpos + lineNum*XiaoInternal);
                vce_flag.append(1);
                vce_x_pos.append(MHXAxis +( col/2 - vec[k][0])/GlobalPix-0.15+(0-XLeftOffset));//-0.26
                vce_y_pos.append(ystartpos + lineNum*XiaoInternal);
                vce_flag.append(0);
            }
            lineNum++;
        }


        QVector<QVector<int>>().swap(vec);

    }

    //这处理Y方向缩放、平移
    //    minYpos = MHYAxis -XiaoInternal*indexSNum-XiaoOffset+(0-YOffset)*XiaoInternal;
    //    maxYpos = MHYAxis -XiaoInternal*indexENum-XiaoOffset-YOffset_N*XiaoInternal;
    //平移

    minYpos = minYpos - YTanslate * XiaoInternal;
    maxYpos = maxYpos - YTanslate * XiaoInternal;
    for (int i=0;i<vce_y_pos.size();i++)
    {
        vce_y_pos[i] = vce_y_pos[i] - YTanslate * XiaoInternal;
    }




    QVector<double> tmp_vce_x_pos;
    QVector<double> tmp_vce_y_pos;
    QVector<int> tmp_vce_flag;
    //缩放  //原：YOffset < 0     YOffset_N > 0
    if (YOffset < 0)
    {
        int num =GetLineHeadNum(vce_y_pos,0-YOffset);
        for(int i= num;i<vce_y_pos.size();i++)
        {
            tmp_vce_y_pos.append(vce_y_pos[i]);
            tmp_vce_x_pos.append(vce_x_pos[i]);
            tmp_vce_flag.append(vce_flag[i]);
        }
        QVector<double>().swap(vce_x_pos);
        QVector<double>().swap(vce_y_pos);
        QVector<int>().swap(vce_flag);
        vce_x_pos = tmp_vce_x_pos;
        vce_y_pos = tmp_vce_y_pos;
        vce_flag = tmp_vce_flag;

    }
    if (YOffset > 0)
    {
        int num =GetLineHeadNum(vce_y_pos,1);
        for(int i= 0;i<num;i++)
        {
            tmp_vce_y_pos.append(vce_y_pos[i]);
            tmp_vce_x_pos.append(vce_x_pos[i]);
            tmp_vce_flag.append(vce_flag[i]);
        }
        QVector<double> tmp_vce_x_pos_all;
        QVector<double> tmp_vce_y_pos_all;
        QVector<int> tmp_vce_flag_all;
        for(int i= YOffset;i>0;i--)
        {
            for(int j= 0;j<tmp_vce_y_pos.size();j++)
            {
                tmp_vce_y_pos_all.append(tmp_vce_y_pos[j]-i*XiaoInternal);
                tmp_vce_x_pos_all.append(tmp_vce_x_pos[j]);
                tmp_vce_flag_all.append(tmp_vce_flag[j]);
            }
        }
        for (int i=0;i<vce_y_pos.size();i++)
        {
            tmp_vce_x_pos_all.append(vce_x_pos[i]);
            tmp_vce_y_pos_all.append(vce_y_pos[i]);
            tmp_vce_flag_all.append(vce_flag[i]);
        }

        QVector<double>().swap(vce_x_pos);
        QVector<double>().swap(vce_y_pos);
        QVector<int>().swap(vce_flag);
        vce_x_pos = tmp_vce_x_pos_all;
        vce_y_pos = tmp_vce_y_pos_all;
        vce_flag = tmp_vce_flag_all;
    }
    minYpos = minYpos+(0-YOffset)*XiaoInternal;

    //
    //原：YOffset < 0     YOffset_N > 0
    if (YOffset_N > 0)
    {
        int num =GetLineTailNum(vce_y_pos,YOffset_N);
        for(int i= 0;i<=num;i++)
        {
            tmp_vce_y_pos.append(vce_y_pos[i]);
            tmp_vce_x_pos.append(vce_x_pos[i]);
            tmp_vce_flag.append(vce_flag[i]);
        }
        QVector<double>().swap(vce_x_pos);
        QVector<double>().swap(vce_y_pos);
        QVector<int>().swap(vce_flag);
        vce_x_pos = tmp_vce_x_pos;
        vce_y_pos = tmp_vce_y_pos;
        vce_flag = tmp_vce_flag;

    }
    if (YOffset_N < 0)
    {
        int num =GetLineTailNum(vce_y_pos,1);
        for(int i= num+1;i<vce_y_pos.size();i++)
        {
            tmp_vce_y_pos.append(vce_y_pos[i]);
            tmp_vce_x_pos.append(vce_x_pos[i]);
            tmp_vce_flag.append(vce_flag[i]);
        }
        QVector<double> tmp_vce_x_pos_all;
        QVector<double> tmp_vce_y_pos_all;
        QVector<int> tmp_vce_flag_all;
        for(int i= 1;i<=(0-YOffset_N);i++)
        {
            for(int j= 0;j<tmp_vce_y_pos.size();j++)
            {
                tmp_vce_y_pos_all.append(tmp_vce_y_pos[j]+i*XiaoInternal);
                tmp_vce_x_pos_all.append(tmp_vce_x_pos[j]);
                tmp_vce_flag_all.append(tmp_vce_flag[j]);
            }
        }
        for (int i=0;i<tmp_vce_y_pos_all.size();i++)
        {
            vce_x_pos.append(tmp_vce_x_pos_all[i]);
            vce_y_pos.append(tmp_vce_y_pos_all[i]);
            vce_flag.append(tmp_vce_flag_all[i]);
        }
    }
    maxYpos = maxYpos-YOffset_N*XiaoInternal;








    double maxXpos=0,minXpos=vce_x_pos[0];//,maxYpos,minYpos;
    for (int i=0;i<vce_x_pos.size();i++)
    {
        if (maxXpos < vce_x_pos[i])
            maxXpos = vce_x_pos[i];
        if (minXpos > vce_x_pos[i])
            minXpos = vce_x_pos[i];
    }
    if ((minXpos < MHXAxis - 105) || (maxXpos > MHXAxis + 105))
    {
        throw MyException(QString("特定区域加工数据错误！"));
    }
    maxXpos =  maxXpos + XiaoAccDec;
    minXpos =  minXpos - XiaoAccDec;

    double tmpPos;
    for (int i=0;i<vce_x_pos.size()/2;i++)
    {
        tmpPos = vce_x_pos[i];
        vce_x_pos[i] = vce_x_pos[vce_x_pos.size()-1-i];
        vce_x_pos[vce_x_pos.size()-1-i] = tmpPos;

        tmpPos = vce_y_pos[i];
        vce_y_pos[i] = vce_y_pos[vce_y_pos.size()-1-i];
        vce_y_pos[vce_y_pos.size()-1-i] = tmpPos;
    }
    RS_SETTINGS->beginGroup("device/ABSMove/Safe");
    double CompensationOffset = RS_SETTINGS->readNumDEntry("/CompensationOffset");
    double CompensationMaxValue = RS_SETTINGS->readNumDEntry("/CompensationMaxValue");
    RS_SETTINGS->endGroup();
    double array[4];
    array[0] = minXpos + 10;
    array[1] = maxXpos - 10;
    array[2] = CompensationOffset;
    array[3] = CompensationMaxValue;
    MotionCompOpen(false,array);
    //    minYpos = MHYAxis -( row/2 - vec[(int)(VecIndexS)][0])/GlobalPix;
    //    maxYpos = MHYAxis -( row/2 - vec[(int)(VecIndexE)][0])/GlobalPix;

    //lc.MultiAxWinSize = 0.0005
    acsCtl->stopBuffer(3);
    QString qstrcode;
    qstrcode+=
            QString("global real XCoord(%1), YCoord(%2)\n").arg(vce_x_pos.size()).arg(vce_x_pos.size())+
            QString("global int GatingArr(%1)\n").arg(vce_x_pos.size())+
            QString("int PointsNum = %1\n").arg(vce_x_pos.size())+
            QString("VEL(X)=%1; ACC(X)=5500; DEC(X)=5500; JERK(X)=30000; KDEC(X)=30000;\n").arg(XiaoVel)+
            "VEL(Y)=50; ACC(Y)=3000; DEC(Y)=3000; JERK(Y)=30000; KDEC(Y)=30000;\n"
            "ACC(Z)=1000; DEC(Z)=1000; JERK(Z)=5000; KDEC(Z)=5000;\n"+
            QString("REAL LY=%1,LX=%2,LP=%3\n").arg(maxYpos-minYpos).arg(maxXpos-minXpos).arg(XiaoInternal)+
            QString("PTP/E (X,Y), %1,%2\n").arg(maxXpos).arg(maxYpos)+

            "lc.Init()\n"
            "lc.MultiAxWinSize = 0.005\n"
            "lc.SetSafetyMasks(1,1)\n"
            "lc.SetMotionAxes(X,Y)\n"
            "lc.CoordinateArrGate(PointsNum, GatingArr, XCoord, YCoord)\n"
            "lc.LaserEnable()\n"
            "LOOP LY/LP\n"
            "PTP/ER X,-LX\n"
            //"PTP/ER Y,LP\n"
            "PTP/ER X,LX\n"
            "PTP/ER Y,-LP\n"
            "END\n"
            "runF=1\n"
            "lc.LaserDisable()\n"
            "stop\n";
    QByteArray qByCode = qstrcode.toLatin1();
    char* code = qByCode.data();
    acsCtl->loadBuffer(3,code);
    acsCtl->compileBuffer(3);


    char vnamex[] = "XCoord";
    acsCtl->setGlobalReal(vnamex,0,vce_x_pos.size()-1,vce_x_pos);
    char vnamey[] = "YCoord";
    acsCtl->setGlobalReal(vnamey,0,vce_y_pos.size()-1,vce_y_pos);
    char GatingArr[] = "GatingArr";
    acsCtl->setGlobalInt(GatingArr,0,vce_flag.size()-1,vce_flag);
    acsCtl->runBuffer(3);

}

bool leastSquareLinearFit(float x[], float y[], const int num, float &a, float &b)
{
    float sum_x2 = 0.0;
    float sum_y  = 0.0;
    float sum_x  = 0.0;
    float sum_xy = 0.0;


    try {
        for (int i = 0; i < num; ++i) {
            sum_x2 += x[i]*x[i];
            sum_y  += y[i];
            sum_x  += x[i];
            sum_xy += x[i]*y[i];
        }
    } catch (...) {
        return false;
    }


    a = (num*sum_xy - sum_x*sum_y)/(num*sum_x2 - sum_x*sum_x);
    b = (sum_x2*sum_y - sum_x*sum_xy)/(num*sum_x2-sum_x*sum_x);


    return true;
}
int DeviceProxy::SaveRatioP1P2ToCSV(float ApValue_P1[30],float ApValue_P2[30], float ApPercentage[30],float kb[],bool flag)
{
    QString filename;
    QDateTime datetime = QDateTime::currentDateTime();
    QString timestr = datetime.toString("yyMMdd_HHmmss");
    //QString timestr = datetime.toString("ddHHmmzzz");

    QString path = "PowerCalibration/";


    if(path.right(1)!=QString("/"))
    {
        path+=QString("/");
    }
    //path+
    if (flag)
    {
        filename = path+"QT_"+timestr+".csv";
    }
    else
    {
        filename = path+"QS_"+timestr+".csv";
    }


    QFile filePid(filename);

    if(filePid.open(QFile::WriteOnly|QFile::Append))
    {
        QTextStream filePidOut(&filePid);
        if (flag)
            filePidOut << "PP_T"<<","<<"P1"<<","<<"P2"<< "\n";
        else
            filePidOut << "PP_S"<<","<<"P1"<<","<<"P2"<< "\n";
        for(int i=0;i<21;i++)
        {
            if (!flag)
            {
                if (i>=13)
                    break;
            }
            filePidOut << ApPercentage[i]<<","<<ApValue_P1[i]<<","<<ApValue_P2[i]<< "\n";
        }
        filePidOut <<"\n";
        filePidOut <<"\n";
        filePidOut << "K1"<<","<<kb[0]<< "\n";
        filePidOut << "B1"<<","<<kb[1]<< "\n";
        filePidOut << "K2"<<","<<kb[2]<< "\n";
        filePidOut << "B2"<<","<<kb[3]<< "\n";
    }

    filePid.close();
}
int DeviceProxy::GetRatioP1P2Thread()
{
    StopGetRatioP1P2Flag = false;
    int step = 0;
    bool hasToBuffer = false;
    float k1,b1,k2=0,b2=0;
    QString str[30];
    str[0] = "0";
    str[1] = "5";
    str[2] = "10";
    str[3] = "15";
    str[4] = "20";
    str[5] = "25";
    str[6] = "30";
    str[7] = "35";
    str[8] = "40";
    str[9] = "45";
    str[10] = "50";
    str[11] = "55";
    str[12] = "60";
    str[13] = "65";
    str[14] = "70";
    str[15] = "75";
    str[16] = "80";
    str[17] = "85";
    str[18] = "90";
    str[19] = "95";
    str[20] = "100";
    float ApValue_P1[30] = {0};
    float ApValue_P2[30] = {0};
    float ApPercentage[30] = {0,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80,85,90,95,100};
    devLaserOpenTime = 1800;

    IPGLASER->LaserClose();
    IPGLASER->getIPGLaerPara("IPGLaser");
    if (IPGLASER->m_hComm == nullptr)
    {
        IPGLASER->OpenComm();
    }
    if (DEV->BiaoDingFlag)
    {

        int ret;
        {
            ret = IPGLASER->SetParam(1);
        }
        if (ret != 0)
        {
            DEVICE_INFO->printDeviceSalamInfo("激光器参数设置错误！");
            return -1;
        }
    }
    else
    {
        int ret;
        {
            ret = IPGLASER->SetParam(2);
        }
        if (ret != 0)
        {
            DEVICE_INFO->printDeviceSalamInfo("激光器参数设置错误！");
            return -1;
        }
    }
    while(1)
    {

        /*
         * 1、到测功率位
         * 2、第一套参数测功率
         * 3、第二套参数测功率

*/
        switch(step)
        {
        case 0:
            if (!hasToBuffer)
            {

                DEV->StepNameSGL(2);

                DEV->lastTaskIsFinish = false;
                DEV->toLaserApTestPosInSide();
                DEV->reqCMDRunFState = true;
                hasToBuffer = true;
            }
            else
            {
                //检测buffer是否执行完毕？
                if (!DEV->reqCMDRunFState)//buffer是否执行完毕
                {
                    step = step + 1;
                    hasToBuffer = false;
                    //continue;
                }
            }
            break;
        case 1:
        {
            float valueMath = 0;
            float valueLight = 0;
            int delayCount = 0;
            int ret;
            DEV->StepNameSGL(31);
            ret = IPGLASER->LaserClose();
            if (ret < 0)
            {
                DEV->StepNameSGL(30);
                return -1;
            }
            if (DEV->BiaoDingFlag)
            {
                ret = IPGLASER->SetParam(1);
                if (ret < 0)
                {
                    DEV->StepNameSGL(30);
                    return -1;
                }
            }
            else
            {
                ret = IPGLASER->SetParam(2);
                if (ret < 0)
                {
                    DEV->StepNameSGL(30);
                    return -1;
                }
            }

            ret = IPGLASER->LaserOpen();
            if (ret < 0)
            {
                DEV->StepNameSGL(30);
                return -1;
            }

            DEV->laserOpenInSide();

            for (int i=0; i < 21; i++)
            {

                if (!DEV->BiaoDingFlag)
                {
                    if (i >= 13)
                        break;
                }
                IPGLASER->SetSingleParam("32",str[i]);
                Sleep(50);


                delayCount = 0;
                while(1)
                {
                    Sleep(10);
                    if (DEV->StopGetRatioP1P2Flag)
                    {
                        DEV->laserClose();
                        DEV->StepNameSGL(30);
                        return -1;
                    }
                    delayCount++;
                    if (delayCount >= 1500)
                        break;
                }
                if (POWERMETERMACH->m_hComm == nullptr)
                {
                    POWERMETERMACH->getSerialSet("jiagonggonglvji");
                    bool ret = POWERMETERMACH->OpenComm();
                    if (!ret)
                    {
                        DEV->laserClose();
                        DEV->StepNameSGL(30);
                        return -1;
                    }

                }
                ret = POWERMETERMACH->GetValue(&valueMath);
                if (ret != 0)
                {
                    DEV->laserClose();
                    DEV->StepNameSGL(30);
                    return -1;
                }
                ApValue_P2[i] = valueMath;

                if (POWERMETERLIGHT->m_hComm == nullptr)
                {
                    POWERMETERLIGHT->getSerialSet("guanglugonglvji");
                    bool ret = POWERMETERLIGHT->OpenComm();
                    if (!ret)
                    {
                        DEV->laserClose();
                        DEV->StepNameSGL(30);
                        return -1;
                    }

                }
                valueLight = 0;
                ret = POWERMETERLIGHT->GetValue(&valueLight);
                if (ret != 0)
                {
                    DEV->laserClose();
                    DEV->StepNameSGL(30);
                    return -1;
                }
                ApValue_P1[i] = valueLight;

            }

            ret = IPGLASER->LaserClose();
            if (ret < 0)
            {
                DEV->StepNameSGL(30);
                return -1;
            }

            DEV->laserCloseInSide();
            DEV->laserClose();
            //            leastSquareLinearFit(ApPercentage, ApValue_P1, 21, k1, b1);
            //            leastSquareLinearFit(ApPercentage, ApValue_P2, 21, k2, b2);
            if (DEV->BiaoDingFlag)
                leastSquareLinearFit(ApValue_P1, ApValue_P2, 21, k1, b1);
            else
                leastSquareLinearFit(ApValue_P1, ApValue_P2, 13, k1, b1);
            float kb[4];
            kb[0] = k1;
            kb[1] = b1;
            kb[2] = k2;
            kb[3] = b2;
            if (DEV->BiaoDingFlag)
            {
                RS_SETTINGS->beginGroup("device/Rposition");

                RS_SETTINGS->writeEntry("/p2_t0", ApValue_P2[0]);
                RS_SETTINGS->writeEntry("/p2_t5", ApValue_P2[1]);
                RS_SETTINGS->writeEntry("/p2_t10", ApValue_P2[2]);
                RS_SETTINGS->writeEntry("/p2_t15", ApValue_P2[3]);
                RS_SETTINGS->writeEntry("/p2_t20", ApValue_P2[4]);
                RS_SETTINGS->writeEntry("/p2_t25", ApValue_P2[5]);
                RS_SETTINGS->writeEntry("/p2_t30", ApValue_P2[6]);
                RS_SETTINGS->writeEntry("/p2_t35", ApValue_P2[7]);
                RS_SETTINGS->writeEntry("/p2_t40", ApValue_P2[8]);
                RS_SETTINGS->writeEntry("/p2_t45", ApValue_P2[9]);
                RS_SETTINGS->writeEntry("/p2_t50", ApValue_P2[10]);
                RS_SETTINGS->writeEntry("/p2_t55", ApValue_P2[11]);
                RS_SETTINGS->writeEntry("/p2_t60", ApValue_P2[12]);
                RS_SETTINGS->writeEntry("/p2_t65", ApValue_P2[13]);
                RS_SETTINGS->writeEntry("/p2_t70", ApValue_P2[14]);
                RS_SETTINGS->writeEntry("/p2_t75", ApValue_P2[15]);
                RS_SETTINGS->writeEntry("/p2_t80", ApValue_P2[16]);
                RS_SETTINGS->writeEntry("/p2_t85", ApValue_P2[17]);
                RS_SETTINGS->writeEntry("/p2_t90", ApValue_P2[18]);
                RS_SETTINGS->writeEntry("/p2_t95", ApValue_P2[19]);
                RS_SETTINGS->writeEntry("/p2_t100", ApValue_P2[20]);

                RS_SETTINGS->writeEntry("/p1k_t", k1);
                RS_SETTINGS->writeEntry("/p1b_t", b1);
                RS_SETTINGS->endGroup();
                SaveRatioP1P2ToCSV(ApValue_P1,ApValue_P2, ApPercentage, kb,true);
            }
            else
            {
                RS_SETTINGS->beginGroup("device/Rposition");

                RS_SETTINGS->writeEntry("/p2_s0", ApValue_P2[0]);
                RS_SETTINGS->writeEntry("/p2_s5", ApValue_P2[1]);
                RS_SETTINGS->writeEntry("/p2_s10", ApValue_P2[2]);
                RS_SETTINGS->writeEntry("/p2_s15", ApValue_P2[3]);
                RS_SETTINGS->writeEntry("/p2_s20", ApValue_P2[4]);
                RS_SETTINGS->writeEntry("/p2_s25", ApValue_P2[5]);
                RS_SETTINGS->writeEntry("/p2_s30", ApValue_P2[6]);
                RS_SETTINGS->writeEntry("/p2_s35", ApValue_P2[7]);
                RS_SETTINGS->writeEntry("/p2_s40", ApValue_P2[8]);
                RS_SETTINGS->writeEntry("/p2_s45", ApValue_P2[9]);
                RS_SETTINGS->writeEntry("/p2_s50", ApValue_P2[10]);
                RS_SETTINGS->writeEntry("/p2_s55", ApValue_P2[11]);
                RS_SETTINGS->writeEntry("/p2_s60", ApValue_P2[12]);
                //                RS_SETTINGS->writeEntry("/p2_s65", ApValue_P2[13]);
                //                RS_SETTINGS->writeEntry("/p2_s70", ApValue_P2[14]);
                //                RS_SETTINGS->writeEntry("/p2_s75", ApValue_P2[15]);
                //                RS_SETTINGS->writeEntry("/p2_s80", ApValue_P2[16]);
                //                RS_SETTINGS->writeEntry("/p2_s85", ApValue_P2[17]);
                //                RS_SETTINGS->writeEntry("/p2_s90", ApValue_P2[18]);
                //                RS_SETTINGS->writeEntry("/p2_s95", ApValue_P2[19]);
                //                RS_SETTINGS->writeEntry("/p2_s100", ApValue_P2[20]);
                RS_SETTINGS->writeEntry("/p1k_s", k1);
                RS_SETTINGS->writeEntry("/p1b_s", b1);
                RS_SETTINGS->endGroup();
                SaveRatioP1P2ToCSV(ApValue_P1,ApValue_P2, ApPercentage, kb,false);
            }

            //            if (DEV->BiaoDingFlag)
            //            {
            //                RS_SETTINGS->beginGroup("device/Rposition");
            //                RS_SETTINGS->writeEntry("/p1k_t", k1);
            //                RS_SETTINGS->writeEntry("/p1b_t", b1);
            //                RS_SETTINGS->writeEntry("/p2k_t", k2);
            //                RS_SETTINGS->writeEntry("/p2b_t", b2);
            //                RS_SETTINGS->endGroup();
            //                SaveRatioP1P2ToCSV(ApValue_P1,ApValue_P2, ApPercentage, kb,true);
            //            }
            //            else
            //            {
            //                RS_SETTINGS->beginGroup("device/Rposition");
            //                RS_SETTINGS->writeEntry("/p1k_s", k1);
            //                RS_SETTINGS->writeEntry("/p1b_s", b1);
            //                RS_SETTINGS->writeEntry("/p2k_s", k2);
            //                RS_SETTINGS->writeEntry("/p2b_s", b2);
            //                RS_SETTINGS->endGroup();
            //                SaveRatioP1P2ToCSV(ApValue_P1,ApValue_P2, ApPercentage, kb,false);
            //            }




            //step = step + 1;
        }
            return 0;

        default:
            break;

        }
        if (DEV->StopGetRatioP1P2Flag)
            return -1;
        Sleep(5);
    }
    return 0;
}

void DeviceProxy::imageGet()
{
    //imageR = rms.RMS_Image(60);
}
int DeviceProxy::ElectricResistanceCheckThread()
{
    //1、连接，获取数组  S T E
    //2、到第一点，读取。循环。结束
    //除了xy位置，Z轴位置也是要计算的。增加一个Z0轴偏移，参考Z2偏移
    //测试时，第一次运行，先升Z轴，再升Z0轴，xy到位，Z0落下
    //后续只动XY，不在动z0，直至测完。
    //测完后，升z0轴，完成测试


    //1、连接，空采，根据尺寸获取数组，解析数组
    //2、到第一点，读取。循环。结束。正常结束时，计算数值。是否正常结束都关掉连接
    //除了xy位置，Z轴位置也是要计算的。增加一个Z0轴偏移，参考Z2偏移
    //测试时，第一次运行，先升Z轴，再升Z0轴，xy到位，Z0落下
    //后续只动XY，不在动z0，直至测完。
    //测完后，升z0轴，完成测试


    char* ip;


    StopElectricResistanceCheckFlag = false;
    int step = 0;
    bool hasToBuffer = false;

    QByteArray ba = MODBUSTCP->ipAddr_electric_resistance.toLatin1(); // must    AF_LOCAL
    ip=ba.data();
    bool ret = rms.RMS_Connect("192.168.1.10",QString("10001").toUShort());
    if (!ret)
    {
        return -1;
    }

    QString str;
    RS_SETTINGS->beginGroup("device/Type");
    QString strType = RS_SETTINGS->readEntry("/value");
    RS_SETTINGS->endGroup();
    if (strType == "6寸")
    {
        str = StrPlotSixInch;
    }
    else if (strType == "8寸")
    {
        str = StrPlotEightInch;
    }
    else
    {
        str = StrPlotFourInch;
    }

    //memcpy(MODBUSTCP->array_pos,rev_buf,RevDataLen);

    QStringList list = str.split(")");
    for (int i=0;i<list.count();i++)
    {
        QStringList list_son = list[i].split("(");
        for (int j=0;j<list_son.count();j++)
        {
            if (list_son[j].indexOf(",") >=0)
            {
                QStringList list_son_son = list_son[j].split(",");
                MODBUSTCP->array_pos[i][0] = list_son_son[0].toFloat();
                MODBUSTCP->array_pos[i][1] = list_son_son[1].toFloat();
            }

        }

    }

    ret = rms.RMS_Read_Empty();
    if (!ret)
    {
        return -1;
    }
    devLaserOpenTime = 1800;
    RS_SETTINGS->beginGroup("device/HeightFindPos");
    double XAxisPos = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisPos = RS_SETTINGS->readNumDEntry("/YAxis");
    RS_SETTINGS->endGroup();
    while(1)
    {
        switch(step)
        {
        case 0:
            if (!hasToBuffer)
            {
                toHeightFindPosInSide();
                reqCMDRunFState = true;
                hasToBuffer = true;
            }
            else
            {
                if (!reqCMDRunFState)//buffer是否执行完毕
                {
                    step = step + 1;
                    hasToBuffer = false;
                    //continue;
                }
            }
            break;
        case 1:
            for (int i = 0;i<list.count()-1;i++)
            {

                bool motorstsX,motorstsY;
                acsCtl->ABSToPoint(XAXIS,XAxisPos-MODBUSTCP->array_pos[i][0]);
                acsCtl->ABSToPoint(YAXIS,YAxisPos-MODBUSTCP->array_pos[i][1]);
                Sleep(20);
                while(1)
                {

                    motorstsX = acsCtl->getMotorState(XAXIS);
                    motorstsY = acsCtl->getMotorState(YAXIS);
                    if (motorstsX && motorstsY)
                        break;
                    if (DEV->StopElectricResistanceCheckFlag)
                    {
                        acsCtl->halt(XAXIS);
                        acsCtl->halt(YAXIS);
                        rms.RMS_Disconnect();
                        acsCtl->ABSToPoint(Z0AXIS,0);
                        return -1;
                    }
                    Sleep(1);
                }
                ret = rms.RMS_Read(MODBUSTCP->array_pos[i][0],MODBUSTCP->array_pos[i][1]);
                if (!ret)
                {
                    DEVICE_INFO->printDeviceSystemInfo("接收命令失败，退出晶锭预测量");
                    return -1;
                }

                if (StopElectricResistanceCheckFlag)
                {
                    rms.RMS_Disconnect();
                    acsCtl->ABSToPoint(Z0AXIS,0);
                    return -1;
                }

            }
            step = step + 1;
            break;
        case 2:
            double max,min,med,mode;
            rms.RMS_ACQ(&max,&min,&med,&mode);
            DEV->mode = mode;
            rms.RMS_P(mode,&R_detection_pt,&R_detection_ps,R_detection_pm,R_detection_po);
            R_detection_pt = R_detection_pt * IPGLASER->PulseRepetition1.toDouble()/1000.0;
            R_detection_ps = R_detection_ps * IPGLASER->PulseRepetition2.toDouble()/1000.0;

            if (strType == "6寸")
            {
                imageR = rms.RMS_Image(60);
            }
            else if (strType == "8寸")
            {
                imageR = rms.RMS_Image(80);
            }
            else
                imageR = rms.RMS_Image(40);


            DEV->emit show_Q_PP_SGL();
            rms.RMS_Disconnect();
            acsCtl->ABSToPoint(Z0AXIS,0);
            return 0;

        }
        if (DEV->StopElectricResistanceCheckFlag)
        {
            rms.RMS_Disconnect();
            acsCtl->ABSToPoint(Z0AXIS,0);
            return -1;
        }
        Sleep(5);
    }
}

int DeviceProxy::FindEdgeThread()
{
    bool motorsts = false;
    Mat image;
    int ret;
    bool findedgeflag;
    double Slope;
    double step = 0;
    double step_count = 0;
    StopFindEdgeFlag = false;
    int  lineFlag = 0;
    acsCtl->setVEL(DAXIS, 40);
    acsCtl->setACC(DAXIS,400);
    acsCtl->setDEC(DAXIS,400);
    acsCtl->setJERK(DAXIS, 4000);
    acsCtl->setKDEC(DAXIS,4000);
    RS_SETTINGS->beginGroup("device/Rposition");
    double PixelSize = RS_SETTINGS->readNumDEntry("/PixelSize");
    RS_SETTINGS->endGroup();
    double point_xyz[3][2] = {0};
    while(1)
    {
        try
        {
            while(1)
            {
                //acsCtl->ABSToPoint(DAXIS,step);
                motorsts = acsCtl->getMotorState(DAXIS);
                if (motorsts)
                    break;
                if (StopFindEdgeFlag)
                {
                    acsCtl->halt(DAXIS);
                    return -1;
                }
                Sleep(1);
            }
            //lightSourceOpen();
            LIGHTSOURCEFIND->LightOn(1);
            Sleep(20);
            //ret = CAMERAFIND->GetImage(image,true);
            ret = CAMERAFIND->GetImage(image,true);
            if (ret < 0)
            {
                throw MyException(QString("寻边获取照片失败"));
            }
            LIGHTSOURCEFIND->LightOff(1);
            //lightSourceClose();

            CAMERAFIND->GetLineSlope(image,findedgeflag,&Slope);
            if (!findedgeflag)
            {
                step = CAMERAFIND->StepOfFalse;
                step_count += step;
                qDebug()<< "findedgeflag:"<<findedgeflag;
                lineFlag = 0;
            }
            else
            {

                if ((Slope >= -0.01) && (Slope <= 0.01))//找到直线
                {
                    qDebug()<< "Slope:"<<Slope;
                    if (lineFlag > 1)
                    {


                        acsCtl->RToPointPos(DAXIS,90);//转到工作位
                        Sleep(10);
                        while(1)
                        {
                            motorsts = acsCtl->getMotorState(DAXIS);
                            if (motorsts)
                                break;
                            if (StopFindEdgeFlag)
                            {
                                acsCtl->halt(DAXIS);
                                return -1;
                            }
                            Sleep(1);
                        }
                        qDebug()<< "get img start";
                        LIGHTSOURCEFIND->LightOn(1);
                        Sleep(20);
                        //ret = CAMERAFIND->GetImage(image,true);
                        ret = CAMERAFIND->GetImage(image,true);
                        if (ret < 0)
                        {
                            throw MyException(QString("寻边获取照片失败"));
                        }
                        LIGHTSOURCEFIND->LightOff(1);

                        CAMERAFIND->GetLineSlope(image,findedgeflag,&Slope);
                        qDebug()<< "get img end";
                        if (!findedgeflag)
                        {
                            acsCtl->RToPointPos(DAXIS,-90);//转到工作位
                            Sleep(10);
                            while(1)
                            {
                                motorsts = acsCtl->getMotorState(DAXIS);
                                if (motorsts)
                                    break;
                                if (StopFindEdgeFlag)
                                {
                                    acsCtl->halt(DAXIS);
                                    return -1;
                                }
                                Sleep(1);
                            }
                            qDebug()<< "false ";
                        }
                        qDebug()<< "lihongchang ";


                        //                        {
                        //                            acsCtl->RToPointPos(XAXIS,10);//转到工作位
                        //                            Sleep(10);
                        //                            while(1)
                        //                            {
                        //                                motorsts = acsCtl->getMotorState(XAXIS);
                        //                                if (motorsts)
                        //                                    break;
                        //                                if (StopFindEdgeFlag)
                        //                                {
                        //                                    acsCtl->halt(XAXIS);
                        //                                    return -1;
                        //                                }
                        //                                Sleep(1);
                        //                            }
                        //                            LIGHTSOURCEFIND->LightOn(1);
                        //                            Sleep(20);
                        //                            ret = CAMERAFIND->GetImage(image,true);
                        //                            if (ret < 0)
                        //                            {
                        //                                throw MyException(QString("寻边获取照片失败"));
                        //                            }
                        //                            LIGHTSOURCEFIND->LightOff(1);

                        //                            int top_left;
                        //                            int left = CAMERAFIND->GetCrossPoint(image,true,&top_left);
                        //                            if (left == -1)
                        //                            {
                        //                                LaserMarkOffset_Y = 0;
                        //                                LaserMarkOffset_X = 0;
                        //                            }
                        //                            else
                        //                            {
                        //                                point_xyz[0][0] = DEV->XAxisCtPos - (image.cols/2 - left)/PixelSize;
                        //                                point_xyz[0][1] = DEV->YAxisCtPos + (top_left - image.rows/2)/PixelSize;
                        //                                acsCtl->RToPointPos(XAXIS,-20);//转到工作位
                        //                                point_xyz[0][0] = point_xyz[0][0] - 20;
                        //                                Sleep(10);
                        //                                while(1)
                        //                                {
                        //                                    motorsts = acsCtl->getMotorState(XAXIS);
                        //                                    if (motorsts)
                        //                                        break;
                        //                                    if (StopFindEdgeFlag)
                        //                                    {
                        //                                        acsCtl->halt(XAXIS);
                        //                                        return -1;
                        //                                    }
                        //                                    Sleep(1);
                        //                                }
                        //                                LIGHTSOURCEFIND->LightOn(1);
                        //                                Sleep(20);
                        //                                ret = CAMERAFIND->GetImage(image,true);
                        //                                if (ret < 0)
                        //                                {
                        //                                    throw MyException(QString("寻边获取照片失败"));
                        //                                }
                        //                                LIGHTSOURCEFIND->LightOff(1);

                        //                                int top_right;
                        //                                int right = CAMERAFIND->GetCrossPoint(image,false,&top_right);

                        //                                if (right == -1)
                        //                                {
                        //                                    LaserMarkOffset_Y = 0;
                        //                                    LaserMarkOffset_X = 0;
                        //                                }
                        //                                else
                        //                                {
                        //                                    point_xyz[1][0] = DEV->XAxisCtPos + (right - image.cols/2)/PixelSize;
                        //                                    point_xyz[1][1] = DEV->YAxisCtPos + (top_right - image.rows/2)/PixelSize;

                        //                                    LaserMarkOffset_Y = (right - left) / 2.0 / PixelSize;
                        //                                    LaserMarkOffset_X = ((top_right + top_left) / 2.0 - 685)/ PixelSize;

                        //                                    {
                        //                                        //移动到中心点，移动到下端，平移xy值，判断边缘最下点（x，y），记录xy
                        //                                        RS_SETTINGS->beginGroup("device/Type");
                        //                                        QString strType = RS_SETTINGS->readEntry("/value");
                        //                                        RS_SETTINGS->endGroup();
                        //                                        int Yoffset;
                        //                                        if (strType == "6寸")
                        //                                        {
                        //                                            Yoffset = INCHES6;
                        //                                        }
                        //                                        else if (strType == "8寸")
                        //                                        {
                        //                                            Yoffset = INCHES8;
                        //                                        }
                        //                                        else
                        //                                        {
                        //                                            Yoffset = INCHES4;
                        //                                        }
                        //                                        point_xyz[0][0] = point_xyz[0][0] + DEV->XAxisCtPos - (point_xyz[1][0]+point_xyz[0][0])/2;
                        //                                        point_xyz[1][0] = point_xyz[1][0] + DEV->XAxisCtPos - (point_xyz[1][0]+point_xyz[0][0])/2;
                        //                                        acsCtl->RToPointPos(XAXIS,DEV->XAxisCtPos - (point_xyz[1][0]+point_xyz[0][0])/2);
                        //                                        point_xyz[0][1] = point_xyz[0][1] + Yoffset;
                        //                                        point_xyz[1][1] = point_xyz[1][1] + Yoffset;
                        //                                        acsCtl->RToPointPos(YAXIS,Yoffset);//移动多少，由4寸，六寸决定。
                        //                                        bool motorsts_x = false;
                        //                                        bool motorsts_y = false;

                        //                                        Sleep(10);
                        //                                        while(1)
                        //                                        {
                        //                                            motorsts_x = acsCtl->getMotorState(XAXIS);
                        //                                            motorsts_y = acsCtl->getMotorState(XAXIS);
                        //                                            if (motorsts_y && motorsts_x)
                        //                                                break;
                        //                                            if (StopFindEdgeFlag)
                        //                                            {
                        //                                                acsCtl->halt(XAXIS);
                        //                                                acsCtl->halt(YAXIS);
                        //                                                return -1;
                        //                                            }
                        //                                            Sleep(1);
                        //                                        }
                        //                                        LIGHTSOURCEFIND->LightOn(1);
                        //                                        Sleep(20);
                        //                                        ret = CAMERAFIND->GetImage(image,true);
                        //                                        if (ret < 0)
                        //                                        {
                        //                                            throw MyException(QString("寻边获取照片失败"));
                        //                                        }
                        //                                        LIGHTSOURCEFIND->LightOff(1);
                        //                                        int edgepos = CAMERAFIND->getLinePoints_bottom(image);
                        //                                        point_xyz[2][0] = DEV->XAxisCtPos;
                        //                                        point_xyz[2][1] = DEV->YAxisCtPos - (edgepos - image.rows/2)/PixelSize;
                        //                                        //获取最低边缘点值
                        //                                        //三点确定圆心
                        //                                        double point_buf1[3], point_buf2[3], point_buf3[3],center[3], radius;
                        //                                        point_buf1[0] = point_xyz[0][0];
                        //                                        point_buf1[1] = point_xyz[0][1];
                        //                                        point_buf1[2] = 0;
                        //                                        point_buf2[0] = point_xyz[1][0];
                        //                                        point_buf2[1] = point_xyz[1][1];
                        //                                        point_buf2[2] = 0;
                        //                                        point_buf3[0] = point_xyz[2][0];
                        //                                        point_buf3[1] = point_xyz[2][1];
                        //                                        point_buf3[2] = 0;
                        //                                        CAMERAFIND->calc_arc_bypoints3(point_buf1, point_buf2, point_buf3, center, &radius);
                        //                                        //calc_arc_bypoints3(float* points0, float* points1, float* points2, float* center, float* radius)
                        //                                        DEVICE_INFO->printDeviceSystemInfo(QString("当前位置为：%1mm,%1mm").arg(DEV->XAxisCtPos).arg(DEV->YAxisCtPos));
                        //                                        DEVICE_INFO->printDeviceSystemInfo(QString("碇中心位置为：%1mm,%1mm").arg(center[0]).arg(center[1]));
                        //                                    }
                        //                                }


                        //                            }




                        //                        }

                        reqCMDRunFState = false;
                        lastTaskIsFinish= true;

                        return 0;
                    }
                    else
                    {
                        step = CAMERAFIND->StepOfFalse;
                        step_count += step;
                    }

                }
                else
                {
                    lineFlag++;
                    qDebug()<< "Slope:"<<Slope;
                    if (abs(Slope) > 0.05)
                        step = 1;
                    else
                        step = 0.3;
                    if (Slope < 0)
                        step = 0 - step;
                    step_count += step;
                }
            }
            if (step_count > 360)//10000 是DD马达走一圈的距离.该距离未定
            {
                return -1;
            }
            else
            {
                acsCtl->RToPointPos(DAXIS,step);
                Sleep(5);
            }
            if (StopFindEdgeFlag)
            {
                acsCtl->halt(DAXIS);
                return -1;
            }


        }
        catch (MyException mye)
        {
            exceptHandl_thread(MyException("寻边定位失败。",mye.getExceptCode()));//这里有问题，暂时没改。多线程中，不显示弹窗
            return -1;
        }


    }
}


int DeviceProxy::FindEdgeThread_6()
{
    bool motorsts = false;
    double step = 0;
    double DAxisCtPos = 0;
    double DAxisStartPos = 0;
    StopFindEdgeFlag = false;
    bool flag[2] = {false};
    double ddPos[2] = {0};
    double YAxisCtPos = 0;

    LaserMarkOffset_Y = 0;
    LaserMarkOffset_X = 0;
    acsCtl->setVEL(DAXIS, 30);
    acsCtl->setACC(DAXIS,100);
    acsCtl->setDEC(DAXIS,100);
    acsCtl->setJERK(DAXIS, 1000);
    acsCtl->setKDEC(DAXIS,1000);
    acsCtl->setVEL(YAXIS, 5);
    char vName[] = ACSCTL_RSVALUE_V;
    double value = acsCtl->getGlobalReal(vName);
    int count_find_edge = 0;

    RS_SETTINGS->beginGroup("device/Rposition");
    double FindEdageOffset = RS_SETTINGS->readNumDEntry("/FindEdageOffset");
    RS_SETTINGS->endGroup();

    if (value < -10)
    {
        acsCtl->RToPointPos(DAXIS,-10);
        Sleep(5);
        while(1)
        {
            motorsts = acsCtl->getMotorState(DAXIS);
            if (motorsts)
                break;
            if (StopFindEdgeFlag)
            {
                acsCtl->halt(DAXIS);
                acsCtl->setVEL(DAXIS, 30);
                acsCtl->setACC(DAXIS,300);
                acsCtl->setDEC(DAXIS,300);
                acsCtl->setJERK(DAXIS, 3000);
                acsCtl->setKDEC(DAXIS,3000);
                return -1;
            }
            Sleep(1);
        }
    }
    DAxisStartPos = acsCtl->getFPOS(DAXIS);
    acsCtl->RToPointPos(DAXIS,360);

    count_find_edge = 1;
    while(1)
    {
        try
        {
            DAxisCtPos = acsCtl->getFPOS(DAXIS);
            value = acsCtl->getGlobalReal(vName);

            if (!flag[0])
            {
                if (value < -0.4)
                {
                    flag[0] = true;
                    ddPos[0] = DAxisCtPos;
                }
            }
            else
            {
                if (value > -0.4)
                {
                    flag[1] = true;
                    ddPos[1] = DAxisCtPos;


                    if ((ddPos[1] - ddPos[0]) > 50)
                    {
                        if (count_find_edge < 7)
                        {
                            flag[0] = false;
                            flag[1] = false;
                            continue;
                        }
                        acsCtl->halt(DAXIS);
                        reqCMDRunFState = false;
                        lastTaskIsFinish= true;
                        acsCtl->setVEL(DAXIS, 30);
                        acsCtl->setACC(DAXIS,300);
                        acsCtl->setDEC(DAXIS,300);
                        acsCtl->setJERK(DAXIS, 3000);
                        acsCtl->setKDEC(DAXIS,3000);
                        return -1;
                    }
                    if ((ddPos[1] - ddPos[0]) < 1)
                    {
                        if (count_find_edge < 7)
                        {
                            flag[0] = false;
                            flag[1] = false;
                            continue;
                        }
                        acsCtl->halt(DAXIS);
                        reqCMDRunFState = false;
                        lastTaskIsFinish= true;
                        acsCtl->setVEL(DAXIS, 30);
                        acsCtl->setACC(DAXIS,300);
                        acsCtl->setDEC(DAXIS,300);
                        acsCtl->setJERK(DAXIS, 3000);
                        acsCtl->setKDEC(DAXIS,3000);
                        return -1;
                    }
                    acsCtl->halt(DAXIS);
                    acsCtl->ABSToPoint(DAXIS,(ddPos[0]+ddPos[1])/2);
                    Sleep(5);
                    while(1)
                    {
                        motorsts = acsCtl->getMotorState(DAXIS);
                        if (motorsts)
                            break;
                        if (StopFindEdgeFlag)
                        {
                            acsCtl->halt(DAXIS);
                            acsCtl->setVEL(DAXIS, 30);
                            acsCtl->setACC(DAXIS,300);
                            acsCtl->setDEC(DAXIS,300);
                            acsCtl->setJERK(DAXIS, 3000);
                            acsCtl->setKDEC(DAXIS,3000);
                            return -1;
                        }
                        Sleep(1);
                    }

                    acsCtl->RToPointPos(YAXIS,0.2);
                    Sleep(5);
                    while(1)
                    {
                        motorsts = acsCtl->getMotorState(YAXIS);
                        if (motorsts)
                            break;
                        if (StopFindEdgeFlag)
                        {
                            acsCtl->halt(DAXIS);
                            acsCtl->setVEL(DAXIS, 30);
                            acsCtl->setACC(DAXIS,300);
                            acsCtl->setDEC(DAXIS,300);
                            acsCtl->setJERK(DAXIS, 3000);
                            acsCtl->setKDEC(DAXIS,3000);
                            return -1;
                        }
                        Sleep(1);
                    }
                    value = acsCtl->getGlobalReal(vName);
                    if (value < -0.4)
                    {
                        LaserMarkOffset_Y = 0;
                        LaserMarkOffset_X = 0;
                        {
                            reqCMDRunFState = false;
                            lastTaskIsFinish= true;
                            acsCtl->setVEL(DAXIS, 30);
                            acsCtl->setACC(DAXIS,300);
                            acsCtl->setDEC(DAXIS,300);
                            acsCtl->setJERK(DAXIS, 3000);
                            acsCtl->setKDEC(DAXIS,3000);
                            acsCtl->RToPointPos(DAXIS,180+FindEdageOffset);
                            Sleep(20);
                            while(1)
                            {
                                motorsts = acsCtl->getMotorState(DAXIS);
                                if (motorsts)
                                {
                                    DAxisCtPos = acsCtl->getFPOS(DAXIS);
                                    int dCtPos = (int)DAxisCtPos;
                                    int tmppos = dCtPos % 360;
                                    double setPos = tmppos + (DAxisCtPos - dCtPos);
                                    //ACSC_SYNCHRONOUS
                                    acsCtl->SetFPOS(DAXIS,setPos);
                                    break;
                                }
                                if (StopFindEdgeFlag)
                                {
                                    acsCtl->halt(DAXIS);
                                    acsCtl->setVEL(DAXIS, 30);
                                    acsCtl->setACC(DAXIS,300);
                                    acsCtl->setDEC(DAXIS,300);
                                    acsCtl->setJERK(DAXIS, 3000);
                                    acsCtl->setKDEC(DAXIS,3000);
                                    return -1;
                                }
                            }

                            return 0;
                        }
                    }
                    else
                    {
                        acsCtl->RToPointPos(YAXIS,-0.2);
                        DAxisCtPos = acsCtl->getFPOS(DAXIS);
                        double tmp = 360 - (DAxisCtPos - DAxisStartPos);
                        acsCtl->RToPointPos(DAXIS,tmp);
                        Sleep(5);
                    }


                }
            }
            if (StopFindEdgeFlag)
            {
                acsCtl->halt(DAXIS);
                acsCtl->setVEL(DAXIS, 30);
                acsCtl->setACC(DAXIS,300);
                acsCtl->setDEC(DAXIS,300);
                acsCtl->setJERK(DAXIS, 3000);
                acsCtl->setKDEC(DAXIS,3000);
                return -1;
            }
            motorsts = acsCtl->getMotorState(DAXIS);
            if (motorsts)
            {
                count_find_edge++;
                if (count_find_edge > 7)
                {
                    acsCtl->halt(DAXIS);
                    acsCtl->setVEL(DAXIS, 30);
                    acsCtl->setACC(DAXIS,300);
                    acsCtl->setDEC(DAXIS,300);
                    acsCtl->setJERK(DAXIS, 3000);
                    acsCtl->setKDEC(DAXIS,3000);
                    return -1;
                }
                acsCtl->RToPointPos(DAXIS,360);
                DAxisStartPos = acsCtl->getFPOS(DAXIS);
                if (count_find_edge == 2)
                {
                    acsCtl->RToPointPos(YAXIS,-0.3);
                }
                else if (count_find_edge == 3)
                {
                    acsCtl->RToPointPos(YAXIS,-0.3);
                }
                else if (count_find_edge == 4)
                {
                    acsCtl->RToPointPos(YAXIS,-0.3);
                }
                else if (count_find_edge == 5)
                {
                    acsCtl->RToPointPos(YAXIS,1.2);
                }
                else if (count_find_edge == 6)
                {
                    acsCtl->RToPointPos(YAXIS,0.3);
                }
                else if (count_find_edge == 7)
                {
                    acsCtl->RToPointPos(YAXIS,0.3);
                }

            }

        }
        catch (MyException mye)
        {
            exceptHandl_thread(MyException("寻边定位失败。",mye.getExceptCode()));//这里有问题，暂时没改。多线程中，不显示弹窗
            acsCtl->setVEL(DAXIS, 30);
            acsCtl->setACC(DAXIS,300);
            acsCtl->setDEC(DAXIS,300);
            acsCtl->setJERK(DAXIS, 3000);
            acsCtl->setKDEC(DAXIS,3000);
            return -1;
        }

        Sleep(1);
    }
}



//int DeviceProxy::FindEdgeThread_6()

//{
//    bool motorsts = false;
//    double step = 0;
//    double DAxisCtPos = 0;
//    double DAxisStartPos = 0;
//    StopFindEdgeFlag = false;
//    bool flag[2] = {false};
//    double ddPos[2] = {0};
//    double YAxisCtPos = 0;

//    LaserMarkOffset_Y = 0;
//    LaserMarkOffset_X = 0;
//    acsCtl->setVEL(DAXIS, 30);
//    acsCtl->setACC(DAXIS,100);
//    acsCtl->setDEC(DAXIS,100);
//    acsCtl->setJERK(DAXIS, 1000);
//    acsCtl->setKDEC(DAXIS,1000);
//    acsCtl->setVEL(YAXIS, 5);
//    char vName[] = ACSCTL_RSVALUE_V;
//    double value = acsCtl->getGlobalReal(vName);
//    int count_find_edge = 0;

//    if (value < -10)
//    {
//        acsCtl->RToPointPos(DAXIS,-10);
//        Sleep(5);
//        while(1)
//        {
//            motorsts = acsCtl->getMotorState(DAXIS);
//            if (motorsts)
//                break;
//            if (StopFindEdgeFlag)
//            {
//                acsCtl->halt(DAXIS);
//                acsCtl->setVEL(DAXIS, 30);
//                acsCtl->setACC(DAXIS,300);
//                acsCtl->setDEC(DAXIS,300);
//                acsCtl->setJERK(DAXIS, 3000);
//                acsCtl->setKDEC(DAXIS,3000);
//                return -1;
//            }
//            Sleep(1);
//        }
//    }
//    DAxisStartPos = acsCtl->getFPOS(DAXIS);
//    acsCtl->RToPointPos(DAXIS,360);

//    count_find_edge = 1;
//    while(1)
//    {
//        try
//        {
//            DAxisCtPos = acsCtl->getFPOS(DAXIS);
//            value = acsCtl->getGlobalReal(vName);

//            if (!flag[0])
//            {
//                if (value < -0.4)
//                {
//                    flag[0] = true;
//                    ddPos[0] = DAxisCtPos;
//                }
//            }
//            else
//            {
//                if (value > -0.4)
//                {
//                    flag[1] = true;
//                    ddPos[1] = DAxisCtPos;


//                    if ((ddPos[1] - ddPos[0]) > 3)
//                    {
//                        if (count_find_edge < 7)
//                        {
//                            flag[0] = false;
//                            flag[1] = false;
//                            continue;
//                        }
//                        acsCtl->halt(DAXIS);
//                        reqCMDRunFState = false;
//                        lastTaskIsFinish= true;
//                        acsCtl->setVEL(DAXIS, 30);
//                        acsCtl->setACC(DAXIS,300);
//                        acsCtl->setDEC(DAXIS,300);
//                        acsCtl->setJERK(DAXIS, 3000);
//                        acsCtl->setKDEC(DAXIS,3000);
//                        return -1;
//                    }
//                    if ((ddPos[1] - ddPos[0]) < 1)
//                    {
//                        if (count_find_edge < 7)
//                        {
//                            flag[0] = false;
//                            flag[1] = false;
//                            continue;
//                        }
//                        acsCtl->halt(DAXIS);
//                        reqCMDRunFState = false;
//                        lastTaskIsFinish= true;
//                        acsCtl->setVEL(DAXIS, 30);
//                        acsCtl->setACC(DAXIS,300);
//                        acsCtl->setDEC(DAXIS,300);
//                        acsCtl->setJERK(DAXIS, 3000);
//                        acsCtl->setKDEC(DAXIS,3000);
//                        return -1;
//                    }
//                    acsCtl->halt(DAXIS);
//                    acsCtl->ABSToPoint(DAXIS,(ddPos[0]+ddPos[1])/2);
//                    Sleep(5);
//                    while(1)
//                    {
//                        motorsts = acsCtl->getMotorState(DAXIS);
//                        if (motorsts)
//                            break;
//                        if (StopFindEdgeFlag)
//                        {
//                            acsCtl->halt(DAXIS);
//                            acsCtl->setVEL(DAXIS, 30);
//                            acsCtl->setACC(DAXIS,300);
//                            acsCtl->setDEC(DAXIS,300);
//                            acsCtl->setJERK(DAXIS, 3000);
//                            acsCtl->setKDEC(DAXIS,3000);
//                            return -1;
//                        }
//                        Sleep(1);
//                    }

//                    acsCtl->RToPointPos(YAXIS,0.2);
//                    Sleep(5);
//                    while(1)
//                    {
//                        motorsts = acsCtl->getMotorState(YAXIS);
//                        if (motorsts)
//                            break;
//                        if (StopFindEdgeFlag)
//                        {
//                            acsCtl->halt(DAXIS);
//                            acsCtl->setVEL(DAXIS, 30);
//                            acsCtl->setACC(DAXIS,300);
//                            acsCtl->setDEC(DAXIS,300);
//                            acsCtl->setJERK(DAXIS, 3000);
//                            acsCtl->setKDEC(DAXIS,3000);
//                            return -1;
//                        }
//                        Sleep(1);
//                    }
//                    value = acsCtl->getGlobalReal(vName);
//                    if (value < -0.4)
//                    {
//                        LaserMarkOffset_Y = 0;
//                        LaserMarkOffset_X = 0;
//                        {
//                            reqCMDRunFState = false;
//                            lastTaskIsFinish= true;
//                            acsCtl->setVEL(DAXIS, 30);
//                            acsCtl->setACC(DAXIS,300);
//                            acsCtl->setDEC(DAXIS,300);
//                            acsCtl->setJERK(DAXIS, 3000);
//                            acsCtl->setKDEC(DAXIS,3000);
//                            return 0;
//                        }
//                    }
//                    else
//                    {
//                        acsCtl->RToPointPos(YAXIS,-0.2);
//                        DAxisCtPos = acsCtl->getFPOS(DAXIS);
//                        double tmp = 360 - (DAxisCtPos - DAxisStartPos);
//                        acsCtl->RToPointPos(DAXIS,tmp);
//                        Sleep(5);
//                    }


//                }
//            }
//            if (StopFindEdgeFlag)
//            {
//                acsCtl->halt(DAXIS);
//                acsCtl->setVEL(DAXIS, 30);
//                acsCtl->setACC(DAXIS,300);
//                acsCtl->setDEC(DAXIS,300);
//                acsCtl->setJERK(DAXIS, 3000);
//                acsCtl->setKDEC(DAXIS,3000);
//                return -1;
//            }
//            motorsts = acsCtl->getMotorState(DAXIS);
//            if (motorsts)
//            {
//                count_find_edge++;
//                if (count_find_edge > 7)
//                {
//                    acsCtl->halt(DAXIS);
//                    acsCtl->setVEL(DAXIS, 30);
//                    acsCtl->setACC(DAXIS,300);
//                    acsCtl->setDEC(DAXIS,300);
//                    acsCtl->setJERK(DAXIS, 3000);
//                    acsCtl->setKDEC(DAXIS,3000);
//                    return -1;
//                }
//                acsCtl->RToPointPos(DAXIS,360);
//                DAxisStartPos = acsCtl->getFPOS(DAXIS);
//                if (count_find_edge == 2)
//                {
//                    acsCtl->RToPointPos(YAXIS,-0.3);
//                }
//                else if (count_find_edge == 3)
//                {
//                    acsCtl->RToPointPos(YAXIS,-0.3);
//                }
//                else if (count_find_edge == 4)
//                {
//                    acsCtl->RToPointPos(YAXIS,-0.3);
//                }
//                else if (count_find_edge == 5)
//                {
//                    acsCtl->RToPointPos(YAXIS,1.2);
//                }
//                else if (count_find_edge == 6)
//                {
//                    acsCtl->RToPointPos(YAXIS,0.3);
//                }
//                else if (count_find_edge == 7)
//                {
//                    acsCtl->RToPointPos(YAXIS,0.3);
//                }

//            }

//        }
//        catch (MyException mye)
//        {
//            exceptHandl_thread(MyException("寻边定位失败。",mye.getExceptCode()));//这里有问题，暂时没改。多线程中，不显示弹窗
//            acsCtl->setVEL(DAXIS, 30);
//            acsCtl->setACC(DAXIS,300);
//            acsCtl->setDEC(DAXIS,300);
//            acsCtl->setJERK(DAXIS, 3000);
//            acsCtl->setKDEC(DAXIS,3000);
//            return -1;
//        }

//        Sleep(1);
//    }
//}


void myFindEdgeThread()
{
    int ret;

    RS_SETTINGS->beginGroup("device/Type");
    QString strType = RS_SETTINGS->readEntry("/value");
    RS_SETTINGS->endGroup();
    if (strType == "6寸")
    {
        //ret = DEV->FindEdgeThread_6();
        ret = DEV->FindEdgeThread_6();
    }
    else
    {
        ret = DEV->FindEdgeThread();
    }
    //FindEdgeThread_6


    DEV->emit FindEdgeFinishSGL(ret);
    return;
}
void myGetRatioP1P2Thread()
{
    int ret;

    ret = DEV->GetRatioP1P2Thread();

    //FindEdgeThread_6


    DEV->emit GetRatioP1P2FinishSGL(ret);
    return;
}
void myElectricResistanceCheckThread()
{
    int ret;

    ret = DEV->ElectricResistanceCheckThread();
    DEV->emit show_Q_PP_SGL();
    DEV->emit ElectricResistanceCheckFinishSGL(ret);
    return;
}
// 寻边定位
void DeviceProxy::FindEdgeInSide()
{
    DEVICE_INFO->printDeviceSystemInfo("寻边定位中...");

    RS_SETTINGS->beginGroup("device/DDMotor");
    double DAxisVel = RS_SETTINGS->readNumDEntry("/Vel");
    RS_SETTINGS->endGroup();
    acsCtl->setVELParams(DAXIS,DAxisVel);

    DWORD ThreadID;
    HANDLE thrdHandle;

    thrdHandle = CreateThread(nullptr,
                              0,
                              (LPTHREAD_START_ROUTINE)myFindEdgeThread,
                              this,
                              0,
                              &ThreadID);
    //
}
void DeviceProxy::GetRatoP1P2Side()
{
    DEVICE_INFO->printDeviceSystemInfo("获取光路参数中...");

    DWORD ThreadID;
    HANDLE thrdHandle;

    thrdHandle = CreateThread(nullptr,
                              0,
                              (LPTHREAD_START_ROUTINE)myGetRatioP1P2Thread,
                              this,
                              0,
                              &ThreadID);
    //
}
void DeviceProxy::ElectricResistanceCheckSide()
{
    DEVICE_INFO->printDeviceSystemInfo("晶锭预测量中...");

    DWORD ThreadID;
    HANDLE thrdHandle;

    thrdHandle = CreateThread(nullptr,
                              0,
                              (LPTHREAD_START_ROUTINE)myElectricResistanceCheckThread,
                              this,
                              0,
                              &ThreadID);
    //
}

// 面扫描
void DeviceProxy::SScanInSide()
{
    DEVICE_INFO->printDeviceSystemInfo("扫描中...");

    acsCtl->stopBuffer(1);
    char vname[]= ACSCTL_RUNF_V;
    acsCtl->setGlobalInt(vname,0);
    SScanCode sScanCode;

    RS_SETTINGS->beginGroup("device/SSCS");
    double XRange = RS_SETTINGS->readNumDEntry("/XRange",1.0);
    double YRange = RS_SETTINGS->readNumDEntry("/YRange",1.0);
    double XInterval = RS_SETTINGS->readNumDEntry("/XInterval",1.0);
    double YInterval = RS_SETTINGS->readNumDEntry("/YInterval",1.0);
    RS_SETTINGS->endGroup();

    sScanCode.setXWorkRange(XRange);
    sScanCode.setYWorkRange(YRange);
    sScanCode.setXSampInterval(XInterval);
    sScanCode.setYSampInterval(YInterval);

    QByteArray qByCode = sScanCode.getCode().toLatin1();
    char* code = qByCode.data();
    acsCtl->loadBuffer(1,code);
    acsCtl->compileBuffer(1);
    acsCtl->runBuffer(1);
}

// 补偿扫描
void DeviceProxy::compSScanInSide()
{
    DEVICE_INFO->printDeviceSystemInfo("补偿面扫描中...");

    SSStartYPos=YAxisCtPos;
    SSStartXPos=XAxisCtPos;

    acsCtl->stopBuffer(1);
    char vname[]= ACSCTL_RUNF_V;
    acsCtl->setGlobalInt(vname,0);
    CSScanCode cSScanCode;

    double XRange;
    double YRange;
    RS_SETTINGS->beginGroup("device/Type");
    QString strType = RS_SETTINGS->readEntry("/value");
    RS_SETTINGS->endGroup();

    RS_SETTINGS->beginGroup("device/SSCS");
    XRange = RS_SETTINGS->readNumDEntry("/XRange",1.0);
    YRange = RS_SETTINGS->readNumDEntry("/YRange",1.0);
    double XInterval = RS_SETTINGS->readNumDEntry("/XInterval",1.0);
    double YInterval = RS_SETTINGS->readNumDEntry("/YInterval",1.0);
    RS_SETTINGS->endGroup();
    if (strType == "6寸")
    {
        XRange = INCHES6 * 2;
        YRange = INCHES6 * 2;
    }
    else if (strType == "8寸")
    {
        XRange = INCHES8 * 2;
        YRange = INCHES8 * 2;
    }
    else if (strType == "4寸")
    {
        XRange = INCHES4 * 2;
        YRange = INCHES4 * 2;
    }



    RS_SETTINGS->beginGroup("device/SSCS");
    RS_SETTINGS->writeEntry("/XRange",XRange);
    RS_SETTINGS->writeEntry("/YRange",YRange);
    RS_SETTINGS->endGroup();




    RS_SETTINGS->beginGroup("device/RSToZeroPos");
    double XAxisPos = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisPos = RS_SETTINGS->readNumDEntry("/YAxis");
    RS_SETTINGS->endGroup();

    RS_SETTINGS->beginGroup("device/MRHCamera/calibPos");
    double MHXAxis = RS_SETTINGS->readNumDEntry("/MHXAxis");
    double MHYAxis = RS_SETTINGS->readNumDEntry("/MHYAxis");
    double RHXAxis = RS_SETTINGS->readNumDEntry("/RHXAxis");
    double RHYAxis = RS_SETTINGS->readNumDEntry("/RHYAxis");
    RS_SETTINGS->endGroup();

    //    if (strType == "自定义")
    //    {
    //        cSScanCode.setRSToZeroXPos(XAxisCtPos + XRange/2 - RHXAxis + MHXAxis);
    //        cSScanCode.setRSToZeroYPos(YAxisCtPos + YRange/2 - RHYAxis + MHYAxis);
    //    }
    //    else
    //    {
    //        cSScanCode.setRSToZeroXPos(XAxisPos - RHXAxis + MHXAxis);
    //        cSScanCode.setRSToZeroYPos(YAxisPos - RHYAxis + MHYAxis);
    //    }
    cSScanCode.setRSToZeroXPos(XAxisCtPos + XRange/2 - RHXAxis + MHXAxis);
    cSScanCode.setRSToZeroYPos(YAxisCtPos + YRange/2 - RHYAxis + MHYAxis);

    //    RS_SETTINGS->beginGroup("device/ABSMove/Safe");
    //    double Z1 = RS_SETTINGS->readNumDEntry("/Z1");
    //    RS_SETTINGS->endGroup();

    //cSScanCode.setRSToZeroZ1Pos(Z1);

    cSScanCode.setXWorkRange(XRange);
    cSScanCode.setYWorkRange(YRange);
    cSScanCode.setXSampInterval(XInterval);
    cSScanCode.setYSampInterval(YInterval);

    char *code;
    QByteArray byCode = cSScanCode.getCode().toLatin1();
    code = byCode.data();

    acsCtl->loadBuffer(1,code);
    acsCtl->compileBuffer(1);
    acsCtl->runBuffer(1);
}

// 加工头补偿打开
void DeviceProxy::MHCompOpenInSide()
{
    DEVICE_INFO->printDeviceSystemInfo("加工头补偿打开中...");

    acsCtl->stopBuffer(1);
    char vname[]= ACSCTL_RUNF_V;
    acsCtl->setGlobalInt(vname,0);

    MHCompCode mHCompCode;

    RS_SETTINGS->beginGroup("device/SSCS");
    double XRange = RS_SETTINGS->readNumDEntry("/XRange",1.0);
    double YRange = RS_SETTINGS->readNumDEntry("/YRange",1.0);
    double XInterval = RS_SETTINGS->readNumDEntry("/XInterval",1.0);
    double YInterval = RS_SETTINGS->readNumDEntry("/YInterval",1.0);
    RS_SETTINGS->endGroup();

    mHCompCode.setXStartPos(SSStartXPos);
    mHCompCode.setYStartPos(SSStartYPos);

    mHCompCode.setXWorkRange(XRange);
    mHCompCode.setYWorkRange(YRange);
    mHCompCode.setXInterval(XInterval);
    mHCompCode.setYInterval(YInterval);

    mHCompCode.setLookupCols(lookupTable.at(0).size());
    mHCompCode.setLookupRows(lookupTable.size());

    RS_SETTINGS->beginGroup("device/MRHCamera/calibPos");
    double MHXAxis = RS_SETTINGS->readNumDEntry("/MHXAxis");
    double MHYAxis = RS_SETTINGS->readNumDEntry("/MHYAxis");
    double RHXAxis = RS_SETTINGS->readNumDEntry("/RHXAxis");
    double RHYAxis = RS_SETTINGS->readNumDEntry("/RHYAxis");
    RS_SETTINGS->endGroup();

    mHCompCode.setMHRHYOffset(MHYAxis-RHYAxis);
    mHCompCode.setMHRHXOffset(MHXAxis-RHXAxis);

    char *code;
    QByteArray byCode = mHCompCode.getCode().toLatin1();
    code = byCode.data();

    acsCtl->loadBuffer(1,code);
    acsCtl->compileBuffer(1);
    downLoadLookupTable();
    acsCtl->runBuffer(1);
}


// 补偿关闭
void DeviceProxy::compCloseInSide()
{
    DEVICE_INFO->printDeviceSystemInfo("补偿关闭中...");
    acsCtl->disableComp(ZAXIS);
    emit MHCompCloseFSGL();
    DEV->devPlaneScanCompState = 0;
    DEVICE_INFO->printDeviceSystemInfo("补偿关闭完成");

}

void DeviceProxy::toLoadAndUnloadPosInSide()
{
    DEVICE_INFO->printDeviceSystemInfo(QString("到上下料位运动中..."));

    acsCtl->stopBuffer(1);
    char vname[]= ACSCTL_RUNF_V;
    acsCtl->setGlobalInt(vname,0);
    MAxisABSMoveCode mAxisABSMoveCode;

    RS_SETTINGS->beginGroup("device/ZAAxisSafe");
    double ZAAxisSafePos = RS_SETTINGS->readNumEntry("/pos");
    double ZAAxisToSafePosVel = RS_SETTINGS->readNumEntry("/vel");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setZAAxisSafePos(ZAAxisSafePos);
    mAxisABSMoveCode.setZAAxisToSafePosVel(ZAAxisToSafePosVel);


    mAxisABSMoveCode.setXAxisIsMove(true);
    mAxisABSMoveCode.setYAxisIsMove(true);
    mAxisABSMoveCode.setZAxisIsMove(true);
    mAxisABSMoveCode.setZAAxisIsMove(false);
    mAxisABSMoveCode.disableZAAxisToSafePos(false);

    RS_SETTINGS->beginGroup("device/LoadAndUnloadPos");
    double XAxisPos = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisPos = RS_SETTINGS->readNumDEntry("/YAxis");
    double ZAxisPos = RS_SETTINGS->readNumDEntry("/ZAxis");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setXAxisTGPos(XAxisPos);
    mAxisABSMoveCode.setYAxisTGPos(YAxisPos);
    mAxisABSMoveCode.setZAxisTGPos(ZAxisPos);

    // 加载PTP位置设置
    RS_SETTINGS->beginGroup("device/ABSMove/Vel");
    double XAxisVel = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisVel = RS_SETTINGS->readNumDEntry("/YAxis");
    double ZAxisVel = RS_SETTINGS->readNumDEntry("/ZAxis");
    double ZAAxisVel = RS_SETTINGS->readNumDEntry("/ZAAxis");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setXAxisVel(XAxisVel);
    mAxisABSMoveCode.setYAxisVel(YAxisVel);
    mAxisABSMoveCode.setZAxisVel(ZAxisVel);
    mAxisABSMoveCode.setZAAxisVel(ZAAxisVel);
    char *code;
    QByteArray byCode = mAxisABSMoveCode.getCode().toLatin1();
    code = byCode.data();

    acsCtl->loadBuffer(1,code);
    acsCtl->compileBuffer(1);
    acsCtl->runBuffer(1);
}
void DeviceProxy::GloblaCameraPosInSide()
{
    DEVICE_INFO->printDeviceSystemInfo(QString("到全局相机位运动中..."));

    acsCtl->stopBuffer(1);
    char vname[]= ACSCTL_RUNF_V;
    acsCtl->setGlobalInt(vname,0);
    MAxisABSMoveCode mAxisABSMoveCode;

    RS_SETTINGS->beginGroup("device/ZAAxisSafe");
    double ZAAxisSafePos = RS_SETTINGS->readNumEntry("/pos");
    double ZAAxisToSafePosVel = RS_SETTINGS->readNumEntry("/vel");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setZAAxisSafePos(ZAAxisSafePos);
    mAxisABSMoveCode.setZAAxisToSafePosVel(ZAAxisToSafePosVel);


    mAxisABSMoveCode.setXAxisIsMove(true);
    mAxisABSMoveCode.setYAxisIsMove(true);
    mAxisABSMoveCode.setZAxisIsMove(false);
    mAxisABSMoveCode.setZAAxisIsMove(true);
    mAxisABSMoveCode.disableZAAxisToSafePos(false);

    RS_SETTINGS->beginGroup("device/GlobalCameraPos");
    double XAxisPos = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisPos = RS_SETTINGS->readNumDEntry("/YAxis");
    //double ZAxisPos = RS_SETTINGS->readNumDEntry("/ZAxis");
    RS_SETTINGS->endGroup();

    RS_SETTINGS->beginGroup("device/Rposition");
    double GlobalCameraOffset = RS_SETTINGS->readNumDEntry("/GlobalCameraOffset");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setXAxisTGPos(XAxisPos);
    mAxisABSMoveCode.setYAxisTGPos(YAxisPos);
    mAxisABSMoveCode.setZAAxisTGPos(workpieceHeight+GlobalCameraOffset);

    // 加载PTP位置设置
    RS_SETTINGS->beginGroup("device/ABSMove/Vel");
    double XAxisVel = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisVel = RS_SETTINGS->readNumDEntry("/YAxis");
    double ZAxisVel = RS_SETTINGS->readNumDEntry("/ZAxis");
    double ZAAxisVel = RS_SETTINGS->readNumDEntry("/ZAAxis");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setXAxisVel(XAxisVel);
    mAxisABSMoveCode.setYAxisVel(YAxisVel);
    mAxisABSMoveCode.setZAxisVel(ZAxisVel);
    mAxisABSMoveCode.setZAAxisVel(ZAAxisVel);



    char *code;
    QByteArray byCode = mAxisABSMoveCode.getCode().toLatin1();
    code = byCode.data();

    acsCtl->loadBuffer(1,code);
    acsCtl->compileBuffer(1);
    acsCtl->runBuffer(1);
}

void DeviceProxy::toSScanStartPosInSide()
{
    DEVICE_INFO->printDeviceSystemInfo(QString("到扫描起始位运动中..."));

    acsCtl->stopBuffer(1);
    char vname[]= ACSCTL_RUNF_V;
    acsCtl->setGlobalInt(vname,0);
    MAxisABSMoveCode mAxisABSMoveCode;

    mAxisABSMoveCode.setXAxisIsMove(true);
    mAxisABSMoveCode.setYAxisIsMove(true);
    mAxisABSMoveCode.setZAxisIsMove(false);
    mAxisABSMoveCode.setZAAxisIsMove(false);
    mAxisABSMoveCode.disableZAAxisToSafePos(true);

    RS_SETTINGS->beginGroup("device/RSToZeroPos");
    double XAxisPos = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisPos = RS_SETTINGS->readNumDEntry("/YAxis");
    RS_SETTINGS->endGroup();

    RS_SETTINGS->beginGroup("device/Type");
    QString strType = RS_SETTINGS->readEntry("/value");
    RS_SETTINGS->endGroup();
    if (strType == "6寸")
    {
        XAxisPos = XAxisPos - INCHES6;
        YAxisPos = YAxisPos - INCHES6;
    }
    else if (strType == "8寸")
    {
        XAxisPos = XAxisPos - INCHES8;
        YAxisPos = YAxisPos - INCHES8;
    }
    else if (strType == "4寸")
    {
        XAxisPos = XAxisPos - INCHES4;
        YAxisPos = YAxisPos - INCHES4;
    }

    mAxisABSMoveCode.setXAxisTGPos(XAxisPos);
    mAxisABSMoveCode.setYAxisTGPos(YAxisPos);

    // 加载PTP位置设置
    RS_SETTINGS->beginGroup("device/ABSMove/Vel");
    double XAxisVel = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisVel = RS_SETTINGS->readNumDEntry("/YAxis");
    double ZAxisVel = RS_SETTINGS->readNumDEntry("/ZAxis");
    double ZAAxisVel = RS_SETTINGS->readNumDEntry("/ZAAxis");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setXAxisVel(XAxisVel);
    mAxisABSMoveCode.setYAxisVel(YAxisVel);
    mAxisABSMoveCode.setZAxisVel(ZAxisVel);
    mAxisABSMoveCode.setZAAxisVel(ZAAxisVel);
    char *code;
    QByteArray byCode = mAxisABSMoveCode.getCode().toLatin1();
    code = byCode.data();

    acsCtl->loadBuffer(1,code);
    acsCtl->compileBuffer(1);
    acsCtl->runBuffer(1);
}


void DeviceProxy::toRSToZeroPosInSide()
{
    DEVICE_INFO->printDeviceSystemInfo(QString("到对零位运动中..."));

    acsCtl->stopBuffer(1);
    char vname[]= ACSCTL_RUNF_V;
    acsCtl->setGlobalInt(vname,0);
    MAxisABSMoveCode mAxisABSMoveCode;

    RS_SETTINGS->beginGroup("device/ZAAxisSafe");
    double ZAAxisSafePos = RS_SETTINGS->readNumEntry("/pos");
    double ZAAxisToSafePosVel = RS_SETTINGS->readNumEntry("/vel");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setZAAxisSafePos(ZAAxisSafePos);
    mAxisABSMoveCode.setZAAxisToSafePosVel(ZAAxisToSafePosVel);

    mAxisABSMoveCode.setXAxisIsMove(true);
    mAxisABSMoveCode.setYAxisIsMove(true);
    mAxisABSMoveCode.setZAxisIsMove(false);
    mAxisABSMoveCode.setZAAxisIsMove(true);
    mAxisABSMoveCode.disableZAAxisToSafePos(false);


    RS_SETTINGS->beginGroup("device/RSToZeroPos");
    double XAxisPos = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisPos = RS_SETTINGS->readNumDEntry("/YAxis");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setXAxisTGPos(XAxisPos);
    mAxisABSMoveCode.setYAxisTGPos(YAxisPos);
    mAxisABSMoveCode.setZAAxisTGPos(ZAAxisSafePos);

    // 加载PTP位置设置
    RS_SETTINGS->beginGroup("device/ABSMove/Vel");
    double XAxisVel = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisVel = RS_SETTINGS->readNumDEntry("/YAxis");
    double ZAxisVel = RS_SETTINGS->readNumDEntry("/ZAxis");
    double ZAAxisVel = RS_SETTINGS->readNumDEntry("/ZAAxis");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setXAxisVel(XAxisVel);
    mAxisABSMoveCode.setYAxisVel(YAxisVel);
    mAxisABSMoveCode.setZAxisVel(ZAxisVel);
    mAxisABSMoveCode.setZAAxisVel(ZAAxisVel);
    char *code;
    QByteArray byCode = mAxisABSMoveCode.getCode().toLatin1();
    code = byCode.data();

    acsCtl->loadBuffer(1,code);
    acsCtl->compileBuffer(1);
    acsCtl->runBuffer(1);
}

void DeviceProxy::SMachInSide(int index)
{
    DEVICE_INFO->printDeviceSystemInfo("单步加工中...");

    acsCtl->stopBuffer(1);

    char vname[]= ACSCTL_RUNF_V;
    acsCtl->setGlobalInt(vname,0);

    //        QByteArray qbyCode = MachCode().getCode().toLatin1();
    //        char* code = qbyCode.data();
    //        acsCtl->loadBuffer(1,code);

    // 加载加工代码路径
    RS_SETTINGS->beginGroup("device/Mach");
    QString machCodeFilePath = RS_SETTINGS->readEntry("/codeFilePath");
    //    QString machCodeFilePath2 = RS_SETTINGS->readEntry("/codeFilePath2");
    //    QString machCodeFilePath3 = RS_SETTINGS->readEntry("/codeFilePath3");
    //    QString machCodeFilePath4 = RS_SETTINGS->readEntry("/codeFilePath4");
    //    QString machCodeFilePath5 = RS_SETTINGS->readEntry("/codeFilePath5");
    RS_SETTINGS->endGroup();

    if(machCodeFilePath == "")
    {
        throw MyException("加工代码路径为空，无法执行单步加工。请先指定加工代码路径。",acsc_GetLastError());
    }

    //    QByteArray fileNameQby = machCodeFilePath.toLocal8Bit();
    //    char* fileName = fileNameQby.data();
    //    acsCtl->loadBuffersFromFile(fileName);
    machCodeFilePath = machCodeFilePath + QString("_%1.txt").arg(index);

    int ret = deCode_file(machCodeFilePath);
    if (ret != 0)
    {
        throw MyException("加工代码解码出错，无法执行单步加工。请先确定加工代码路径。",acsc_GetLastError());
    }
    char *code;
    QByteArray byCode = deCodeString.toLatin1();
    code = byCode.data();

    acsCtl->loadBuffer(8,code);
    acsCtl->compileBuffer(8);
    acsCtl->runBuffer(8);

    //    acsCtl->compileBuffer(8);
    //    acsCtl->runBuffer(8);
}

void DeviceProxy::semiAutoMachInSide()
{
    DEVICE_INFO->printDeviceSystemInfo("半自动加工中...");
    emit AutoSmachStateSGL(true);
    emit SmachTypeStateSGL(false);
    emit VacuumSuckerOnOrOffStateSGL(false);
    emit StopStateSGL(!DEV->SuspendFlag);
    bRunning = true;
    emit RunSGL(!bRunning);
    step = 1;
    StopFindEdgeFlag = false;
    MODBUSTCP->stopFlag = false;
    checkZaxisAlarmFlag = true;
    LaserTestApFlag = false;
    StopGonglvCheckFlag = false;

}

void DeviceProxy::vacuumSuckerOpenInSide()
{
    DEVICE_INFO->printDeviceSystemInfo("真空吸盘打开中...");
    char vname[] = ACSCTL_DO1_V;
    int do1 = acsCtl->getGlobalInt(vname);
    RS_SETTINGS->beginGroup("device/DO");
    QString vacuumSuckerDONumStr = RS_SETTINGS->readEntry("/vacuumSucker");
    RS_SETTINGS->endGroup();

    int vacuumSuckerDONum = vacuumSuckerDONumStr.toInt();

    int mask = 1;
    mask = mask<<vacuumSuckerDONum;
    do1 = (do1|mask);
    acsCtl->setGlobalInt(vname,do1);
    devWorkpieceLockState = 1;
    emit vacuumSuckerOpenFSGL();
    DEVICE_INFO->printDeviceSystemInfo("真空吸盘打开完成");
}

void DeviceProxy::vacuumSuckerCloseInSide()
{
    DEVICE_INFO->printDeviceSystemInfo("真空吸盘关闭中...");

    char vname[] = ACSCTL_DO1_V;
    int do1 = acsCtl->getGlobalInt(vname);
    RS_SETTINGS->beginGroup("device/DO");
    QString vacuumSuckerDONumStr = RS_SETTINGS->readEntry("/vacuumSucker");
    RS_SETTINGS->endGroup();

    int vacuumSuckerDONum = vacuumSuckerDONumStr.toInt();

    int mask = 1;
    mask = mask<<vacuumSuckerDONum;
    mask = (~mask);
    do1 = (do1&mask);
    acsCtl->setGlobalInt(vname,do1);
    devWorkpieceLockState = 0;
    emit vacuumSuckerCloseFSGL();
    DEVICE_INFO->printDeviceSystemInfo("真空吸盘关闭完成");
}

void DeviceProxy::laserOpenInSide()
{
    DEVICE_INFO->printDeviceSystemInfo("激光器打开中...");
    char vname[] = ACSCTL_DO1_V;
    int do1 = acsCtl->getGlobalInt(vname);
    RS_SETTINGS->beginGroup("device/DO");
    QString laserDONumStr = RS_SETTINGS->readEntry("/laser");
    RS_SETTINGS->endGroup();

    int laserDONum = laserDONumStr.toInt();
    int mask = 1;
    mask = mask<<laserDONum;
    do1 = (do1|mask);
    acsCtl->setGlobalInt(vname,do1);
    emit laserOpenFSGL();
    devLaserState = 1;
    DEVICE_INFO->printDeviceSystemInfo("激光器打开完成");
}

void DeviceProxy::laserCloseInSide()
{
    DEVICE_INFO->printDeviceSystemInfo("激光器关闭中...");
    char vname[] = ACSCTL_DO1_V;
    int do1 = acsCtl->getGlobalInt(vname);
    RS_SETTINGS->beginGroup("device/DO");
    QString laserDONumStr = RS_SETTINGS->readEntry("/laser");
    RS_SETTINGS->endGroup();

    int laserDONum = laserDONumStr.toInt();

    int mask = 1;
    mask = mask<<laserDONum;
    mask = (~mask);
    do1 = (do1&mask);
    acsCtl->setGlobalInt(vname,do1);
    emit laserCloseFSGL();
    devLaserState = 0;
    DEVICE_INFO->printDeviceSystemInfo("激光器关闭完成");
}

void DeviceProxy::RHToMHInSide()
{
    DEVICE_INFO->printDeviceSystemInfo("测距头到加工头位置运动中...");
    acsCtl->stopBuffer(1);
    char vname[]= ACSCTL_RUNF_V;
    acsCtl->setGlobalInt(vname,0);
    MAxisABSMoveCode mAxisABSMoveCode;

    RS_SETTINGS->beginGroup("device/ZAAxisSafe");
    double ZAAxisSafePos = RS_SETTINGS->readNumEntry("/pos");
    double ZAAxisToSafePosVel = RS_SETTINGS->readNumEntry("/vel");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setZAAxisSafePos(ZAAxisSafePos);
    mAxisABSMoveCode.setZAAxisToSafePosVel(ZAAxisToSafePosVel);

    mAxisABSMoveCode.setXAxisIsMove(true);
    mAxisABSMoveCode.setYAxisIsMove(true);
    mAxisABSMoveCode.setZAxisIsMove(false);
    mAxisABSMoveCode.setZAAxisIsMove(false);
    mAxisABSMoveCode.disableZAAxisToSafePos(true);
    mAxisABSMoveCode.setCMRSwitch(true);

    RS_SETTINGS->beginGroup("device/MRHCamera/calibPos");
    double MHXAxis = RS_SETTINGS->readNumDEntry("/MHXAxis");
    double MHYAxis = RS_SETTINGS->readNumDEntry("/MHYAxis");
    double RHXAxis = RS_SETTINGS->readNumDEntry("/RHXAxis");
    double RHYAxis = RS_SETTINGS->readNumDEntry("/RHYAxis");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setXAxisTGPos(RHXAxis-MHXAxis);
    mAxisABSMoveCode.setYAxisTGPos(RHYAxis-MHYAxis);

    RS_SETTINGS->beginGroup("device/MRHCamera/switchVel");
    double XAxisVel = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisVel = RS_SETTINGS->readNumDEntry("/YAxis");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setXAxisVel(XAxisVel);
    mAxisABSMoveCode.setYAxisVel(YAxisVel);
    char *code;
    QByteArray byCode = mAxisABSMoveCode.getCode().toLatin1();
    code = byCode.data();

    acsCtl->loadBuffer(1,code);
    acsCtl->compileBuffer(1);
    acsCtl->runBuffer(1);
}

void DeviceProxy::MHToRHInSide()
{
    DEVICE_INFO->printDeviceSystemInfo("加工头到测距头位置运动中...");
    acsCtl->stopBuffer(1);
    char vname[]= ACSCTL_RUNF_V;
    acsCtl->setGlobalInt(vname,0);
    MAxisABSMoveCode mAxisABSMoveCode;

    RS_SETTINGS->beginGroup("device/ZAAxisSafe");
    double ZAAxisSafePos = RS_SETTINGS->readNumEntry("/pos");
    double ZAAxisToSafePosVel = RS_SETTINGS->readNumEntry("/vel");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setZAAxisSafePos(ZAAxisSafePos);
    mAxisABSMoveCode.setZAAxisToSafePosVel(ZAAxisToSafePosVel);

    mAxisABSMoveCode.setXAxisIsMove(true);
    mAxisABSMoveCode.setYAxisIsMove(true);
    mAxisABSMoveCode.setZAxisIsMove(false);
    mAxisABSMoveCode.setZAAxisIsMove(false);
    mAxisABSMoveCode.disableZAAxisToSafePos(true);
    mAxisABSMoveCode.setCMRSwitch(true);

    RS_SETTINGS->beginGroup("device/MRHCamera/calibPos");
    double MHXAxis = RS_SETTINGS->readNumDEntry("/MHXAxis");
    double MHYAxis = RS_SETTINGS->readNumDEntry("/MHYAxis");
    double RHXAxis = RS_SETTINGS->readNumDEntry("/RHXAxis");
    double RHYAxis = RS_SETTINGS->readNumDEntry("/RHYAxis");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setXAxisTGPos(MHXAxis-RHXAxis);
    mAxisABSMoveCode.setYAxisTGPos(MHYAxis-RHYAxis);

    RS_SETTINGS->beginGroup("device/MRHCamera/switchVel");
    double XAxisVel = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisVel = RS_SETTINGS->readNumDEntry("/YAxis");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setXAxisVel(XAxisVel);
    mAxisABSMoveCode.setYAxisVel(YAxisVel);
    char *code;
    QByteArray byCode = mAxisABSMoveCode.getCode().toLatin1();
    code = byCode.data();

    acsCtl->loadBuffer(1,code);
    acsCtl->compileBuffer(1);
    acsCtl->runBuffer(1);
}
void DeviceProxy::ClientConnect()
{
    //解析所有客户连接
    while (server->hasPendingConnections())
    {
        //连接上后通过socket获取连接信息
        socket = server->nextPendingConnection();
        QString str = QString("[ip:%1,port:%2]").arg(socket->peerAddress().toString()).arg(socket->peerPort());
        //提示连接成功
        //ui->edLog->append(str+"Connect to the server");
        //监听客户端是否有消息发送
        connect(socket, &QTcpSocket::readyRead, this, &DeviceProxy::ReadData1);
    }
}
extern QImage* qimgRecv;//从python返回的img转化为qimage
extern cv::Mat imgRecv;//从python返回的img
extern cv::Mat imgcv;//拼接完成的图片
void DeviceProxy::ReadData1()
{


    QDataStream streamin(socket);
    streamin.setByteOrder(QDataStream::BigEndian);
    quint32 recvsize;
    streamin >> recvsize;

    QByteArray imgDataReceived;
    while (imgDataReceived.size() < recvsize) {
        socket->waitForReadyRead();
        imgDataReceived.append(socket->readAll());
    }

    imgRecv = cv::imdecode(std::vector<char>(imgDataReceived.begin(), imgDataReceived.end()), 1);

    imwrite("binary_mask.jpg",imgRecv);
    emit ShowMergeSGL();
    //    QImage imgReceived;
    //    imgReceived.loadFromData(imgDataReceived, "JPG");
    //    ui->lbImage->setPixmap(QPixmap::fromImage(imgReceived));

}
cv::Mat Func(int left,int right);
int DeviceProxy::GetGlobalPhotoThread()
{
    //1、连接，获取数组  S T E
    //2、到第一点，读取。循环。结束
    //除了xy位置，Z轴位置也是要计算的。增加一个Z0轴偏移，参考Z2偏移
    //测试时，第一次运行，先升Z轴，再升Z0轴，xy到位，Z0落下
    //后续只动XY，不在动z0，直至测完。
    //测完后，升z0轴，完成测试

    StopElectricResistanceCheckFlag = false;
    int step = 0;
    bool hasToBuffer = false;
    Mat image;

    int ret;
    RS_SETTINGS->beginGroup("device/Rposition");

    double GlobalPix = RS_SETTINGS->readNumDEntry("/GlobalPix");
    int StartPos = RS_SETTINGS->readNumDEntry("/StartPos");
    int StartPosRight = RS_SETTINGS->readNumDEntry("/StartPosRight");
    RS_SETTINGS->endGroup();
    Mat dst(3648, 22*(StartPosRight-StartPos), CV_8UC3, Scalar(0, 0, 0));

    while(1)
    {
        switch(step)
        {
        case 0:
            if (!hasToBuffer)
            {
                acsCtl->setVEL(DAXIS, 40);
                acsCtl->setACC(DAXIS,400);
                acsCtl->setDEC(DAXIS,400);
                acsCtl->setJERK(DAXIS, 4000);
                acsCtl->setKDEC(DAXIS,4000);
                acsCtl->RToPointPos(DAXIS,-90);//转到工作位
                GloblaCameraPosInSide();
                reqCMDRunFState = true;
                hasToBuffer = true;
            }
            else
            {
                if (!reqCMDRunFState)//buffer是否执行完毕
                {
                    bool motorstsD,motorstsX;
                    acsCtl->RToPointPos(XAXIS,-113);//转到工作位
                    while(1)
                    {

                        motorstsD = acsCtl->getMotorState(DAXIS);
                        motorstsX = acsCtl->getMotorState(XAXIS);
                        if (motorstsD && motorstsX)
                            break;
                        if (DEV->StopElectricResistanceCheckFlag)
                        {
                            acsCtl->halt(DAXIS);
                            acsCtl->halt(XAXIS);
                            return -1;
                        }
                        Sleep(50);
                    }
                    RS_SETTINGS->beginGroup("device/Rposition");
                    RS_SETTINGS->writeEntry("/XiaoXAxis", XAxisCtPos+(11*(StartPosRight-StartPos)+(5472/2-StartPos))/GlobalPix);
                    RS_SETTINGS->endGroup();
                    step = step + 1;
                    hasToBuffer = false;
                    //std::vector<cv::Mat>().swap(srcImgs);
                    //continue;
                }
            }
            break;
        case 1:
            for (int i = 0;i<22;i++)
            {


                bool motorstsX;
                acsCtl->RToPointPos(XAXIS,10);
                Sleep(20);
                while(1)
                {

                    motorstsX = acsCtl->getMotorState(XAXIS);
                    if (motorstsX)
                        break;
                    if (DEV->StopElectricResistanceCheckFlag)
                    {
                        acsCtl->halt(XAXIS);
                        return -1;
                    }
                    Sleep(50);
                }
                LIGHTSOURCEFIND->LightOn(4);
                ret = CAMERAFIND->GetImage(image,true);
                LIGHTSOURCEFIND->LightOff(4);
                if (ret < 0)
                {
                    return -1;
                }
                else
                {
                    QDateTime datetime = QDateTime::currentDateTime();
                    char buf[200];
                    //sprintf(buf,"%s.jpg",datetime.toString("yyyyMMddHHmmsszzz").toLocal8Bit().data());
                    sprintf(buf,"%d.jpg",i);


                    //cv::flip(image, image, 0);
                    //cv::flip(image, image, 1);
                    imwrite(buf,image);
                    //image.copyTo(srcImgs[i]);
                    //cv::Rect roi(StartPos, 0, (int)GlobalPix*10, image.rows);
                    cv::Rect roi(StartPos, 0, (StartPosRight-StartPos), image.rows);

                    cv::Mat cropped_image = image(roi);
                    Mat dst_roi= dst(Rect(i*(StartPosRight-StartPos), 0, (StartPosRight-StartPos), dst.rows));
                    cropped_image.copyTo(dst_roi);
                    //                    srcImgs.push_back(cropped_image);

                }


            }
            step = step + 1;
            break;
        case 2:
            dst.copyTo(imgcv);
            imwrite("imgcv.jpg",imgcv);
            acsCtl->RToPointPos(DAXIS,90);//转到工作位
            return 0;

        }
        if (DEV->StopElectricResistanceCheckFlag)
        {
            return -1;
        }
        Sleep(5);
    }
}


void myGetGlobalPhotoThread()
{
    int ret;

    ret = DEV->GetGlobalPhotoThread();

    if (ret ==0)
    {
        DEVICE_INFO->printDeviceSystemInfo(QString("全局相机拍照运行完毕！"));
    }
    else
        DEVICE_INFO->printDeviceSystemInfo(QString("全局相机拍照失败！"));
    DEV->emit GetGlobalPhotoFinishSGL(ret);
    return;
}

void DeviceProxy::GetGlobalPhotoSide()
{
    DEVICE_INFO->printDeviceSystemInfo("全局相机拍照中...");

    DWORD ThreadID;
    HANDLE thrdHandle;

    thrdHandle = CreateThread(nullptr,
                              0,
                              (LPTHREAD_START_ROUTINE)myGetGlobalPhotoThread,
                              this,
                              0,
                              &ThreadID);
    //
}

void DeviceProxy::MHCompOpen()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，无法执行开启面扫描补偿。请先完成复位。"),MY_WARN));
        return;
    }
    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行开启面扫描补偿。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if (lookupTable.size() == 0)
    {
        emit exceptSGL(MyException(QString("设备未执行平面扫描，无法执行开启面扫描补偿。请先扫描。"),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    if (lookupTable.empty())
    {
        emit exceptSGL(MyException(QString("扫描数据为空，请先扫描。"),MY_WARN));
        return;
    }

    try
    {
        lastTaskIsFinish=false;
        lastTaskName="面扫描补偿打开";
        MHCompOpenInSide();

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(MHCompOpenFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("面扫描补偿打开失败。",mye.getExceptCode()));
    }

}


void DeviceProxy::MotionCompOpen(bool flag,double array[])
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，无法执行开启运动补偿。请先完成复位。"),MY_WARN));
        return;
    }
    //    if(!lastTaskIsFinish)
    //    {
    //        emit exceptSGL(MyException(QString("%1任务执行中，无法执行开启运动补偿。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
    //        return;
    //    }
    //    if(bRunning)
    //    {
    //        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
    //        return;
    //    }
    if (!flag)
    {
        if (array == nullptr)
        {
            emit exceptSGL(MyException(QString("参数错误！"),MY_WARN));
            return;
        }
    }

    try
    {
        lastTaskIsFinish=false;
        lastTaskName="运动补偿打开";
        acsCtl->stopBuffer(5);
        DEVICE_INFO->printDeviceSystemInfo("运行补偿开启中...");
        double CompensationX1;
        double CompensationX2;
        double CompensationOffset;
        double CompensationMaxValue;
        if (flag)
        {
            RS_SETTINGS->beginGroup("device/ABSMove/Safe");
            CompensationX1 = RS_SETTINGS->readNumDEntry("/CompensationX1");
            CompensationX2 = RS_SETTINGS->readNumDEntry("/CompensationX2");
            CompensationOffset = RS_SETTINGS->readNumDEntry("/CompensationOffset");
            CompensationMaxValue = RS_SETTINGS->readNumDEntry("/CompensationMaxValue");
            RS_SETTINGS->endGroup();
        }
        else
        {
            CompensationX1 = array[0];
            CompensationX2 = array[1];
            CompensationOffset = array[2];
            CompensationMaxValue = array[3];
        }


        MHCompCode mHCompCode;
        mHCompCode.MaxCmp = CompensationMaxValue;
        mHCompCode.MaxPos_x = CompensationX2;
        mHCompCode.MinPos_x = CompensationX1;
        mHCompCode.x_offset = CompensationOffset;

        char *code;
        QByteArray byCode = mHCompCode.getCode_motion().toLatin1();
        code = byCode.data();

        acsCtl->loadBuffer(5,code);
        acsCtl->compileBuffer(5);
        acsCtl->runBuffer(5);

        emit MotionCompOpenFSGL();
        devMotionCompState = 1;
        DEVICE_INFO->printDeviceSystemInfo("运行补偿开启完成");
        lastTaskIsFinish=true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("运动补偿打开失败。",mye.getExceptCode()));
    }

}

void DeviceProxy::FindEdge()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，无法执行寻边定位。请先完成复位。"),MY_WARN));
        return;
    }
    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行寻边定位。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    try
    {
        lastTaskIsFinish=false;
        lastTaskName="寻边定位";
        FindEdgeInSide();

        connect(this,SIGNAL(FindEdgeFinishSGL(int)),this,SLOT(FindEdgeFHandl(int)));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("寻边定位失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::GetRatioP1P2()//PEG_R
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，无法获取光路参数。请先完成复位。"),MY_WARN));
        return;
    }
    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法获取光路参数。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    try
    {
        lastTaskIsFinish=false;
        lastTaskName="获取光路参数";
        GetRatoP1P2Side();

        connect(this,SIGNAL(GetRatioP1P2FinishSGL(int)),this,SLOT(GetRatioP1P2FHandl(int)));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("获取光路参数失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::GetGlobalPhoto()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，无法开始测量电阻。请先完成复位。"),MY_WARN));
        return;
    }
    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法开始全局相机拍照。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    try
    {
        lastTaskIsFinish=false;
        lastTaskName="全局相机拍照";
        GetGlobalPhotoSide();

        connect(this,SIGNAL(GetGlobalPhotoFinishSGL(int)),this,SLOT(GetGlobalPhotoFHandl(int)));
        //reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("全局相机拍照失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::GetGlobalPhotoFHandl(int result)
{
    disconnect(this,SIGNAL(GetGlobalPhotoFinishSGL(int)),this,SLOT(GetGlobalPhotoFHandl(int)));
    if (result == 0)
        DEVICE_INFO->printDeviceSystemInfo("全局相机拍照完成");
    else
        DEVICE_INFO->printDeviceSystemInfo("全局相机拍照失败，未完成检测!");
    //ABSMove_Z0_test();
    lastTaskIsFinish=true;
    SpecificAreasWidget * specificAreasWidget = new(SpecificAreasWidget);
    specificAreasWidget->exec();
}
void DeviceProxy::ElectricResistanceCheck()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，无法开始测量电阻。请先完成复位。"),MY_WARN));
        return;
    }
    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法开始测量电阻。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    try
    {
        lastTaskIsFinish=false;
        lastTaskName="电阻测量";
        ElectricResistanceCheckSide();

        connect(this,SIGNAL(ElectricResistanceCheckFinishSGL(int)),this,SLOT(ElectricResistanceCheckFHandl(int)));
        //reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("测量电阻失败。",mye.getExceptCode()));
    }
}


void DeviceProxy::compClose()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，无法执行关闭面补偿。请先完成复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行关闭面补偿。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    try
    {
        lastTaskIsFinish=false;
        lastTaskName="面补偿关闭";
        compCloseInSide();
        lastTaskIsFinish=true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("面关闭补偿失败。",mye.getExceptCode()));
    }

}
void DeviceProxy::MotionCompClose()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，无法执行关闭补偿。请先完成复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行关闭补偿。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    try
    {
        lastTaskIsFinish=false;
        lastTaskName="补偿关闭";
        DEVICE_INFO->printDeviceSystemInfo("运行补偿关闭中...");
        acsCtl->disableComp(ZAXIS);
        if(acsCtl->getBufferRunState(5))
        {
            acsCtl->stopBuffer(5);
        }
        emit MotionCompCloseFSGL();
        devMotionCompState = 0;
        DEVICE_INFO->printDeviceSystemInfo("运行补偿关闭完成");
        lastTaskIsFinish=true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("关闭补偿失败。",mye.getExceptCode()));
    }

}


void DeviceProxy::Suspend()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行暂停。请先初始化。"),MY_WARN));
        return;
    }
    if ((lastTaskIsFinish == false) && (lastTaskName == "单步加工"))
    {
        try
        {
            acsCtl->suspendBuffer(8);
            emit suspendBufferFSGL();

        }
        catch (MyException mye)
        {
            exceptHandl(MyException("暂停失败。",mye.getExceptCode()));
        }
    }

}
void DeviceProxy::ContinueBuffer()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行运行。请先初始化。"),MY_WARN));
        return;
    }
    if ((lastTaskIsFinish == false) && (lastTaskName == "单步加工"))
    {
        try
        {
            acsCtl->runBuffer(8);
            emit continueBufferFSGL();

        }
        catch (MyException mye)
        {
            exceptHandl(MyException("继续运行失败。",mye.getExceptCode()));
        }
    }
}
void DeviceProxy::stop()
{

    bool bThreadRunning = false;
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行停止。请先初始化。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("停止中...");


        //reqCMDRunFState = false;
        StopFindEdgeFlag = true;
        StopGetRatioP1P2Flag = true;
        StopElectricResistanceCheckFlag = true;
        StopGonglvCheckFlag = true;
        MODBUSTCP->stopFlag = true;
        acsCtl->halt(XAXIS);
        acsCtl->halt(YAXIS);
        acsCtl->halt(ZAXIS);
        acsCtl->halt(ZAAXIS);
        acsCtl->halt(DAXIS);
        acsCtl->halt(Z0AXIS);
        acsCtl->halt(Z2AXIS);
        if(acsCtl->getBufferRunState(8))
        {
            acsCtl->stopBuffer(8);
        }
        if(acsCtl->getBufferRunState(1))
        {
            acsCtl->stopBuffer(1);
        }
        if(acsCtl->getBufferRunState(3))
        {
            acsCtl->stopBuffer(3);
            QString qstrcode;
            qstrcode+=
                    "lc.LaserDisable()\n"
                    "stop\n";
            QByteArray qByCode = qstrcode.toLatin1();
            char* code = qByCode.data();
            acsCtl->loadBuffer(3,code);
            acsCtl->compileBuffer(3);
            acsCtl->runBuffer(3);
        }


        laserClose();
        CuCeGaoOpen();
        if (pLaserMark != nullptr)
            pLaserMark->Abort();
        if (bRunning)
        {
            mutex.lock();
            bRunning = false;
            emit RunSGL(!bRunning);
            step = 0;
            mutex.unlock();
            bThreadRunning = true;
            emit StopStateSGL(true);
            SuspendFlag = false;
        }


        lastTaskIsFinish=true;
        reqCMDRunFState = false;
        emit AutoSmachStateSGL(false);
        emit VacuumSuckerOnOrOffStateSGL(true);
        if (bUserPower)
            emit SmachTypeStateSGL(true);
        emit continueBufferFSGL();
        StepNameSGL(30);
        emit StopStateSGL(true);
        SuspendFlag = false;
        DEVICE_INFO->printDeviceSystemInfo("停止完成");
        //        if (bThreadRunning)
        //        {
        //            toLoadAndUnloadPos();
        //        }
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("停止失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::EStop()
{

    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行急停。请先初始化。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("软件急停中...");
        StopFindEdgeFlag = true;
        StopGetRatioP1P2Flag = true;
        StopElectricResistanceCheckFlag = true;
        MODBUSTCP->stopFlag = true;
        acsCtl->halt(XAXIS);
        acsCtl->halt(YAXIS);
        acsCtl->halt(ZAXIS);
        acsCtl->halt(ZAAXIS);
        acsCtl->halt(DAXIS);
        acsCtl->halt(Z0AXIS);
        acsCtl->halt(Z2AXIS);
        acsCtl->disable(XAXIS);
        acsCtl->disable(YAXIS);
        acsCtl->disable(ZAXIS);
        acsCtl->disable(ZAAXIS);
        acsCtl->disable(DAXIS);
        acsCtl->disable(Z0AXIS);
        acsCtl->disable(Z2AXIS);

        if(acsCtl->getBufferRunState(8))
        {
            acsCtl->stopBuffer(8);
        }
        if(acsCtl->getBufferRunState(1))
        {
            acsCtl->stopBuffer(1);
        }
        if (bRunning)
        {
            mutex.lock();
            bRunning = false;
            emit RunSGL(!bRunning);
            step = 0;
            mutex.unlock();
        }

        emit continueBufferFSGL();
        lastTaskIsFinish=true;
        laserClose();
        if (pLaserMark != nullptr)
            pLaserMark->Abort();
        devIsReset = false;
        reqCMDRunFState = false;
        DEVICE_INFO->printDeviceSystemInfo("软件急停完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("急停失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::SMach()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，无法执行单步加工。请先完成复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行单步加工。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    int axisBuf[4] = {0};
    axisBuf[1] = 1;
    int ret = AxisMoveSafeCheckXY(axisBuf,nullptr,nullptr);
    if(ret < 0)
    {
        emit exceptSGL(MyException(QString("晶碇与Z轴间距太小，不能执行动作。"),MY_WARN));
        return;
    }

    // 加载加工代码路径
    RS_SETTINGS->beginGroup("device/Mach");
    QString machCodeFilePath = RS_SETTINGS->readEntry("/codeFilePath");
    RS_SETTINGS->endGroup();

    if(machCodeFilePath == "")
    {
        emit exceptSGL(MyException(QString("加工代码路径为空，无法执行单步加工。请先指定加工代码路径。"),MY_WARN));
        return;
    }

    try
    {
        lastTaskIsFinish=false;
        lastTaskName="单步加工";
        SMachInSide(1);
        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(SMachFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("单步加工失败。",mye.getExceptCode()));
    }

}

void DeviceProxy::semiAutoMach()
{


    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化，未复位，无法执行半自动加工。请先完成复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行半自动加工。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    if (devLaserOpenTime < 1800)
    {
        if (bUserPower)
        {
            emit AutoExceptSGL_laser(MyException(QString("激光器开启时间不足3分钟,是否继续加工？")));
            if (DataCheckFlag)
                devLaserOpenTime = 1800;
            else
                return;
        }
        else
        {
            emit exceptSGL(MyException(QString("激光器开启时间不足3分钟,请等待！"),MY_WARN));
            return;
        }

    }
    //    if (pLaserMark == nullptr)
    //    {
    //        if (bUserPower)
    //        {
    //            emit AutoExceptSGL_laser(MyException(QString("振镜未初始化成功,是否继续加工？")));
    //            if (!DataCheckFlag)
    //                return;
    //        }
    //        else
    //        {
    //            emit exceptSGL(MyException(QString("振镜未初始化成功，请重新启动程序！"),MY_WARN));
    //            return;
    //        }

    //    }
    // 加载加工代码路径
    RS_SETTINGS->beginGroup("device/Mach");
    QString machCodeFilePath = RS_SETTINGS->readEntry("/codeFilePath");
    QString machCodeFilePath2 = RS_SETTINGS->readEntry("/codeFilePath2");
    RS_SETTINGS->endGroup();

    if((machCodeFilePath == "") || (machCodeFilePath2 == ""))
    {
        emit exceptSGL(MyException(QString("加工代码路径为空，无法执行单步加工。请先指定加工代码路径。"),MY_WARN));
        return;
    }
    int ret = UpdateWorkData();
    if (ret != 0)
    {
        emit exceptSGL(MyException(QString("加工文件打开错误，请检查文件路径"),MY_WARN));
        return;
    }
    try
    {
        //lastTaskIsFinish=false;
        lastTaskName="自动加工";

        DEV->vacuumSuckerOpen();
        DEV->VacuumBreakClose();
        semiAutoMachInSide();

        //connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(semiAutoMachFHandl()));
        //reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("半自动加工失败。",mye.getExceptCode()));
    }

}

void DeviceProxy::vacuumSuckerOpen()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行打开真空吸盘。请先初始化。"),MY_WARN));
        return;
    }


    try
    {
        vacuumSuckerOpenInSide();
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("真空吸盘打开失败。",mye.getExceptCode()));
    }

}

void DeviceProxy::vacuumSuckerClose()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行关闭真空吸盘。请先初始化。"),MY_WARN));
        return;
    }


    try
    {
        vacuumSuckerCloseInSide();
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("真空吸盘关闭失败。",mye.getExceptCode()));
    }

}

void DeviceProxy::laserOpen()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行打开激光器。请先初始化。"),MY_WARN));
        return;
    }

    try
    {
        int ret = IPGLASER->LaserOpen();
        if (ret < 0)
            throw MyException("激光器打开失败。",acsc_GetLastError());
        laserOpenInSide();
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("激光器打开失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::laserClose()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行关闭激光器。请先初始化。"),MY_WARN));
        return;
    }

    try
    {
        IPGLASER->LaserClose();
        laserCloseInSide();
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("激光器关闭失败。",mye.getExceptCode()));
    }
}

// 绿灯开
void DeviceProxy::greenLightOpen()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行该操作。请先初始化。"),MY_WARN));
        return;
    }


    try
    {
        //DEVICE_INFO->printDeviceSystemInfo("绿灯打开中...");
        char vname[] = ACSCTL_DO1_V;
        int do1 = acsCtl->getGlobalInt(vname);
        RS_SETTINGS->beginGroup("device/DO");
        QString greenLightDONumStr = RS_SETTINGS->readEntry("/greenLight");
        RS_SETTINGS->endGroup();

        int greenLightDONum = greenLightDONumStr.toInt();

        int mask = 1;
        mask = mask<<greenLightDONum;
        do1 = (do1|mask);
        acsCtl->setGlobalInt(vname,do1);
        DEVICE_INFO->printDeviceSystemInfo("绿灯打开完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("绿灯打开失败。",mye.getExceptCode()));
    }
}

// 绿灯关
void DeviceProxy::greenLightClose()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行该操作。请先初始化。"),MY_WARN));
        return;
    }

    try
    {
        //DEVICE_INFO->printDeviceSystemInfo("绿灯关闭中...");
        char vname[] = ACSCTL_DO1_V;
        int do1 = acsCtl->getGlobalInt(vname);
        RS_SETTINGS->beginGroup("device/DO");
        QString greenLightDONumStr = RS_SETTINGS->readEntry("/greenLight");
        RS_SETTINGS->endGroup();

        int greenLightDONum = greenLightDONumStr.toInt();

        int mask = 1;
        mask = mask<<greenLightDONum;
        mask = (~mask);
        do1 = (do1&mask);
        acsCtl->setGlobalInt(vname,do1);

        DEVICE_INFO->printDeviceSystemInfo("绿灯关闭完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("绿灯关闭失败。",mye.getExceptCode()));
    }
}

// 红灯开
void DeviceProxy::redLightOpen()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行该操作。请先初始化。"),MY_WARN));
        return;
    }

    try
    {
        //DEVICE_INFO->printDeviceSystemInfo("红灯打开中...");

        char vname[] = ACSCTL_DO1_V;
        int do1 = acsCtl->getGlobalInt(vname);
        RS_SETTINGS->beginGroup("device/DO");
        QString redLightDONumStr = RS_SETTINGS->readEntry("/redLight");
        RS_SETTINGS->endGroup();

        int redLightDONum = redLightDONumStr.toInt();

        int mask = 1;
        mask = mask<<redLightDONum;
        do1 = (do1|mask);
        acsCtl->setGlobalInt(vname,do1);
        //DEVICE_INFO->printDeviceSystemInfo("红灯打开完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("红灯打开失败。",mye.getExceptCode()));
    }
}

// 红灯关
void DeviceProxy::redLightClose()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行该操作。请先初始化。"),MY_WARN));
        return;
    }

    try
    {
        //DEVICE_INFO->printDeviceSystemInfo("红灯关闭中...");
        char vname[] = ACSCTL_DO1_V;
        int do1 = acsCtl->getGlobalInt(vname);
        RS_SETTINGS->beginGroup("device/DO");
        QString redLightDONumStr = RS_SETTINGS->readEntry("/redLight");
        RS_SETTINGS->endGroup();

        int redLightDONum = redLightDONumStr.toInt();

        int mask = 1;
        mask = mask<<redLightDONum;
        mask = (~mask);
        do1 = (do1&mask);
        acsCtl->setGlobalInt(vname,do1);
        //DEVICE_INFO->printDeviceSystemInfo("红灯关闭完成");

    }
    catch (MyException mye)
    {
        exceptHandl(MyException("红灯关闭失败。",mye.getExceptCode()));
    }
}

// 黄灯开
void DeviceProxy::yellowLightOpen()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行该操作。请先初始化。"),MY_WARN));
        return;
    }

    try
    {
        //DEVICE_INFO->printDeviceSystemInfo("黄灯打开中...");
        char vname[] = ACSCTL_DO1_V;
        int do1 = acsCtl->getGlobalInt(vname);
        RS_SETTINGS->beginGroup("device/DO");
        QString yellowLightDONumStr = RS_SETTINGS->readEntry("/yellowLight");
        RS_SETTINGS->endGroup();

        int yellowLightDONum = yellowLightDONumStr.toInt();

        int mask = 1;
        mask = mask<<yellowLightDONum;
        do1 = (do1|mask);
        acsCtl->setGlobalInt(vname,do1);
        //DEVICE_INFO->printDeviceSystemInfo("黄灯打开完成");

    }
    catch (MyException mye)
    {
        exceptHandl(MyException("黄灯打开失败。",mye.getExceptCode()));
    }
}

// 黄灯关
void DeviceProxy::yellowLightClose()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行该操作。请先初始化。"),MY_WARN));
        return;
    }

    try
    {
        //DEVICE_INFO->printDeviceSystemInfo("黄灯关闭中...");

        char vname[] = ACSCTL_DO1_V;
        int do1 = acsCtl->getGlobalInt(vname);
        RS_SETTINGS->beginGroup("device/DO");
        QString yellowLightDONumStr = RS_SETTINGS->readEntry("/yellowLight");
        RS_SETTINGS->endGroup();

        int yellowLightDONum = yellowLightDONumStr.toInt();

        int mask = 1;
        mask = mask<<yellowLightDONum;
        mask = (~mask);
        do1 = (do1&mask);
        acsCtl->setGlobalInt(vname,do1);

        //DEVICE_INFO->printDeviceSystemInfo("黄灯关闭完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("黄灯关闭失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::StopBtnOpen()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行该操作。请先初始化。"),MY_WARN));
        return;
    }

    try
    {
        //DEVICE_INFO->printDeviceSystemInfo("停止按钮状态开启中...");

        char vname[] = ACSCTL_DO1_V;
        int do1 = acsCtl->getGlobalInt(vname);
        RS_SETTINGS->beginGroup("device/DO");
        QString yellowLightDONumStr = RS_SETTINGS->readEntry("/stopBtn");
        RS_SETTINGS->endGroup();


        int yellowLightDONum = yellowLightDONumStr.toInt();

        int mask = 1;
        mask = mask<<yellowLightDONum;
        do1 = (do1|mask);
        acsCtl->setGlobalInt(vname,do1);

        DEVICE_INFO->printDeviceSystemInfo("停止按钮状态开启完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("停止按钮状态开启失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::StopBtnClose()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行该操作。请先初始化。"),MY_WARN));
        return;
    }

    try
    {
        //DEVICE_INFO->printDeviceSystemInfo("停止按钮状态关闭中...");

        char vname[] = ACSCTL_DO1_V;
        int do1 = acsCtl->getGlobalInt(vname);
        RS_SETTINGS->beginGroup("device/DO");
        QString yellowLightDONumStr = RS_SETTINGS->readEntry("/stopBtn");
        RS_SETTINGS->endGroup();

        int yellowLightDONum = yellowLightDONumStr.toInt();

        int mask = 1;
        mask = mask<<yellowLightDONum;
        mask = (~mask);
        do1 = (do1&mask);
        acsCtl->setGlobalInt(vname,do1);

        DEVICE_INFO->printDeviceSystemInfo("停止按钮状态关闭完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("停止按钮状态关闭失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::RunBtnOpen()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行该操作。请先初始化。"),MY_WARN));
        return;
    }

    try
    {
        //DEVICE_INFO->printDeviceSystemInfo("运行按钮状态开启中...");

        char vname[] = ACSCTL_DO1_V;
        int do1 = acsCtl->getGlobalInt(vname);
        RS_SETTINGS->beginGroup("device/DO");
        QString yellowLightDONumStr = RS_SETTINGS->readEntry("/runBtn");
        RS_SETTINGS->endGroup();

        int yellowLightDONum = yellowLightDONumStr.toInt();

        int mask = 1;
        mask = mask<<yellowLightDONum;
        do1 = (do1|mask);
        acsCtl->setGlobalInt(vname,do1);

        DEVICE_INFO->printDeviceSystemInfo("运行按钮状态开启完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("运行按钮状态开启失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::RunBtnClose()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行该操作。请先初始化。"),MY_WARN));
        return;
    }

    try
    {
        //DEVICE_INFO->printDeviceSystemInfo("运行按钮状态关闭中...");

        char vname[] = ACSCTL_DO1_V;
        int do1 = acsCtl->getGlobalInt(vname);
        RS_SETTINGS->beginGroup("device/DO");
        QString yellowLightDONumStr = RS_SETTINGS->readEntry("/runBtn");
        RS_SETTINGS->endGroup();

        int yellowLightDONum = yellowLightDONumStr.toInt();

        int mask = 1;
        mask = mask<<yellowLightDONum;
        mask = (~mask);
        do1 = (do1&mask);
        acsCtl->setGlobalInt(vname,do1);

        DEVICE_INFO->printDeviceSystemInfo("运行按钮状态关闭完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("运行按钮状态关闭失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::FanOpen()
{
    try
    {
        //DEVICE_INFO->printDeviceSystemInfo("漩涡风机开启中...");

        char vname[] = ACSCTL_DO1_V;
        int do1 = acsCtl->getGlobalInt(vname);
        RS_SETTINGS->beginGroup("device/DO");
        QString yellowLightDONumStr = RS_SETTINGS->readEntry("/fan");
        RS_SETTINGS->endGroup();

        int yellowLightDONum = yellowLightDONumStr.toInt();

        int mask = 1;
        mask = mask<<yellowLightDONum;
        do1 = (do1|mask);
        acsCtl->setGlobalInt(vname,do1);

        DEVICE_INFO->printDeviceSystemInfo("漩涡风机开启完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("漩涡风机开启失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::FanClose()
{
    try
    {
        DEVICE_INFO->printDeviceSystemInfo("漩涡风机关闭中...");

        char vname[] = ACSCTL_DO1_V;
        int do1 = acsCtl->getGlobalInt(vname);
        RS_SETTINGS->beginGroup("device/DO");
        QString yellowLightDONumStr = RS_SETTINGS->readEntry("/fan");
        RS_SETTINGS->endGroup();

        int yellowLightDONum = yellowLightDONumStr.toInt();

        int mask = 1;
        mask = mask<<yellowLightDONum;
        mask = (~mask);
        do1 = (do1&mask);
        acsCtl->setGlobalInt(vname,do1);

        DEVICE_INFO->printDeviceSystemInfo("漩涡风机关闭完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("漩涡风机关闭失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::LightOpen()//chkAirValve
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法控制照明灯。请先初始化。"),MY_WARN));
        return;
    }

    try
    {

        char vname[] = ACSCTL_DO2_V;
        int do1 = acsCtl->getGlobalInt(vname);
        RS_SETTINGS->beginGroup("device/DO");
        QString LightDoDONumStr = RS_SETTINGS->readEntry("/Light");
        RS_SETTINGS->endGroup();

        int yellowLightDONum = LightDoDONumStr.toInt();
        if (yellowLightDONum >= 8)
            yellowLightDONum = yellowLightDONum - 8;

        int mask = 1;
        mask = mask<<yellowLightDONum;
        do1 = (do1|mask);
        acsCtl->setGlobalInt(vname,do1);
        devLightingState = 1;
        //DEVICE_INFO->printDeviceSystemInfo("照明灯开启完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("照明灯开启失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::LightClose()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法操作照明灯。请先初始化。"),MY_WARN));
        return;
    }

    try
    {
        //DEVICE_INFO->printDeviceSystemInfo("相机光源关闭中...");

        char vname[] = ACSCTL_DO2_V;
        int do1 = acsCtl->getGlobalInt(vname);
        RS_SETTINGS->beginGroup("device/DO");
        QString yellowLightDONumStr = RS_SETTINGS->readEntry("/Light");
        RS_SETTINGS->endGroup();

        int yellowLightDONum = yellowLightDONumStr.toInt();

        if (yellowLightDONum >= 8)
            yellowLightDONum = yellowLightDONum - 8;

        int mask = 1;
        mask = mask<<yellowLightDONum;
        mask = (~mask);
        do1 = (do1&mask);
        acsCtl->setGlobalInt(vname,do1);
        devLightingState = 0;
        //DEVICE_INFO->printDeviceSystemInfo("气阀关闭完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("照明灯关闭失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::AirValveOpen()//chkAirValve
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法操作光学片气阀。请先初始化。"),MY_WARN));
        return;
    }

    try
    {

        char vname[] = ACSCTL_DO2_V;
        int do1 = acsCtl->getGlobalInt(vname);
        RS_SETTINGS->beginGroup("device/DO");
        QString AirValveDoDONumStr = RS_SETTINGS->readEntry("/AirValveDo");
        RS_SETTINGS->endGroup();

        int yellowLightDONum = AirValveDoDONumStr.toInt();
        if (yellowLightDONum >= 8)
            yellowLightDONum = yellowLightDONum - 8;

        int mask = 1;
        mask = mask<<yellowLightDONum;
        do1 = (do1|mask);
        acsCtl->setGlobalInt(vname,do1);

        DEVICE_INFO->printDeviceSystemInfo("光学片气阀开启完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("光学片气阀开启失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::AirValveClose()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法操作光学片气阀。请先初始化。"),MY_WARN));
        return;
    }

    try
    {
        //DEVICE_INFO->printDeviceSystemInfo("相机光源关闭中...");

        char vname[] = ACSCTL_DO2_V;
        int do1 = acsCtl->getGlobalInt(vname);
        RS_SETTINGS->beginGroup("device/DO");
        QString yellowLightDONumStr = RS_SETTINGS->readEntry("/AirValveDo");
        RS_SETTINGS->endGroup();

        int yellowLightDONum = yellowLightDONumStr.toInt();

        if (yellowLightDONum >= 8)
            yellowLightDONum = yellowLightDONum - 8;

        int mask = 1;
        mask = mask<<yellowLightDONum;
        mask = (~mask);
        do1 = (do1&mask);
        acsCtl->setGlobalInt(vname,do1);

        //DEVICE_INFO->printDeviceSystemInfo("气阀关闭完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("光学片气阀关闭失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::CuCeGaoOpen()//chkAirValve
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法操作粗测高头。请先初始化。"),MY_WARN));
        return;
    }

    try
    {

        char vname[] = ACSCTL_DO2_V;
        int do2 = acsCtl->getGlobalInt(vname);
        RS_SETTINGS->beginGroup("device/DO");
        QString AirValveDoDONumStr = RS_SETTINGS->readEntry("/CuCeGaoDo");
        RS_SETTINGS->endGroup();

        int yellowLightDONum = AirValveDoDONumStr.toInt();
        if (yellowLightDONum >= 8)
            yellowLightDONum = yellowLightDONum - 8;

        int mask = 1;
        mask = mask<<yellowLightDONum;
        do2 = (do2|mask);
        acsCtl->setGlobalInt(vname,do2);

        DEVICE_INFO->printDeviceSystemInfo("粗测高头收回完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("粗测高头收回失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::CuCeGaoClose()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法操作粗测高头。请先初始化。"),MY_WARN));
        return;
    }

    try
    {
        //DEVICE_INFO->printDeviceSystemInfo("相机光源关闭中...");

        char vname[] = ACSCTL_DO2_V;
        int do2 = acsCtl->getGlobalInt(vname);
        RS_SETTINGS->beginGroup("device/DO");
        QString yellowLightDONumStr = RS_SETTINGS->readEntry("/CuCeGaoDo");
        RS_SETTINGS->endGroup();

        int yellowLightDONum = yellowLightDONumStr.toInt();

        if (yellowLightDONum >= 8)
            yellowLightDONum = yellowLightDONum - 8;

        int mask = 1;
        mask = mask<<yellowLightDONum;
        mask = (~mask);
        do2 = (do2&mask);
        acsCtl->setGlobalInt(vname,do2);

        //DEVICE_INFO->printDeviceSystemInfo("气阀关闭完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("粗测高头伸出失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::Pin18Open()//chkAirValve
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法操作Pin引脚。请先初始化。"),MY_WARN));
        return;
    }

    try
    {

        char vname[] = ACSCTL_DO2_V;
        int do2 = acsCtl->getGlobalInt(vname);
        RS_SETTINGS->beginGroup("device/DO");
        QString AirValveDoDONumStr = RS_SETTINGS->readEntry("/Pin18Do");
        RS_SETTINGS->endGroup();

        int yellowLightDONum = AirValveDoDONumStr.toInt();
        if (yellowLightDONum >= 8)
            yellowLightDONum = yellowLightDONum - 8;

        int mask = 1;
        mask = mask<<yellowLightDONum;
        do2 = (do2|mask);
        acsCtl->setGlobalInt(vname,do2);

        DEVICE_INFO->printDeviceSystemInfo("Pin引脚开启完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Pin引脚开启失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::Pin18Close()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法操作Pin引脚。请先初始化。"),MY_WARN));
        return;
    }

    try
    {
        //DEVICE_INFO->printDeviceSystemInfo("相机光源关闭中...");

        char vname[] = ACSCTL_DO2_V;
        int do2 = acsCtl->getGlobalInt(vname);
        RS_SETTINGS->beginGroup("device/DO");
        QString yellowLightDONumStr = RS_SETTINGS->readEntry("/Pin18Do");
        RS_SETTINGS->endGroup();

        int yellowLightDONum = yellowLightDONumStr.toInt();

        if (yellowLightDONum >= 8)
            yellowLightDONum = yellowLightDONum - 8;

        int mask = 1;
        mask = mask<<yellowLightDONum;
        mask = (~mask);
        do2 = (do2&mask);
        acsCtl->setGlobalInt(vname,do2);

        //DEVICE_INFO->printDeviceSystemInfo("气阀关闭完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Pin引脚关闭失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::AirValveOpen2()//chkAirValve
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法操作气阀。请先初始化。"),MY_WARN));
        return;
    }
    try
    {

        char vname[] = ACSCTL_DO2_V;
        int do1 = acsCtl->getGlobalInt(vname);
        RS_SETTINGS->beginGroup("device/DO");
        QString AirValveDoDONumStr = RS_SETTINGS->readEntry("/AirValveDo2");
        RS_SETTINGS->endGroup();

        int yellowLightDONum = AirValveDoDONumStr.toInt();
        if (yellowLightDONum >= 8)
            yellowLightDONum = yellowLightDONum - 8;

        int mask = 1;
        mask = mask<<yellowLightDONum;
        do1 = (do1|mask);
        acsCtl->setGlobalInt(vname,do1);

        //DEVICE_INFO->printDeviceSystemInfo("气阀开启完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("整形片伸出失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::AirValveClose2()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法操作气阀。请先初始化。"),MY_WARN));
        return;
    }
    try
    {
        //DEVICE_INFO->printDeviceSystemInfo("相机光源关闭中...");

        char vname[] = ACSCTL_DO2_V;
        int do1 = acsCtl->getGlobalInt(vname);
        RS_SETTINGS->beginGroup("device/DO");
        QString yellowLightDONumStr = RS_SETTINGS->readEntry("/AirValveDo2");
        RS_SETTINGS->endGroup();

        int yellowLightDONum = yellowLightDONumStr.toInt();

        if (yellowLightDONum >= 8)
            yellowLightDONum = yellowLightDONum - 8;

        int mask = 1;
        mask = mask<<yellowLightDONum;
        mask = (~mask);
        do1 = (do1&mask);
        acsCtl->setGlobalInt(vname,do1);

        //DEVICE_INFO->printDeviceSystemInfo("气阀关闭完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("整形片收回失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::VacuumBreakOpen()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行打开真空吸盘。请先初始化。"),MY_WARN));
        return;
    }

    try
    {
        //DEVICE_INFO->printDeviceSystemInfo("相机光源开启中...");

        char vname[] = ACSCTL_DO2_V;
        int do1 = acsCtl->getGlobalInt(vname);
        RS_SETTINGS->beginGroup("device/DO");
        QString yellowLightDONumStr = RS_SETTINGS->readEntry("/Vacuumbreak");
        RS_SETTINGS->endGroup();

        int yellowLightDONum = yellowLightDONumStr.toInt();
        if (yellowLightDONum == 8)
            yellowLightDONum = 0;

        int mask = 1;
        mask = mask<<yellowLightDONum;
        do1 = (do1|mask);
        acsCtl->setGlobalInt(vname,do1);

        DEVICE_INFO->printDeviceSystemInfo("破真空开启完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("破真空开启失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::VacuumBreakClose()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行打开真空吸盘。请先初始化。"),MY_WARN));
        return;
    }

    try
    {
        //DEVICE_INFO->printDeviceSystemInfo("相机光源关闭中...");

        char vname[] = ACSCTL_DO2_V;
        int do1 = acsCtl->getGlobalInt(vname);
        RS_SETTINGS->beginGroup("device/DO");
        QString yellowLightDONumStr = RS_SETTINGS->readEntry("/Vacuumbreak");
        RS_SETTINGS->endGroup();

        int yellowLightDONum = yellowLightDONumStr.toInt();

        if (yellowLightDONum == 8)
            yellowLightDONum = 0;

        int mask = 1;
        mask = mask<<yellowLightDONum;
        mask = (~mask);
        do1 = (do1&mask);
        acsCtl->setGlobalInt(vname,do1);

        DEVICE_INFO->printDeviceSystemInfo("破真空关闭完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("破真空关闭失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::setLight()
{
    int newDevLightState;
    int newRunStopBtnState;
    if(!devIsInit)
    {
        devLightState = 0;
        return;
    }

    if (devIsAlarm)
    {
        newDevLightState = 1;
        //        redLightOpen();
        //        yellowLightClose();
        //        greenLightClose();
    }
    else if(!devIsReset)
    {
        newDevLightState = 2;
        //        redLightOpen();
        //        yellowLightClose();
        //        greenLightClose();
    }
    else if ((devIsReset && !lastTaskIsFinish) || (bRunning))
    {
        newDevLightState = 2;
        //        redLightClose();
        //        yellowLightClose();
        //        greenLightOpen();
    }
    else
    {
        newDevLightState = 3;
        //        redLightClose();
        //        yellowLightOpen();
        //        greenLightClose();
    }
    if (newDevLightState != devLightState)
    {
        devLightState = newDevLightState;
        switch(devLightState){
        case 1:
            redLightOpen();
            yellowLightClose();
            greenLightClose();
            break;
        case 2:
            redLightClose();
            yellowLightClose();
            greenLightOpen();
            break;
        case 3:
            redLightClose();
            yellowLightOpen();
            greenLightClose();
            break;
        default:
            break;
        }
    }
    if (bRunning)
        newRunStopBtnState = 1;
    else
        newRunStopBtnState = 0;
    if (newRunStopBtnState != devRunStopBtnState)
    {
        devRunStopBtnState = newRunStopBtnState;
        if (devRunStopBtnState == 1)
        {
            RunBtnOpen();
            StopBtnClose();
        }
        else
        {
            RunBtnClose();
            StopBtnOpen();
        }
    }

    return;
}


void DeviceProxy::enableXAxis()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行使能X轴。请先初始化。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("X轴使能中...");
        acsCtl->enable(XAXIS);
        DEVICE_INFO->printDeviceSystemInfo("X轴使能完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("X轴使能失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::enableYAxis()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行使能Y轴。请先初始化。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Y轴使能中...");
        acsCtl->enable(YAXIS);
        DEVICE_INFO->printDeviceSystemInfo("Y轴使能完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Y轴使能失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::enableZAxis()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行使能Z1轴。请先初始化。"),MY_WARN));
        return;
    }
    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Z1轴使能中...");
        acsCtl->enable(ZAXIS);
        DEVICE_INFO->printDeviceSystemInfo("Z1轴使能完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z1轴使能失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::enableZAAxis()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行使能Z轴。请先初始化。"),MY_WARN));
        return;
    }
    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Z轴使能中...");
        acsCtl->enable(ZAAXIS);
        DEVICE_INFO->printDeviceSystemInfo("Z轴使能完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z轴使能失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::disableXAxis()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行取消X轴使能。请先初始化。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行取消X轴使能。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("X轴取消使能中...");
        lastTaskIsFinish=false;
        lastTaskName="X轴取消使能";
        acsCtl->disable(XAXIS);
        DEVICE_INFO->printDeviceSystemInfo("X轴取消使能完成");
        lastTaskIsFinish=true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("X轴取消使能失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::disableYAxis()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行取消Y轴使能。请先初始化。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行取消Y轴使能。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Y轴取消使能中...");
        lastTaskIsFinish=false;
        lastTaskName="Y轴取消使能";
        acsCtl->disable(YAXIS);
        DEVICE_INFO->printDeviceSystemInfo("Y轴取消使能完成");
        lastTaskIsFinish=true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Y轴取消使能失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::disableZAxis()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行取消Z1轴使能。请先初始化。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行取消Z1轴使能。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Z1轴取消使能中...");
        lastTaskIsFinish=false;
        lastTaskName="Z1轴取消使能";
        acsCtl->disable(ZAXIS);
        DEVICE_INFO->printDeviceSystemInfo("Z1轴取消使能完成");
        lastTaskIsFinish=true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z1轴取消使能失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::disableZAAxis()
{   
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行取消Z轴使能。请先初始化。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行取消Z轴使能。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Z轴取消使能中...");
        lastTaskIsFinish=false;
        lastTaskName="Z轴取消使能";
        acsCtl->disable(ZAAXIS);
        DEVICE_INFO->printDeviceSystemInfo("Z轴取消使能完成");
        lastTaskIsFinish=true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z轴取消使能失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::enableDAxis()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行使能Z轴。请先初始化。"),MY_WARN));
        return;
    }
    try
    {
        DEVICE_INFO->printDeviceSystemInfo("DD马达使能中...");
        acsCtl->enable(DAXIS);
        DEVICE_INFO->printDeviceSystemInfo("DD马达使能完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("DD马达使能失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::enableZ0Axis()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行使能Z轴。请先初始化。"),MY_WARN));
        return;
    }
    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Z0轴使能中...");
        acsCtl->enable(Z0AXIS);
        DEVICE_INFO->printDeviceSystemInfo("Z0轴使能完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z0轴使能失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::enableZ2Axis()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行使能Z轴。请先初始化。"),MY_WARN));
        return;
    }
    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Z2轴使能中...");
        acsCtl->enable(Z2AXIS);
        DEVICE_INFO->printDeviceSystemInfo("Z2轴使能完成");
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z2轴使能失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::disableDAxis()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行取消DD马达使能。请先初始化。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行取消DD马达使能。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("DD马达取消使能中...");
        lastTaskIsFinish=false;
        lastTaskName="DD马达取消使能";
        acsCtl->disable(DAXIS);
        DEVICE_INFO->printDeviceSystemInfo("DD马达取消使能完成");
        lastTaskIsFinish=true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("DD马达取消使能失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::disableZ0Axis()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行取消Z0轴使能。请先初始化。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行取消Z0轴使能。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Z0轴取消使能中...");
        lastTaskIsFinish=false;
        lastTaskName="Z0轴取消使能";
        acsCtl->disable(Z0AXIS);
        DEVICE_INFO->printDeviceSystemInfo("Z0轴取消使能完成");
        lastTaskIsFinish=true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z0轴取消使能失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::disableZ2Axis()
{
    if(!devIsInit)
    {
        emit exceptSGL(MyException(QString("设备未初始化，无法执行取消Z2轴使能。请先初始化。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行取消Z2轴使能。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("Z2轴取消使能中...");
        lastTaskIsFinish=false;
        lastTaskName="Z2轴取消使能";
        acsCtl->disable(Z2AXIS);
        DEVICE_INFO->printDeviceSystemInfo("Z2轴取消使能完成");
        lastTaskIsFinish=true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("Z2轴取消使能失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::enableDisableXAxis()
{
    if(XAxisIsEnable)
        disableXAxis();
    else
        enableXAxis();
}
void DeviceProxy::enableDisableYAxis()
{
    if(YAxisIsEnable)
        disableYAxis();
    else
        enableYAxis();
}
void DeviceProxy::enableDisableZAxis()
{
    if(ZAxisIsEnable)
        disableZAxis();
    else
        enableZAxis();
}
void DeviceProxy::enableDisableZAAxis()
{
    if(ZAAxisIsEnable)
        disableZAAxis();
    else
        enableZAAxis();
}
void DeviceProxy::enableDisableDAxis()
{
    if(DAxisIsEnable)
        disableDAxis();
    else
        enableDAxis();
}
void DeviceProxy::enableDisableZ0Axis()
{
    if(Z0AxisIsEnable)
        disableZ0Axis();
    else
        enableZ0Axis();
}
void DeviceProxy::enableDisableZ2Axis()
{
    if(Z2AxisIsEnable)
        disableZ2Axis();
    else
        enableZ2Axis();
}
void DeviceProxy::setAxisState()
{
    XAxisLimitState = NORMAL;
    YAxisLimitState = NORMAL;
    ZAxisLimitState = NORMAL;
    ZAAxisLimitState = NORMAL;
    XAxisIsEnable = false;
    YAxisIsEnable = false;
    ZAxisIsEnable = false;
    ZAAxisIsEnable = false;
}
void DeviceProxy::startStateDetection()
{
    timer->start();
}

void DeviceProxy::stopStateDetection()
{
    timer->stop();
}

void DeviceProxy::detectionAllAxisCtPos()
{
    XAxisCtPos = acsCtl->getFPOS(XAXIS);
    emit XAxisCtPosSGL(XAxisCtPos);

    YAxisCtPos = acsCtl->getFPOS(YAXIS);
    emit YAxisCtPosSGL(YAxisCtPos);

    //lihongchang
    ZAxisCtPos = acsCtl->getFPOS(ZAXIS);
    emit ZAxisCtPosSGL(ZAxisCtPos);

    ZAAxisCtPos = acsCtl->getFPOS(ZAAXIS);
    emit ZAAxisCtPosSGL(ZAAxisCtPos);

    Z0AxisCtPos = acsCtl->getFPOS(Z0AXIS);
    emit Z0AxisCtPosSGL(Z0AxisCtPos);

    Z2AxisCtPos = acsCtl->getFPOS(Z2AXIS);
    emit Z2AxisCtPosSGL(Z2AxisCtPos);

    DAxisCtPos = acsCtl->getFPOS(DAXIS);
    emit DAxisCtPosSGL(DAxisCtPos);
}


void DeviceProxy::detectionAllAxisLimitState()
{
    QVector<LIMIT_STATE> state;
    if (!bUserPower) return;
    LIMIT_STATE XAxisLimitStateTemp = NORMAL;
    LIMIT_STATE YAxisLimitStateTemp = NORMAL;
    LIMIT_STATE ZAxisLimitStateTemp = NORMAL;
    LIMIT_STATE ZAAxisLimitStateTemp = NORMAL;
    LIMIT_STATE Z0AxisLimitStateTemp = NORMAL;
    LIMIT_STATE Z2AxisLimitStateTemp = NORMAL;
    LIMIT_STATE DAxisLimitStateTemp = NORMAL;


    XAxisLimitStateTemp = acsCtl->getAxesLimitState(XAXIS);
    YAxisLimitStateTemp = acsCtl->getAxesLimitState(YAXIS);
    ZAxisLimitStateTemp = acsCtl->getAxesLimitState(ZAXIS);
    ZAAxisLimitStateTemp = acsCtl->getAxesLimitState(ZAAXIS);
    Z0AxisLimitStateTemp = acsCtl->getAxesLimitState(Z0AXIS);
    Z2AxisLimitStateTemp = acsCtl->getAxesLimitState(Z2AXIS);
    DAxisLimitStateTemp = acsCtl->getAxesLimitState(DAXIS);

    if(XAxisLimitStateTemp != XAxisLimitState)
    {
        XAxisLimitState = XAxisLimitStateTemp;
        emit XAxisLimitStateSGL(XAxisLimitStateTemp);
    }

    if(YAxisLimitStateTemp != YAxisLimitState)
    {
        YAxisLimitState = YAxisLimitStateTemp;
        emit YAxisLimitStateSGL(YAxisLimitStateTemp);
    }

    if(ZAxisLimitStateTemp != ZAxisLimitState)
    {
        ZAxisLimitState = ZAxisLimitStateTemp;
        emit ZAxisLimitStateSGL(ZAxisLimitStateTemp);
    }

    if(ZAAxisLimitStateTemp != ZAAxisLimitState)
    {
        ZAAxisLimitState = ZAAxisLimitStateTemp;
        emit ZAAxisLimitStateSGL(ZAAxisLimitStateTemp);
    }

    if(Z0AxisLimitStateTemp != Z0AxisLimitState)
    {
        Z0AxisLimitState = Z0AxisLimitStateTemp;
        emit DDLimitStateSGL(1,Z0AxisLimitStateTemp);
    }

    if(Z2AxisLimitStateTemp != Z2AxisLimitState)
    {
        Z2AxisLimitState = Z2AxisLimitStateTemp;
        emit DDLimitStateSGL(2,Z2AxisLimitStateTemp);
    }

    if(DAxisLimitStateTemp != DAxisLimitState)
    {
        DAxisLimitState = DAxisLimitStateTemp;
        emit DDLimitStateSGL(0,DAxisLimitStateTemp);
    }
}


void DeviceProxy::detectionAllAxisEnableState()
{
    bool enabaleState;
    if (!bUserPower) return;

    enabaleState = acsCtl->getEnable(XAXIS);
    if(enabaleState!=XAxisIsEnable)
    {
        XAxisIsEnable = enabaleState;
        emit XAxisEnableStateSGL(enabaleState);
    }

    enabaleState = acsCtl->getEnable(YAXIS);
    if(enabaleState!=YAxisIsEnable)
    {
        YAxisIsEnable = enabaleState;
        emit YAxisEnableStateSGL(enabaleState);
    }

    //lihongchang
    enabaleState = acsCtl->getEnable(ZAXIS);
    if(enabaleState!=ZAxisIsEnable)
    {
        ZAxisIsEnable = enabaleState;
        emit ZAxisEnableStateSGL(enabaleState);
    }

    enabaleState = acsCtl->getEnable(ZAAXIS);
    if(enabaleState!=ZAAxisIsEnable)
    {
        ZAAxisIsEnable = enabaleState;
        emit ZAAxisEnableStateSGL(enabaleState);
    }

    bool enabaleState1 = acsCtl->getEnable(Z0AXIS);
    bool enabaleState2 = acsCtl->getEnable(Z2AXIS);
    bool enabaleState0 = acsCtl->getEnable(DAXIS);
    if((enabaleState0!=DAxisIsEnable) || (enabaleState1!=Z0AxisIsEnable) || (enabaleState2!=Z2AxisIsEnable))
    {
        DAxisIsEnable = enabaleState0;
        Z0AxisIsEnable = enabaleState1;
        Z2AxisIsEnable = enabaleState2;
        int value = enabaleState0 + (enabaleState1 << 1) + (enabaleState2 << 2);
        emit DDEnableStateSGL(value);
    }

}


void DeviceProxy::detectionEStopState()
{
    bool bRet;
    bRet = acsCtl->getEmergencyStopState();
    if (bRet != devEStopState)
    {
        devEStopState = bRet;
        if (bRet)
        {
            //关激光
            laserClose();
            pLaserMark->Abort();
            devIsReset = false;
            lastTaskIsFinish = true;
            reqCMDRunFState = false;
            if (bRunning)
            {
                mutex.lock();
                bRunning = false;
                mutex.unlock();
                emit RunSGL(!bRunning);
            }
        }

        emit EStopSGL(bRet);
        return;
    }

    emit EStopSGL(bRet);
}


void DeviceProxy::detectionCMDRunFState()
{
    char vName[] = ACSCTL_RUNF_V;
    if(acsCtl->getGlobalInt(vName))
    {
        reqCMDRunFState = false;
        if (!bRunning)
            emit CMDRunFinishSGL();
    }
}

void DeviceProxy::detectionRCValue()
{
    char vName[] = ACSCTL_RSVALUE_V;
    double value = acsCtl->getGlobalReal(vName);
    emit RSValueChangedSGL(value);
}
void DeviceProxy::detectionLaserValue()
{
    char vname[] = ACSCTL_DO1_V;
    int do1 = acsCtl->getGlobalInt(vname);
    int mask;

    mask = 1;
    mask = mask<<devLaserNum;
    mask = (do1&mask);
    if(mask)
    {
        emit laserOpenFSGL();
        if (devLaserState == 0)
        {
            if (JIADINGJIAGONG != 1)
                IPGLASER->LaserOpen();  //lihongchang jia
        }
        devLaserState = 1;
    }
    else
    {
        emit laserCloseFSGL();
        if (devLaserState == 1)
        {
            if (JIADINGJIAGONG != 1)
                IPGLASER->LaserClose();  //lihongchang jia
        }
        devLaserState = 0;
    }
    mask = 1;
    mask = mask<<airValveDoNum;
    mask = (do1&mask);
    if(mask)
    {
        airValveDoSts = 1;
    }
    else
    {
        airValveDoSts = 0;
    }
    mask = 1;
    mask = mask<<airValveDoNum2;
    mask = (do1&mask);
    if(mask)
    {
        airValveDoSts2 = 1;
    }
    else
    {
        airValveDoSts2 = 0;
    }
    if (devLaserOpenTime < 5000)
    {
        devLaserOpenTime++;
        if (JIADINGJIAGONG != 1)
        {
            if (devLaserOpenTime <= 1800)
                StepNameSGL(devLaserOpenTime + 10000);
        }
        else
        {
            if (devLaserOpenTime <= 180)   //lihongchang jia
                StepNameSGL(devLaserOpenTime + 10000);
        }

    }


}
void DeviceProxy::detectionInState()
{
    //    char vname[] = ACSCTL_DI1_V;
    //    int di1 = acsCtl->getGlobalInt(vname);
    //    char vname2[] = ACSCTL_DI2_V;
    //    int di2 = acsCtl->getGlobalInt(vname2);

    //    emit InStateSGL(di1);


    char vname[] = ACSCTL_DI1_V;
    int di1 = acsCtl->getGlobalInt(vname);
    di1 = di1 & 0xff;
    char vname2[] = ACSCTL_DI2_V;
    int di2 = acsCtl->getGlobalInt(vname2);
    di2 = di2 & 0xff;
    di1 = (di2 << 8) | di1;

    emit InStateSGL(di1);

    int mask = 1;
    mask = mask<<runBtnDINum;
    mask = (di1&mask);
    if(mask)
        lRunStopTime[0]++;
    else
        lRunStopTime[0] = 0;
    if (lRunStopTime[0] >= 10)
        if (!bRunning)
        {
            lRunStopTime[0] = 0;
            if (!bRunning)
            {
                emit GetRunTypeState();
                semiAutoMach();
            }
        }
    mask = 1;
    mask = mask<<stopBtnDINum;
    mask = (di1&mask);
    if(mask)
        lRunStopTime[1]++;
    else
        lRunStopTime[1] = 0;
    if (lRunStopTime[1] >= 1)
        //if (bRunning)
    {
        lRunStopTime[1] = 0;
        stop();
        DEVICE_INFO->printDeviceSystemInfo("面板停止按钮按下！");
        //            if (DEV->SuspendFlag)
        //                DEV->SuspendFlag = false;
        //            else
        //                DEV->SuspendFlag = true;
        //            emit DEV->StopStateSGL(!DEV->SuspendFlag);
    }

    mask = 1;
    mask = mask<<estopBtnDINum;
    mask = (di1&mask);
    if(!mask)
        lRunStopTime[1]++;
    else
        lRunStopTime[1] = 0;
    if (lRunStopTime[1] >= 1)
        //if (bRunning)
    {
        lRunStopTime[1] = 0;
        stop();
        devIsReset = false;
        devIsInit = false;
        emit DEVInitStateChangedSGL(devIsInit && devIsReset);
        stopStateDetection();
        emit exceptSGL(MyException(QString("急停按钮按下！"),MY_WARN));
    }

    int mask1 = 1;
    int mask2 = 1;
    mask1 = mask1<<door1DINum;
    mask2 = mask2<<door2DINum;
    mask1 = (di1&mask1);
    mask2 = (di1&mask2);
    if(mask1 || mask2)
    {
        //        if ((bRunning) )
        //        {
        //            stop();
        //            emit exceptSGL(MyException(QString("设备运行中，不能打开机台门，注意安全"),MY_WARN));
        //        }
        if (devLightingState == 0)
        {
            DEV->LightOpen();
        }

    }
    else
    {
        if (devLightingState == 1)
        {
            DEV->LightClose();
        }

    }



    //    mask = 1;
    //    mask = mask<<AllPressureDINum;
    //    mask = (di1&mask);
    //    if(!mask)
    //        lRunStopTime[1]++;
    //    else
    //        lRunStopTime[1] = 0;
    //    if (lRunStopTime[1] >= 1)
    //        //if (bRunning)
    //        {
    //            lRunStopTime[1] = 0;
    //            stop();
    //            emit exceptSGL(MyException(QString("总气压过低"),MY_WARN));
    //        }

    //    mask = 1;
    //    mask = mask<<FanPressureDINum;
    //    mask = (di1&mask);
    //    if(!mask)
    //        lRunStopTime[1]++;
    //    else
    //        lRunStopTime[1] = 0;
    //    if (lRunStopTime[1] >= 1)
    //        //if (bRunning)
    //        {
    //            lRunStopTime[1] = 0;
    //            stop();
    //            emit exceptSGL(MyException(QString("风机气压过低"),MY_WARN));
    //        }

    // 自动运行各大步骤之间可以暂停。检查激光功率时，停止30秒后再读数，pid控制功率衰减器时，用增量模式
    //
    //
    //
    //
}
void DeviceProxy::resetFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(resetFHandl()));
    getResetState();
    devIsReset = true;
    //emit DEVResetStateChangedSGL(devIsReset);
    emit DEVInitStateChangedSGL(devIsInit && devIsReset);
    DEVICE_INFO->printDeviceSystemInfo("复位完成");
    lastTaskIsFinish=true;
}

void DeviceProxy::XAxisSMoveNFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(XAxisSMoveNFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("X轴负向点动完成");
    lastTaskIsFinish=true;
}

void DeviceProxy::XAxisSMovePFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(XAxisSMovePFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("X轴正向点动完成");
    lastTaskIsFinish=true;
}

void DeviceProxy::YAxisSMoveNFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(YAxisSMoveNFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("Y轴负向点动完成");
    lastTaskIsFinish=true;
}

void DeviceProxy::YAxisSMovePFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(YAxisSMovePFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("Y轴正向点动完成");
    lastTaskIsFinish=true;
}

void DeviceProxy::ZAxisSMoveNFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(ZAxisSMoveNFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("Z1轴负向点动完成");
    lastTaskIsFinish=true;
}

void DeviceProxy::ZAxisSMovePFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(ZAxisSMovePFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("Z1轴正向点动完成");
    lastTaskIsFinish=true;
}

void DeviceProxy::ZAAxisSMoveNFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(ZAAxisSMoveNFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("Z轴负向点动完成");
    lastTaskIsFinish=true;
}

void DeviceProxy::ZAAxisSMovePFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(ZAAxisSMovePFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("Z轴正向点动完成");
    lastTaskIsFinish=true;
}

void DeviceProxy::DAxisSMoveNFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(DAxisSMoveNFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("DD马达负向点动完成");
    lastTaskIsFinish=true;
}
void DeviceProxy::DAxisSMovePFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(DAxisSMovePFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("DD马达正向点动完成");
    lastTaskIsFinish=true;
}
void DeviceProxy::Z2AxisSMoveNFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(Z2AxisSMoveNFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("Z2轴负向点动完成");
    lastTaskIsFinish=true;
}
void DeviceProxy::Z2AxisSMovePFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(Z2AxisSMovePFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("Z2轴正向点动完成");
    lastTaskIsFinish=true;
}
void DeviceProxy::Z0AxisSMoveNFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(Z0AxisSMoveNFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("Z0轴负向点动完成");
    lastTaskIsFinish=true;
}
void DeviceProxy::Z0AxisSMovePFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(Z0AxisSMovePFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("Z0轴正向点动完成");
    lastTaskIsFinish=true;
}

void DeviceProxy::ABSMoveFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(ABSMoveFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("绝对定位完成");
    lastTaskIsFinish=true;
}

void DeviceProxy::toLoadAndUnloadPosFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toLoadAndUnloadPosFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("到上下料位置完成");
    lastTaskIsFinish=true;
}
void DeviceProxy::toGlobalCameraPosFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toGlobalCameraPosFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("到全局相机位置完成");
    lastTaskIsFinish=true;
}
void DeviceProxy::toSScanStartPosFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toSScanStartPosFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("到扫描起始位完成");
    lastTaskIsFinish=true;
}

void DeviceProxy::toRSToZeroPosFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toRSToZeroPosFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("到对零位完成");
    lastTaskIsFinish=true;
}
void DeviceProxy::toLaserApTestPosFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toLaserApTestPosFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("到功率测量位完成");
    lastTaskIsFinish=true;
}
void DeviceProxy::toLaserMarkPosFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toLaserMarkPosFHandl()));
    char *code;
    QByteArray byCode = DEV->strLaserMark_test.toLatin1();
    code = byCode.data();
    memset(MODBUSTCP->RFID,0,50);
    memcpy_s(MODBUSTCP->RFID,50,code,strlen(code));
    if (DEV->pLaserMark != nullptr)
    {
        DEV->pLaserMark->SetFontParam(laserMarkHeight, laserMarkWidth, laserMarkInternal, laserMarkFrequency,laserMarkPulseWidth); //字符高度 字体宽度 字体间距 频率 脉宽
        DEV->pLaserMark->Start(MODBUSTCP->RFID,&DEV->strLaserMark_test,1,false);//"4H04-AB023"
    }
    DEVICE_INFO->printDeviceSystemInfo("打标完成");
    lastTaskIsFinish=true;
}
void DeviceProxy::toHeightFindPosFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toHeightFindPosFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("到测高位完成");
    lastTaskIsFinish=true;
}
void DeviceProxy::toEdgeSearchPosFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toEdgeSearchPosFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("到寻边位完成");
    lastTaskIsFinish=true;
}
void DeviceProxy::toCompenTestPosFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toCompenTestPosFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("到上料准备位完成");
    lastTaskIsFinish=true;
}
void DeviceProxy::toRecordPosFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toRecordPosFHandl()));
    RS_SETTINGS->beginGroup("device/ZAAxisSafe");
    double ZAAxisSafePos = RS_SETTINGS->readNumEntry("/pos");
    RS_SETTINGS->endGroup();
    RS_SETTINGS->beginGroup("device/RecordPos");
    RS_SETTINGS->writeEntry("/XAxis", 0);
    RS_SETTINGS->writeEntry("/YAxis", 0);
    RS_SETTINGS->writeEntry("/ZAAxis",ZAAxisSafePos);
    RS_SETTINGS->endGroup();
    DEVICE_INFO->printDeviceSystemInfo("到记录位完成");
    lastTaskIsFinish=true;
}

void DeviceProxy::toZAAxisCPosFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toZAAxisCPosFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("到Z轴常用位置完成");
    lastTaskIsFinish=true;
}

void DeviceProxy::MHToCameraFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(MHToCameraFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("加工头到相机位置完成");
    lastTaskIsFinish=true;
}

void DeviceProxy::CameraToMHFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(CameraToMHFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("相机到加工头位置完成");
    lastTaskIsFinish=true;
}

void DeviceProxy::RHToCameraFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(RHToCameraFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("测距头到相机位置完成");
    lastTaskIsFinish=true;
}

void DeviceProxy::CameraToRHFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(CameraToRHFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("相机到测距头位置完成");
    lastTaskIsFinish=true;
}

void DeviceProxy::RHToMHFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(RHToMHFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("测距头到加工头位置完成");
    lastTaskIsFinish=true;
}

void DeviceProxy::MHToRHFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(RHToMHFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("加工头到测距头位置完成");
    lastTaskIsFinish=true;
}


void DeviceProxy::RSToZeroFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(RSToZeroFHandl()));
    workpieceHeight = ZAAxisCtPos - ZAxisCtPos;
    DEVICE_INFO->printDeviceSystemInfo("测距传感器对零完成");
    lastTaskIsFinish=true;
}

void DeviceProxy::MachSmallAreaFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(MachSmallAreaFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("特定区域加工完成");
    lastTaskIsFinish=true;
}

void DeviceProxy::SScanFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(SScanFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("面扫描完成");
    lastTaskIsFinish=true;
}

void DeviceProxy::compSScanFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(compSScanFHandl()));
    bool motorsts;
    while(1)
    {

        motorsts = acsCtl->getMotorState(XAXIS);
        if (motorsts)
            break;
        Sleep(5);
    }
    try
    {
        readCompSScanData();
        //saveCompSScanData();
        //buildLookupTable();
        // 保存原始查找表的数据
        //saveLookupTable();
        // 判断查找表的值是否都超上下限
        // 如果都超则补偿失败
        //SScanDataCheck();
        //lookupTableHeadEndDataHandl();
        //saveLookupTable();


        //        DEV->readCompSScanData();

        //        DEV->buildLookupTable();
        //        DEV->saveLookupTable();
        //        QVector<QVector<double>>().swap(DEV->lookupTable);
        //        DEV->buildLookupTable_lhc();
        //        //mParent->saveLookupTable_lhc();
        //        DEV->SScanDataCheck();
        //        DEV->lookupTableHeadEndDataHandl();
        //        //mParent->saveLookupTable_lhc();
        //        DEV->lookupTableHeadEndDataHandl_lhc2();
        //        DEV->saveLookupTable_lhc();



        buildLookupTable2();//
        saveLookupTable();//

        //SScanDataCheck();//
        //lookupTableHeadEndDataHandl_lhc();//

        //saveLookupTable();//

        /********************************************************/

        QVector<QVector<double>>().swap(lookupTable);
        buildLookupTable_lhc2();//
        //saveLookupTable_lhc();//


        SScanDataCheck();//lihongchang
        lookupTableHeadEndDataHandl();
        //lookupTableHeadEndDataHandl_lhc();//

        //saveLookupTable_lhc();//
        lookupTableHeadEndDataHandl_lhc2();
        saveLookupTable_lhc();//




        //测试
        //saveLookupTable();
        SScanDataCheck_lhc();
        //开启加工头补偿
        MHCompOpenInSide();
        DEV->devPlaneScanCompState = 1;
        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(CSS_MHCompOpenFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException(mye.getExceptInfo(),mye.getExceptCode()));
    }
}

void DeviceProxy::CSS_MHCompOpenFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(CSS_MHCompOpenFHandl()));
    emit MHCompOpenFSGL();
    DEVICE_INFO->printDeviceSystemInfo("加工头补偿打开完成");
    DEVICE_INFO->printDeviceSystemInfo("补偿面扫描完成");
    lastTaskIsFinish=true;
}

void DeviceProxy::FindEdgeFHandl(int result)
{
    disconnect(this,SIGNAL(FindEdgeFinishSGL(int)),this,SLOT(FindEdgeFHandl(int)));
    if (result == 0)
        DEVICE_INFO->printDeviceSystemInfo("寻边定位完成");
    else
        DEVICE_INFO->printDeviceSystemInfo("寻边定位失败，未找到切边!");
    lastTaskIsFinish=true;
}
void DeviceProxy::GetRatioP1P2FHandl(int result)
{
    disconnect(this,SIGNAL(GetRatioP1P2FinishSGL(int)),this,SLOT(GetRatioP1P2FHandl(int)));
    if (result == 0)
        DEVICE_INFO->printDeviceSystemInfo("获取光路参数完成");
    else
        DEVICE_INFO->printDeviceSystemInfo("获取光路参数失败，未完成检测!");
    lastTaskIsFinish=true;
}
void DeviceProxy::ElectricResistanceCheckFHandl(int result)
{
    disconnect(this,SIGNAL(ElectricResistanceCheckFinishSGL(int)),this,SLOT(ElectricResistanceCheckFHandl(int)));
    if (result == 0)
        DEVICE_INFO->printDeviceSystemInfo("晶锭预测量完成");
    else
        DEVICE_INFO->printDeviceSystemInfo("晶锭预测量失败，未完成检测!");
    ABSMove_Z0_test();
    lastTaskIsFinish=true;
}
void DeviceProxy::MHCompOpenFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(MHCompOpenFHandl()));
    emit MHCompOpenFSGL();
    DEVICE_INFO->printDeviceSystemInfo("加工头补偿打开完成");
    lastTaskIsFinish=true;
}


void DeviceProxy::SMachFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(SMachFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("单步加工完成");
    try {
        compCloseInSide();

        acsCtl->stopBuffer(1);
        QByteArray qbyCode = MachCode().getCode().toLatin1();
        char* code = qbyCode.data();
        acsCtl->loadBuffer(1,code);
        acsCtl->compileBuffer(1);
        acsCtl->runBuffer(1);
        lastTaskIsFinish=true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("单步加工后，取消补偿或Z轴运动失败！",mye.getExceptCode()));
    }

}

void DeviceProxy::semiAutoMachFHandl()
{
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(semiAutoMachFHandl()));
    DEVICE_INFO->printDeviceSystemInfo("半自动加工完成");
    lastTaskIsFinish=true;
}

bool DeviceProxy::getResetState()
{
    char vNameToHomeF[] = ACSCTL_ALLTOHOMEF_V;
    devIsReset = acsCtl->getGlobalInt(vNameToHomeF);
    return devIsReset;
}


void DeviceProxy::MHToCamera()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化,未复位,无法执行加工头到相机位置。请先完成复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行加工头到相机位置。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    {
        int axisBuf[4] = {0};
        axisBuf[1] = 1;
        int ret = AxisMoveSafeCheckXY(axisBuf,nullptr,nullptr);
        if(ret < 0)
        {
            emit exceptSGL(MyException(QString("晶碇与Z轴间距太小，不能执行动作。"),MY_WARN));
            return;
        }
    }

    RS_SETTINGS->beginGroup("device/MRHCamera");
    int cameraIsCalib = RS_SETTINGS->readNumEntry("/cameraIsCalib", 0);
    int MHIsCalib = RS_SETTINGS->readNumEntry("/MHIsCalib", 0);
    RS_SETTINGS->endGroup();

    if(!(cameraIsCalib&&MHIsCalib))
    {
        emit exceptSGL(MyException(QString("相机或加工头空间位置未标定，无法执行加工头到相机位置。请先完成复位。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("加工头到相机位置运动中...");
        lastTaskIsFinish=false;
        lastTaskName="加工头到相机位置";
        acsCtl->stopBuffer(1);
        char vname[]= ACSCTL_RUNF_V;
        acsCtl->setGlobalInt(vname,0);
        MAxisABSMoveCode mAxisABSMoveCode;

        RS_SETTINGS->beginGroup("device/ZAAxisSafe");
        double ZAAxisSafePos = RS_SETTINGS->readNumEntry("/pos");
        double ZAAxisToSafePosVel = RS_SETTINGS->readNumEntry("/vel");
        RS_SETTINGS->endGroup();

        mAxisABSMoveCode.setZAAxisSafePos(ZAAxisSafePos);
        mAxisABSMoveCode.setZAAxisToSafePosVel(ZAAxisToSafePosVel);

        mAxisABSMoveCode.setXAxisIsMove(true);
        mAxisABSMoveCode.setYAxisIsMove(true);
        mAxisABSMoveCode.setZAxisIsMove(false);
        mAxisABSMoveCode.setZAAxisIsMove(false);
        mAxisABSMoveCode.disableZAAxisToSafePos(true);
        mAxisABSMoveCode.setCMRSwitch(true);

        RS_SETTINGS->beginGroup("device/MRHCamera/calibPos");
        double MHXAxis = RS_SETTINGS->readNumDEntry("/MHXAxis");
        double MHYAxis = RS_SETTINGS->readNumDEntry("/MHYAxis");
        double cameraXAxis = RS_SETTINGS->readNumDEntry("/cameraXAxis");
        double cameraYAxis = RS_SETTINGS->readNumDEntry("/cameraYAxis");
        RS_SETTINGS->endGroup();

        mAxisABSMoveCode.setXAxisTGPos(MHXAxis-cameraXAxis);
        mAxisABSMoveCode.setYAxisTGPos(MHYAxis-cameraYAxis);

        RS_SETTINGS->beginGroup("device/MRHCamera/switchVel");
        double XAxisVel = RS_SETTINGS->readNumDEntry("/XAxis");
        double YAxisVel = RS_SETTINGS->readNumDEntry("/YAxis");
        RS_SETTINGS->endGroup();

        mAxisABSMoveCode.setXAxisVel(XAxisVel);
        mAxisABSMoveCode.setYAxisVel(YAxisVel);
        char *code;
        QByteArray byCode = mAxisABSMoveCode.getCode().toLatin1();
        code = byCode.data();

        acsCtl->loadBuffer(1,code);
        acsCtl->compileBuffer(1);
        acsCtl->runBuffer(1);

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(MHToCameraFHandl()));
        reqCMDRunFState = true;

    }
    catch (MyException mye)
    {
        exceptHandl(MyException("加工头移动到相机位置失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::CameraToMH()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化,未复位,无法执行相机到加工头位置。请先完成复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行相机到加工头位置。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    {
        int axisBuf[4] = {0};
        axisBuf[1] = 1;
        int ret = AxisMoveSafeCheckXY(axisBuf,nullptr,nullptr);
        if(ret < 0)
        {
            emit exceptSGL(MyException(QString("晶碇与Z轴间距太小，不能执行动作。"),MY_WARN));
            return;
        }
    }

    RS_SETTINGS->beginGroup("device/MRHCamera");
    int cameraIsCalib = RS_SETTINGS->readNumEntry("/cameraIsCalib", 0);
    int MHIsCalib = RS_SETTINGS->readNumEntry("/MHIsCalib", 0);
    RS_SETTINGS->endGroup();

    if(!(cameraIsCalib&&MHIsCalib))
    {
        emit exceptSGL(MyException(QString("相机或加工头空间位置未标定，无法执行加工头到相机位置。请先完成复位。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("相机到加工头位置运动中...");
        lastTaskIsFinish=false;
        lastTaskName="相机到加工头位置";

        acsCtl->stopBuffer(1);
        char vname[]= ACSCTL_RUNF_V;
        acsCtl->setGlobalInt(vname,0);
        MAxisABSMoveCode mAxisABSMoveCode;

        RS_SETTINGS->beginGroup("device/ZAAxisSafe");
        double ZAAxisSafePos = RS_SETTINGS->readNumEntry("/pos");
        double ZAAxisToSafePosVel = RS_SETTINGS->readNumEntry("/vel");
        RS_SETTINGS->endGroup();

        mAxisABSMoveCode.setZAAxisSafePos(ZAAxisSafePos);
        mAxisABSMoveCode.setZAAxisToSafePosVel(ZAAxisToSafePosVel);

        mAxisABSMoveCode.setXAxisIsMove(true);
        mAxisABSMoveCode.setYAxisIsMove(true);
        mAxisABSMoveCode.setZAxisIsMove(false);
        mAxisABSMoveCode.setZAAxisIsMove(false);
        mAxisABSMoveCode.disableZAAxisToSafePos(true);
        mAxisABSMoveCode.setCMRSwitch(true);

        RS_SETTINGS->beginGroup("device/MRHCamera/calibPos");
        double MHXAxis = RS_SETTINGS->readNumDEntry("/MHXAxis");
        double MHYAxis = RS_SETTINGS->readNumDEntry("/MHYAxis");
        double cameraXAxis = RS_SETTINGS->readNumDEntry("/cameraXAxis");
        double cameraYAxis = RS_SETTINGS->readNumDEntry("/cameraYAxis");
        RS_SETTINGS->endGroup();

        mAxisABSMoveCode.setXAxisTGPos(cameraXAxis-MHXAxis);
        mAxisABSMoveCode.setYAxisTGPos(cameraYAxis-MHYAxis);

        RS_SETTINGS->beginGroup("device/MRHCamera/switchVel");
        double XAxisVel = RS_SETTINGS->readNumDEntry("/XAxis");
        double YAxisVel = RS_SETTINGS->readNumDEntry("/YAxis");
        RS_SETTINGS->endGroup();

        mAxisABSMoveCode.setXAxisVel(XAxisVel);
        mAxisABSMoveCode.setYAxisVel(YAxisVel);
        char *code;
        QByteArray byCode = mAxisABSMoveCode.getCode().toLatin1();
        code = byCode.data();

        acsCtl->loadBuffer(1,code);
        acsCtl->compileBuffer(1);
        acsCtl->runBuffer(1);

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(CameraToMHFHandl()));
        reqCMDRunFState = true;

    }
    catch (MyException mye)
    {
        exceptHandl(MyException("相机移动到加工头位置失败。",mye.getExceptCode()));
    }
}
void DeviceProxy::RHToCamera()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化,未复位,无法执行测距头到相机位置。请先完成复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行测距头到相机位置。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    {
        int axisBuf[4] = {0};
        axisBuf[1] = 1;
        int ret = AxisMoveSafeCheckXY(axisBuf,nullptr,nullptr);
        if(ret < 0)
        {
            emit exceptSGL(MyException(QString("晶碇与Z轴间距太小，不能执行动作。"),MY_WARN));
            return;
        }
    }

    RS_SETTINGS->beginGroup("device/MRHCamera");
    int cameraIsCalib = RS_SETTINGS->readNumEntry("/cameraIsCalib", 0);
    int RHIsCalib = RS_SETTINGS->readNumEntry("/RHIsCalib", 0);
    RS_SETTINGS->endGroup();

    if(!(cameraIsCalib&&RHIsCalib))
    {
        emit exceptSGL(MyException(QString("相机或测距头空间位置未标定，无法执行加工头到相机位置。请先完成复位。"),MY_WARN));
        return;
    }
    try
    {
        DEVICE_INFO->printDeviceSystemInfo("测距头到相机位置运动中...");
        lastTaskIsFinish=false;
        lastTaskName="测距头到相机位置";

        acsCtl->stopBuffer(1);
        char vname[]= ACSCTL_RUNF_V;
        acsCtl->setGlobalInt(vname,0);
        MAxisABSMoveCode mAxisABSMoveCode;

        RS_SETTINGS->beginGroup("device/ZAAxisSafe");
        double ZAAxisSafePos = RS_SETTINGS->readNumEntry("/pos");
        double ZAAxisToSafePosVel = RS_SETTINGS->readNumEntry("/vel");
        RS_SETTINGS->endGroup();

        mAxisABSMoveCode.setZAAxisSafePos(ZAAxisSafePos);
        mAxisABSMoveCode.setZAAxisToSafePosVel(ZAAxisToSafePosVel);

        mAxisABSMoveCode.setXAxisIsMove(true);
        mAxisABSMoveCode.setYAxisIsMove(true);
        mAxisABSMoveCode.setZAxisIsMove(false);
        mAxisABSMoveCode.setZAAxisIsMove(false);
        mAxisABSMoveCode.disableZAAxisToSafePos(true);
        mAxisABSMoveCode.setCMRSwitch(true);

        RS_SETTINGS->beginGroup("device/MRHCamera/calibPos");
        double RHXAxis = RS_SETTINGS->readNumDEntry("/RHXAxis");
        double RHYAxis = RS_SETTINGS->readNumDEntry("/RHYAxis");
        double cameraXAxis = RS_SETTINGS->readNumDEntry("/cameraXAxis");
        double cameraYAxis = RS_SETTINGS->readNumDEntry("/cameraYAxis");
        RS_SETTINGS->endGroup();

        mAxisABSMoveCode.setXAxisTGPos(RHXAxis-cameraXAxis);
        mAxisABSMoveCode.setYAxisTGPos(RHYAxis-cameraYAxis);

        RS_SETTINGS->beginGroup("device/MRHCamera/switchVel");
        double XAxisVel = RS_SETTINGS->readNumDEntry("/XAxis");
        double YAxisVel = RS_SETTINGS->readNumDEntry("/YAxis");
        RS_SETTINGS->endGroup();

        mAxisABSMoveCode.setXAxisVel(XAxisVel);
        mAxisABSMoveCode.setYAxisVel(YAxisVel);
        char *code;
        QByteArray byCode = mAxisABSMoveCode.getCode().toLatin1();
        code = byCode.data();

        acsCtl->loadBuffer(1,code);
        acsCtl->compileBuffer(1);
        acsCtl->runBuffer(1);

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(RHToCameraFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("测距头移动到相机位置失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::CameraToRH()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化,未复位,无法执行相机到测距头位置。请先完成复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行相机到测距头位置。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    {
        int axisBuf[4] = {0};
        axisBuf[1] = 1;
        int ret = AxisMoveSafeCheckXY(axisBuf,nullptr,nullptr);
        if(ret < 0)
        {
            emit exceptSGL(MyException(QString("晶碇与Z轴间距太小，不能执行动作。"),MY_WARN));
            return;
        }
    }

    RS_SETTINGS->beginGroup("device/MRHCamera");
    int cameraIsCalib = RS_SETTINGS->readNumEntry("/cameraIsCalib", 0);
    int RHIsCalib = RS_SETTINGS->readNumEntry("/RHIsCalib", 0);
    RS_SETTINGS->endGroup();

    if(!(cameraIsCalib&&RHIsCalib))
    {
        emit exceptSGL(MyException(QString("相机或测距头空间位置未标定，无法执行加工头到相机位置。请先完成复位。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo("相机到测距头位置运动中...");
        lastTaskIsFinish=false;
        lastTaskName="相机到测距头位置";
        acsCtl->stopBuffer(1);
        char vname[]= ACSCTL_RUNF_V;
        acsCtl->setGlobalInt(vname,0);
        MAxisABSMoveCode mAxisABSMoveCode;

        RS_SETTINGS->beginGroup("device/ZAAxisSafe");
        double ZAAxisSafePos = RS_SETTINGS->readNumEntry("/pos");
        double ZAAxisToSafePosVel = RS_SETTINGS->readNumEntry("/vel");
        RS_SETTINGS->endGroup();

        mAxisABSMoveCode.setZAAxisSafePos(ZAAxisSafePos);
        mAxisABSMoveCode.setZAAxisToSafePosVel(ZAAxisToSafePosVel);

        mAxisABSMoveCode.setXAxisIsMove(true);
        mAxisABSMoveCode.setYAxisIsMove(true);
        mAxisABSMoveCode.setZAxisIsMove(false);
        mAxisABSMoveCode.setZAAxisIsMove(false);
        mAxisABSMoveCode.disableZAAxisToSafePos(true);
        mAxisABSMoveCode.setCMRSwitch(true);

        RS_SETTINGS->beginGroup("device/MRHCamera/calibPos");
        double RHXAxis = RS_SETTINGS->readNumDEntry("/RHXAxis");
        double RHYAxis = RS_SETTINGS->readNumDEntry("/RHYAxis");
        double cameraXAxis = RS_SETTINGS->readNumDEntry("/cameraXAxis");
        double cameraYAxis = RS_SETTINGS->readNumDEntry("/cameraYAxis");
        RS_SETTINGS->endGroup();

        mAxisABSMoveCode.setXAxisTGPos(cameraXAxis-RHXAxis);
        mAxisABSMoveCode.setYAxisTGPos(cameraYAxis-RHYAxis);

        RS_SETTINGS->beginGroup("device/MRHCamera/switchVel");
        double XAxisVel = RS_SETTINGS->readNumDEntry("/XAxis");
        double YAxisVel = RS_SETTINGS->readNumDEntry("/YAxis");
        RS_SETTINGS->endGroup();

        mAxisABSMoveCode.setXAxisVel(XAxisVel);
        mAxisABSMoveCode.setYAxisVel(YAxisVel);
        char *code;
        QByteArray byCode = mAxisABSMoveCode.getCode().toLatin1();
        code = byCode.data();

        acsCtl->loadBuffer(1,code);
        acsCtl->compileBuffer(1);
        acsCtl->runBuffer(1);

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(CameraToRHFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("相机移动到测距头位置失败。",mye.getExceptCode()));
    }
}


void DeviceProxy::RHToMH()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化,未复位,无法执行测距头到加工头位置。请先完成复位。"),MY_WARN));
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行测距头到加工头位置。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    {
        int axisBuf[4] = {0};
        axisBuf[1] = 1;
        int ret = AxisMoveSafeCheckXY(axisBuf,nullptr,nullptr);
        if(ret < 0)
        {
            emit exceptSGL(MyException(QString("晶碇与Z轴间距太小，不能执行动作。"),MY_WARN));
            return;
        }
    }

    RS_SETTINGS->beginGroup("device/MRHCamera");
    int RHIsCalib = RS_SETTINGS->readNumEntry("/RHIsCalib", 0);
    int MHIsCalib = RS_SETTINGS->readNumEntry("/MHIsCalib", 0);
    RS_SETTINGS->endGroup();

    if(!(MHIsCalib&&RHIsCalib))
    {
        emit exceptSGL(MyException(QString("测距或加工头空间位置未标定，无法执行加工头到相机位置。请先完成复位。"),MY_WARN));
    }

    try
    {
        lastTaskIsFinish=false;
        lastTaskName="测距头到加工头位置";
        RHToMHInSide();

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(RHToMHFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("测距头移动到加工头位置失败。",mye.getExceptCode()));
    }
}

void DeviceProxy::MHToRH()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化,未复位,无法执行加工头到测距头位置。请先完成复位。"),MY_WARN));
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行加工头到测距头位置。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    {
        int axisBuf[4] = {0};
        axisBuf[1] = 1;
        int ret = AxisMoveSafeCheckXY(axisBuf,nullptr,nullptr);
        if(ret < 0)
        {
            emit exceptSGL(MyException(QString("晶碇与Z轴间距太小，不能执行动作。"),MY_WARN));
            return;
        }
    }

    RS_SETTINGS->beginGroup("device/MRHCamera");
    int RHIsCalib = RS_SETTINGS->readNumEntry("/RHIsCalib", 0);
    int MHIsCalib = RS_SETTINGS->readNumEntry("/MHIsCalib", 0);
    RS_SETTINGS->endGroup();

    if(!(MHIsCalib&&RHIsCalib))
    {
        emit exceptSGL(MyException(QString("测距或加工头空间位置未标定，无法执行加工头到相机位置。请先完成复位。"),MY_WARN));
    }
    try
    {
        lastTaskIsFinish=false;
        lastTaskName="加工头到测距头位置";
        MHToRHInSide();
        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(MHToRHFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException("加工头移动到测距头位置失败。",mye.getExceptCode()));
    }
}



void DeviceProxy::toLoadAndUnloadPos()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化,未复位,无法执行到上下料位置。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行到上下料位置。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }


    try
    {
        lastTaskIsFinish=false;
        lastTaskName="到上下料位";
        toLoadAndUnloadPosInSide();
        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toLoadAndUnloadPosFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException(QString("到上下料位置失败。"),mye.getExceptCode()));
    }
}

void DeviceProxy::toGloblaCameraPos()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化,未复位,无法执行到全局相机位置。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行到全局相机位置。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }


    try
    {
        lastTaskIsFinish=false;
        lastTaskName="到全局相机位";
        acsCtl->setVEL(DAXIS, 40);
        acsCtl->setACC(DAXIS,400);
        acsCtl->setDEC(DAXIS,400);
        acsCtl->setJERK(DAXIS, 4000);
        acsCtl->setKDEC(DAXIS,4000);
        acsCtl->RToPointPos(DAXIS,-90);//转到工作位
        GloblaCameraPosInSide();
        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toGlobalCameraPosFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException(QString("到全局相机位置失败。"),mye.getExceptCode()));
    }
}

void DeviceProxy::toSScanStartPos()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化,未复位,无法执行到扫描起始位。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行到扫描起始位。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    try
    {
        lastTaskIsFinish=false;
        lastTaskName="到扫描起始位";
        toSScanStartPosInSide();
        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toSScanStartPosFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException(QString("到扫描起始位失败。"),mye.getExceptCode()));
    }
}


void DeviceProxy::toRSToZeroPos()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化,未复位,无法执行到对零位。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行到对零位。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    try
    {
        lastTaskIsFinish=false;
        lastTaskName="到对零位";
        toRSToZeroPosInSide();

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toRSToZeroPosFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException(QString("到对零位失败。"),mye.getExceptCode()));
    }
}


void DeviceProxy::toZAAxisCPos()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化,未复位,无法执行到Z轴常用位置。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行到Z轴常用位置。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    try
    {
        DEVICE_INFO->printDeviceSystemInfo(QString("到Z轴常用位运动中..."));
        lastTaskIsFinish=false;
        lastTaskName="到Z轴常用位";
        acsCtl->stopBuffer(1);
        char vname[]= ACSCTL_RUNF_V;
        acsCtl->setGlobalInt(vname,0);
        MAxisABSMoveCode mAxisABSMoveCode;


        mAxisABSMoveCode.setXAxisIsMove(false);
        mAxisABSMoveCode.setYAxisIsMove(false);
        mAxisABSMoveCode.setZAxisIsMove(false);
        mAxisABSMoveCode.setZAAxisIsMove(true);
        mAxisABSMoveCode.disableZAAxisToSafePos(true);


        RS_SETTINGS->beginGroup("device");
        QMap<QString,double> ZAAxisCPosMapTemp;
        ZAAxisCPosMapTemp = RS_SETTINGS->readQMapQStringDoubleEntry("/ZAAxisCPosMap", ZAAxisCPosMapTemp);
        RS_SETTINGS->endGroup();

        // 加载Z轴当前常用位置
        RS_SETTINGS->beginGroup("device");
        QString cbZAAxisCPCtText = RS_SETTINGS->readEntry("/ZAAxisCPCtText");
        RS_SETTINGS->endGroup();

        mAxisABSMoveCode.setZAAxisTGPos(ZAAxisCPosMapTemp[cbZAAxisCPCtText]);


        // 加载PTP位置设置
        RS_SETTINGS->beginGroup("device/ABSMove/Vel");
        double XAxisVel = RS_SETTINGS->readNumDEntry("/XAxis");
        double YAxisVel = RS_SETTINGS->readNumDEntry("/YAxis");
        double ZAxisVel = RS_SETTINGS->readNumDEntry("/ZAxis");
        double ZAAxisVel = RS_SETTINGS->readNumDEntry("/ZAAxis");
        RS_SETTINGS->endGroup();

        mAxisABSMoveCode.setXAxisVel(XAxisVel);
        mAxisABSMoveCode.setYAxisVel(YAxisVel);
        mAxisABSMoveCode.setZAxisVel(ZAxisVel);
        mAxisABSMoveCode.setZAAxisVel(ZAAxisVel);
        char *code;
        QByteArray byCode = mAxisABSMoveCode.getCode().toLatin1();
        code = byCode.data();

        acsCtl->loadBuffer(1,code);
        acsCtl->compileBuffer(1);
        acsCtl->runBuffer(1);

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toZAAxisCPosFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException(QString("到Z轴常用位置失败。"),mye.getExceptCode()));
    }
}


void DeviceProxy::stateDetection()
{
    try
    {
        detectionAllAxisCtPos();
        detectionAllAxisLimitState();
        detectionAllAxisEnableState();
        detectionEStopState();
        detectionRCValue();
        detectionLaserValue();
        detectionInState();
        setLight();
        detectionZZAAxisPos();
        if (checkZaxisAlarmFlag)
        {
            {
                int ZAxisErrorTemp = acsCtl->getMotorError(ZAXIS);
                if (ZAxisErrorTemp && (ZAxisErrorTemp >= 5017) && (ZAxisErrorTemp <= 5023))
                {
                    if (ZAxisErrorTemp >= 5017)
                    {
                        devIsReset = false;
                        //emit DEVResetStateChangedSGL(devIsReset);
                        //emit DEVInitStateChangedSGL(devIsInit && devIsReset);
                        char vNameToHomeF[] = ACSCTL_ALLTOHOMEF_V;
                        acsCtl->setGlobalInt(vNameToHomeF,0);
                    }
                    throw MyException(QString("Z1轴异常。"),ZAxisErrorTemp);
                }
            }
            {
                int ZAAxisErrorTemp = acsCtl->getMotorError(ZAAXIS);
                if (ZAAxisErrorTemp && (ZAAxisErrorTemp >= 5017) && (ZAAxisErrorTemp <= 5023))
                {
                    if (ZAAxisErrorTemp >= 5017)
                    {
                        devIsReset = false;
                        //emit DEVResetStateChangedSGL(devIsReset);
                        emit DEVInitStateChangedSGL(devIsInit && devIsReset);
                        char vNameToHomeF[] = ACSCTL_ALLTOHOMEF_V;
                        acsCtl->setGlobalInt(vNameToHomeF,0);
                    }
                    throw MyException(QString("Z轴异常。"),ZAAxisErrorTemp);
                }
            }
            {
                int XAxisErrorTemp = acsCtl->getMotorError(XAXIS);
                if (XAxisErrorTemp && (XAxisErrorTemp >= 5017) && (XAxisErrorTemp <= 5023))
                {
                    if (XAxisErrorTemp >= 5017)
                    {
                        devIsReset = false;
                        //emit DEVResetStateChangedSGL(devIsReset);
                        emit DEVInitStateChangedSGL(devIsInit && devIsReset);
                        char vNameToHomeF[] = ACSCTL_ALLTOHOMEF_V;
                        acsCtl->setGlobalInt(vNameToHomeF,0);
                    }
                    throw MyException(QString("X轴异常。"),XAxisErrorTemp);
                }
            }
            {
                int YAxisErrorTemp = acsCtl->getMotorError(YAXIS);
                if (YAxisErrorTemp && (YAxisErrorTemp >= 5017) && (YAxisErrorTemp <= 5023))
                {
                    if (YAxisErrorTemp >= 5017)
                    {
                        devIsReset = false;
                        //emit DEVResetStateChangedSGL(devIsReset);
                        emit DEVInitStateChangedSGL(devIsInit && devIsReset);
                        char vNameToHomeF[] = ACSCTL_ALLTOHOMEF_V;
                        acsCtl->setGlobalInt(vNameToHomeF,0);
                    }
                    throw MyException(QString("Y轴异常。"),YAxisErrorTemp);
                }
            }
            {
                int Z2AxisErrorTemp = acsCtl->getMotorError(Z2AXIS);
                if (Z2AxisErrorTemp && (Z2AxisErrorTemp >= 5017) && (Z2AxisErrorTemp <= 5023))
                {
                    if (Z2AxisErrorTemp >= 5017)
                    {
                        devIsReset = false;
                        //emit DEVResetStateChangedSGL(devIsReset);
                        emit DEVInitStateChangedSGL(devIsInit && devIsReset);
                        char vNameToHomeF[] = ACSCTL_ALLTOHOMEF_V;
                        acsCtl->setGlobalInt(vNameToHomeF,0);
                    }
                    throw MyException(QString("Z2轴异常。"),Z2AxisErrorTemp);
                }
            }
            {
                int DAxisErrorTemp = acsCtl->getMotorError(DAXIS);
                if (DAxisErrorTemp && (DAxisErrorTemp >= 5017) && (DAxisErrorTemp <= 5023))
                {
                    if (DAxisErrorTemp >= 5017)
                    {
                        devIsReset = false;
                        //emit DEVResetStateChangedSGL(devIsReset);
                        emit DEVInitStateChangedSGL(devIsInit && devIsReset);
                        char vNameToHomeF[] = ACSCTL_ALLTOHOMEF_V;
                        acsCtl->setGlobalInt(vNameToHomeF,0);
                    }
                    throw MyException(QString("DD轴异常。"),DAxisErrorTemp);
                }
            }
        }
        if(reqCMDRunFState)
        {

            detectionCMDRunFState();
            int buffer1ErrorTemp = acsCtl->getProgramError(1);
            if(buffer1ErrorTemp&&(buffer1ErrorTemp>=3020))
            {
                throw MyException(QString("buffer1运行异常。"),buffer1ErrorTemp);
            }


            if(acsCtl->getMoveState(XAXIS))
            {
                XAxisErrorDetection = true;
            }

            if(XAxisErrorDetection)
            {
                int XAxisErrorTemp = acsCtl->getMotorError(XAXIS);
                if(XAxisErrorTemp&&(XAxisErrorTemp!=5016)&&(XAxisErrorTemp!=5015)&&(XAxisErrorTemp!=5038))
                {

                    if ((XAxisErrorTemp >= 5017) && (XAxisErrorTemp <= 5023))
                    {
                        devIsReset = false;
                        //emit DEVResetStateChangedSGL(devIsReset);
                        emit DEVInitStateChangedSGL(devIsInit && devIsReset);
                        char vNameToHomeF[] = ACSCTL_ALLTOHOMEF_V;
                        acsCtl->setGlobalInt(vNameToHomeF,0);
                    }
                    throw MyException(QString("X轴异常。"),XAxisErrorTemp);
                }
            }

            if(acsCtl->getMoveState(YAXIS))
            {
                YAxisErrorDetection = true;
            }

            if(YAxisErrorDetection)
            {
                int YAxisErrorTemp = acsCtl->getMotorError(YAXIS);
                if(YAxisErrorTemp&&(YAxisErrorTemp!=5016)&&(YAxisErrorTemp!=5015)&&(YAxisErrorTemp!=5038))
                {
                    if ((YAxisErrorTemp >= 5017) && (YAxisErrorTemp <= 5023))
                    {
                        devIsReset = false;
                        //emit DEVResetStateChangedSGL(devIsReset);
                        emit DEVInitStateChangedSGL(devIsInit && devIsReset);
                        char vNameToHomeF[] = ACSCTL_ALLTOHOMEF_V;
                        acsCtl->setGlobalInt(vNameToHomeF,0);
                    }
                    throw MyException(QString("Y轴异常。"),YAxisErrorTemp);
                }
            }

            //lihongchang
            if(acsCtl->getMoveState(ZAXIS))
            {
                ZAxisErrorDetection = true;
            }

            if(ZAxisErrorDetection)
            {
                int ZAxisErrorTemp = acsCtl->getMotorError(ZAXIS);
                if(ZAxisErrorTemp&&(ZAxisErrorTemp!=5016)&&(ZAxisErrorTemp!=5015)&&(ZAxisErrorTemp!=5038))
                {
                    if ((ZAxisErrorTemp >= 5017) && (ZAxisErrorTemp <= 5023))
                    {
                        devIsReset = false;
                        //emit DEVResetStateChangedSGL(devIsReset);
                        emit DEVInitStateChangedSGL(devIsInit && devIsReset);
                        char vNameToHomeF[] = ACSCTL_ALLTOHOMEF_V;
                        acsCtl->setGlobalInt(vNameToHomeF,0);
                    }
                    throw MyException(QString("Z1轴异常。"),ZAxisErrorTemp);
                }
            }

            if(acsCtl->getMoveState(ZAAXIS))
            {
                ZAAxisErrorDetection = true;
            }

            if(ZAAxisErrorDetection)
            {
                int ZAAxisErrorTemp = acsCtl->getMotorError(ZAAXIS);
                if(ZAAxisErrorTemp&&(ZAAxisErrorTemp!=5016)&&(ZAAxisErrorTemp!=5015)&&(ZAAxisErrorTemp!=5038))
                {
                    if ((ZAAxisErrorTemp >= 5017) && (ZAAxisErrorTemp <= 5023))
                    {
                        devIsReset = false;
                        //emit DEVResetStateChangedSGL(devIsReset);
                        emit DEVInitStateChangedSGL(devIsInit && devIsReset);
                        char vNameToHomeF[] = ACSCTL_ALLTOHOMEF_V;
                        acsCtl->setGlobalInt(vNameToHomeF,0);
                    }
                    throw MyException(QString("Z轴异常。"),ZAAxisErrorTemp);
                }
            }
        }

    }
    catch (MyException mye)
    {
        exceptHandl(mye);
    }
}
bool DeviceProxy::getDevIsReset()
{
    return devIsReset;
}
bool DeviceProxy::getDevIsInit()
{
    return devIsInit;
}
bool DeviceProxy::getLastTaskIsFinish()
{
    return lastTaskIsFinish;
}
void DeviceProxy::exceptHandl_thread(MyException mye)
{
    //emit exceptSGL(mye);
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(resetFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(XAxisSMoveNFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(XAxisSMovePFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(YAxisSMoveNFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(YAxisSMovePFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(ZAxisSMoveNFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(ZAxisSMovePFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(ZAAxisSMoveNFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(ZAAxisSMovePFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(ABSMoveFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(MHToCameraFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(CameraToMHFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(RHToCameraFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(CameraToRHFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(RHToMHFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(MHToRHFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toLoadAndUnloadPosFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toGlobalCameraPosFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toSScanStartPosFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toHeightFindPosFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toEdgeSearchPosFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toCompenTestPosFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toRecordPosFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toRSToZeroPosFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toLaserApTestPosFHandl()));
    //disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toMachStartPosFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toZAAxisCPosFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(RSToZeroFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(MachSmallAreaFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(SScanFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(compSScanFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(MHCompOpenFHandl()));
    //disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(RHCompOpenFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(SMachFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(semiAutoMachFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(CSS_MHCompOpenFHandl()));

    disconnect(this,SIGNAL(FindEdgeFinishSGL(int)),this,SLOT(FindEdgeFHandl(int)));
    disconnect(this,SIGNAL(GetRatioP1P2FinishSGL(int)),this,SLOT(GetRatioP1P2FHandl(int)));
    disconnect(this,SIGNAL(ElectricResistanceCheckFinishSGL(int)),this,SLOT(ElectricResistanceCheckFHandl(int)));

    disconnect(this,SIGNAL(GetGlobalPhotoFinishSGL(int)),this,SLOT(GetGlobalPhotoFHandl(int)));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(DAxisSMovePFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(DAxisSMoveNFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(Z2AxisSMoveNFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(Z2AxisSMovePFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(Z0AxisSMoveNFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(Z0AxisSMovePFHandl()));

    XAxisErrorDetection=false;
    YAxisErrorDetection=false;
    ZAxisErrorDetection=false;
    ZAAxisErrorDetection=false;

    StopFindEdgeFlag = true;
    StopGetRatioP1P2Flag = true;
    StopElectricResistanceCheckFlag = true;
    MODBUSTCP->stopFlag = true;
    acsCtl->halt(XAXIS);
    acsCtl->halt(YAXIS);
    acsCtl->halt(ZAXIS);
    acsCtl->halt(ZAAXIS);
    acsCtl->halt(DAXIS);
    acsCtl->halt(Z0AXIS);
    acsCtl->halt(Z2AXIS);

    if (bRunning)
    {
        mutex.lock();
        bRunning = false;
        mutex.unlock();
        emit RunSGL(!bRunning);
    }
    lastTaskIsFinish=true;
    if (devIsInit)
    {
        laserClose();
        if (pLaserMark != nullptr)
            pLaserMark->Abort();
    }

    reqCMDRunFState = false;

    try
    {
        acsCtl->getEnable(XAXIS);
        if(acsCtl->getBufferRunState(1))
        {
            acsCtl->stopBuffer(1);
        }
        if(acsCtl->getBufferRunState(8))
        {
            acsCtl->stopBuffer(8);
        }
        emit exceptSGL_lhc(mye);
        //emit exceptSGL(mye);

    } catch (MyException mye)
    {
        devIsInit = false;
        //emit DEVInitStateChangedSGL(devIsInit);
        devIsReset = false;
        emit DEVInitStateChangedSGL(devIsInit && devIsReset);
        //emit DEVResetStateChangedSGL(devIsReset);
        stopStateDetection();
        emit exceptSGL_lhc(MyException(QString("网络连接断开。")));
    }
}
void DeviceProxy::exceptHandl(MyException mye)
{
    //emit exceptSGL(mye);
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(resetFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(XAxisSMoveNFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(XAxisSMovePFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(YAxisSMoveNFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(YAxisSMovePFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(ZAxisSMoveNFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(ZAxisSMovePFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(ZAAxisSMoveNFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(ZAAxisSMovePFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(ABSMoveFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(MHToCameraFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(CameraToMHFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(RHToCameraFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(CameraToRHFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(RHToMHFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(MHToRHFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toLoadAndUnloadPosFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toGlobalCameraPosFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toSScanStartPosFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toHeightFindPosFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toEdgeSearchPosFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toCompenTestPosFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toRecordPosFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toRSToZeroPosFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toLaserApTestPosFHandl()));
    //disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toMachStartPosFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toZAAxisCPosFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(RSToZeroFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(MachSmallAreaFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(SScanFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(compSScanFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(MHCompOpenFHandl()));
    //disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(RHCompOpenFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(SMachFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(semiAutoMachFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(CSS_MHCompOpenFHandl()));

    disconnect(this,SIGNAL(FindEdgeFinishSGL(int)),this,SLOT(FindEdgeFHandl(int)));
    disconnect(this,SIGNAL(GetRatioP1P2FinishSGL(int)),this,SLOT(GetRatioP1P2FHandl(int)));
    disconnect(this,SIGNAL(ElectricResistanceCheckFinishSGL(int)),this,SLOT(ElectricResistanceCheckFHandl(int)));

    disconnect(this,SIGNAL(GetGlobalPhotoFinishSGL(int)),this,SLOT(GetGlobalPhotoFHandl(int)));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(DAxisSMovePFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(DAxisSMoveNFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(Z2AxisSMoveNFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(Z2AxisSMovePFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(Z0AxisSMoveNFHandl()));
    disconnect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(Z0AxisSMovePFHandl()));

    XAxisErrorDetection=false;
    YAxisErrorDetection=false;
    ZAxisErrorDetection=false;
    ZAAxisErrorDetection=false;


    checkZaxisAlarmFlag = false;
    StopFindEdgeFlag = true;
    StopGetRatioP1P2Flag = true;
    StopElectricResistanceCheckFlag = true;
    MODBUSTCP->stopFlag = true;
    if (devIsInit)
    {
        acsCtl->halt(XAXIS);
        acsCtl->halt(YAXIS);
        acsCtl->halt(ZAXIS);
        acsCtl->halt(ZAAXIS);
        acsCtl->halt(DAXIS);
        acsCtl->halt(Z0AXIS);
        acsCtl->halt(Z2AXIS);
    }
    if (bRunning)
    {
        mutex.lock();
        bRunning = false;
        mutex.unlock();
        emit RunSGL(!bRunning);
    }
    lastTaskIsFinish=true;
    if (devIsInit)
    {
        laserClose();
        if (pLaserMark != nullptr)
            pLaserMark->Abort();
    }

    reqCMDRunFState = false;
    emit AutoSmachStateSGL(false);
    emit VacuumSuckerOnOrOffStateSGL(true);
    if (bUserPower)
        emit SmachTypeStateSGL(true);
    try
    {
        acsCtl->getEnable(XAXIS);
        if(acsCtl->getBufferRunState(1))
        {
            acsCtl->stopBuffer(1);
        }
        if(acsCtl->getBufferRunState(8))
        {
            acsCtl->stopBuffer(8);
        }
        //emit exceptSGL_lhc(mye);
        emit exceptSGL(mye);

    } catch (MyException mye)
    {
        devIsInit = false;
        //emit DEVInitStateChangedSGL(devIsInit);
        devIsReset = false;
        //emit DEVResetStateChangedSGL(devIsReset);
        emit DEVInitStateChangedSGL(devIsInit && devIsReset);
        stopStateDetection();
        emit exceptSGL(MyException(QString("网络连接断开。")));
    }
}
void DeviceProxy::toLaserApTestPosInSide()
{
    DEVICE_INFO->printDeviceSystemInfo(QString("到激光功率测量位运动中..."));

    acsCtl->stopBuffer(1);
    char vname[]= ACSCTL_RUNF_V;
    acsCtl->setGlobalInt(vname,0);
    MAxisABSMoveCode mAxisABSMoveCode;

    RS_SETTINGS->beginGroup("device/ZAAxisSafe");
    double ZAAxisSafePos = RS_SETTINGS->readNumEntry("/pos");
    double ZAAxisToSafePosVel = RS_SETTINGS->readNumEntry("/vel");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setZAAxisSafePos(ZAAxisSafePos);
    mAxisABSMoveCode.setZAAxisToSafePosVel(ZAAxisToSafePosVel);

    mAxisABSMoveCode.setXAxisIsMove(true);
    mAxisABSMoveCode.setYAxisIsMove(true);
    mAxisABSMoveCode.setZAxisIsMove(true);
    mAxisABSMoveCode.setZAAxisIsMove(true);
    mAxisABSMoveCode.setZ0AxisIsMove(true);
    mAxisABSMoveCode.disableZAAxisToSafePos(false);


    RS_SETTINGS->beginGroup("device/LaserApTestPos");
    double XAxisPos = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisPos = RS_SETTINGS->readNumDEntry("/YAxis");
    double ZAAxisPos = RS_SETTINGS->readNumDEntry("/ZAAxis");
    RS_SETTINGS->endGroup();

    RS_SETTINGS->beginGroup("device/rightSLimit");
    double Z0AxisRightSLimit = RS_SETTINGS->readNumDEntry("/Z0Axis");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setXAxisTGPos(XAxisPos);
    mAxisABSMoveCode.setYAxisTGPos(YAxisPos);
    mAxisABSMoveCode.setZAxisTGPos(0);
    mAxisABSMoveCode.setZAAxisTGPos(ZAAxisPos);
    /***************************************************************
     * 修改码：1008610010
     * 日期：
     *      2024.3.4
     * 功能：
     *      光路检测功能，将Z0轴移动到最高（右软限位）
     * 描述：
     *      mAxisABSMoveCode.setZ0AxisIsMove(true);
     *      mAxisABSMoveCode.setZ0AxisTGPos(Z0AxisRightSLimit);
     **************************************************************/
    mAxisABSMoveCode.setZ0AxisTGPos(Z0AxisRightSLimit);

    // 加载PTP位置设置
    RS_SETTINGS->beginGroup("device/ABSMove/Vel");
    double XAxisVel = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisVel = RS_SETTINGS->readNumDEntry("/YAxis");
    double ZAxisVel = RS_SETTINGS->readNumDEntry("/ZAxis");
    double ZAAxisVel = RS_SETTINGS->readNumDEntry("/ZAAxis");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setXAxisVel(XAxisVel);
    mAxisABSMoveCode.setYAxisVel(YAxisVel);
    mAxisABSMoveCode.setZAxisVel(ZAxisVel);
    mAxisABSMoveCode.setZAAxisVel(ZAAxisVel);
    char *code;
    QByteArray byCode = mAxisABSMoveCode.getCode_L().toLatin1();
    code = byCode.data();

    acsCtl->loadBuffer(1,code);
    acsCtl->compileBuffer(1);
    acsCtl->runBuffer(1);
}
void DeviceProxy::toLaserMarkPosThreadInSide()
{
    DEVICE_INFO->printDeviceSystemInfo(QString("到打标位运动中..."));

    acsCtl->stopBuffer(1);
    char vname[]= ACSCTL_RUNF_V;
    acsCtl->setGlobalInt(vname,0);
    MAxisABSMoveCode mAxisABSMoveCode;

    RS_SETTINGS->beginGroup("device/ZAAxisSafe");
    double ZAAxisSafePos = RS_SETTINGS->readNumEntry("/pos");
    double ZAAxisToSafePosVel = RS_SETTINGS->readNumEntry("/vel");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setZAAxisSafePos(ZAAxisSafePos);
    mAxisABSMoveCode.setZAAxisToSafePosVel(ZAAxisToSafePosVel);

    mAxisABSMoveCode.setXAxisIsMove(true);
    mAxisABSMoveCode.setYAxisIsMove(true);
    mAxisABSMoveCode.setZAxisIsMove(false);
    mAxisABSMoveCode.setZAAxisIsMove(true);
    mAxisABSMoveCode.setZ2AxisIsMove(true);
    mAxisABSMoveCode.disableZAAxisToSafePos(false);


    RS_SETTINGS->beginGroup("device/LaserMarkPos");
    double XAxisPos = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisPos = RS_SETTINGS->readNumDEntry("/YAxis");
    RS_SETTINGS->endGroup();

    RS_SETTINGS->beginGroup("device/LaserMark");
    double dsbZ2Offset = RS_SETTINGS->readNumDEntry("/Z2Offset");
    RS_SETTINGS->endGroup();

    RS_SETTINGS->beginGroup("device/Type");
    QString strType = RS_SETTINGS->readEntry("/value");
    RS_SETTINGS->endGroup();
    int Yoffset;
    if (strType == "6寸")
    {
        Yoffset = INCHES6;
    }
    else if (strType == "8寸")
    {
        Yoffset = INCHES8;
    }
    else
    {
        Yoffset = INCHES4;
    }

    mAxisABSMoveCode.setXAxisTGPos(XAxisPos + INCHES4 - Yoffset);
    mAxisABSMoveCode.setYAxisTGPos(YAxisPos);
    mAxisABSMoveCode.setZAAxisTGPos(ZAAxisSafePos);
    mAxisABSMoveCode.setZ2AxisTGPos(workpieceHeight - dsbZ2Offset );//这里可能不对，逻辑关系不对

    // 加载PTP位置设置
    RS_SETTINGS->beginGroup("device/ABSMove/Vel");
    double XAxisVel = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisVel = RS_SETTINGS->readNumDEntry("/YAxis");
    double ZAxisVel = RS_SETTINGS->readNumDEntry("/ZAxis");
    double ZAAxisVel = RS_SETTINGS->readNumDEntry("/ZAAxis");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setXAxisVel(XAxisVel);
    mAxisABSMoveCode.setYAxisVel(YAxisVel);
    mAxisABSMoveCode.setZAxisVel(ZAxisVel);
    mAxisABSMoveCode.setZAAxisVel(ZAAxisVel);
    mAxisABSMoveCode.setZ2AxisVel(5);
    char *code;
    QByteArray byCode = mAxisABSMoveCode.getLaserMarkCode().toLatin1();
    code = byCode.data();

    acsCtl->loadBuffer(1,code);
    acsCtl->compileBuffer(1);
    acsCtl->runBuffer(1);
}

void DeviceProxy::toLaserMarkPosInSide()
{
    DEVICE_INFO->printDeviceSystemInfo(QString("到打标位运动中..."));

    acsCtl->stopBuffer(1);
    char vname[]= ACSCTL_RUNF_V;
    acsCtl->setGlobalInt(vname,0);
    MAxisABSMoveCode mAxisABSMoveCode;

    RS_SETTINGS->beginGroup("device/ZAAxisSafe");
    double ZAAxisSafePos = RS_SETTINGS->readNumEntry("/pos");
    double ZAAxisToSafePosVel = RS_SETTINGS->readNumEntry("/vel");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setZAAxisSafePos(ZAAxisSafePos);
    mAxisABSMoveCode.setZAAxisToSafePosVel(ZAAxisToSafePosVel);

    mAxisABSMoveCode.setXAxisIsMove(true);
    mAxisABSMoveCode.setYAxisIsMove(true);
    mAxisABSMoveCode.setZAxisIsMove(false);
    mAxisABSMoveCode.setZAAxisIsMove(true);
    mAxisABSMoveCode.setZ2AxisIsMove(true);
    mAxisABSMoveCode.disableZAAxisToSafePos(false);


    RS_SETTINGS->beginGroup("device/LaserMarkPos");
    double XAxisPos = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisPos = RS_SETTINGS->readNumDEntry("/YAxis");
    RS_SETTINGS->endGroup();

    RS_SETTINGS->beginGroup("device/LaserMark");
    double dsbZ2Offset = RS_SETTINGS->readNumDEntry("/Z2Offset");
    RS_SETTINGS->endGroup();

    RS_SETTINGS->beginGroup("device/Type");
    QString strType = RS_SETTINGS->readEntry("/value");
    RS_SETTINGS->endGroup();
    int Yoffset;
    if (strType == "6寸")
    {
        Yoffset = INCHES6;
    }
    else if (strType == "8寸")
    {
        Yoffset = INCHES8;
    }
    else
    {
        Yoffset = INCHES4;
    }

    mAxisABSMoveCode.setXAxisTGPos(XAxisPos + INCHES4 - Yoffset+LaserMarkOffset_X);
    mAxisABSMoveCode.setYAxisTGPos(YAxisPos+LaserMarkOffset_Y);
    mAxisABSMoveCode.setZAAxisTGPos(ZAAxisSafePos);
    mAxisABSMoveCode.setZ2AxisTGPos(workpieceHeight - dsbZ2Offset );//这里可能不对，逻辑关系不对  lihongchang -2.5

    // 加载PTP位置设置
    RS_SETTINGS->beginGroup("device/ABSMove/Vel");
    double XAxisVel = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisVel = RS_SETTINGS->readNumDEntry("/YAxis");
    double ZAxisVel = RS_SETTINGS->readNumDEntry("/ZAxis");
    double ZAAxisVel = RS_SETTINGS->readNumDEntry("/ZAAxis");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setXAxisVel(XAxisVel);
    mAxisABSMoveCode.setYAxisVel(YAxisVel);
    mAxisABSMoveCode.setZAxisVel(ZAxisVel);
    mAxisABSMoveCode.setZAAxisVel(ZAAxisVel);
    mAxisABSMoveCode.setZ2AxisVel(5);
    char *code;
    QByteArray byCode = mAxisABSMoveCode.getCode().toLatin1();
    code = byCode.data();

    acsCtl->loadBuffer(1,code);
    acsCtl->compileBuffer(1);
    acsCtl->runBuffer(1);
}

void DeviceProxy::toLaserMarkPos()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化,未复位,无法执行到打标位。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行到打标位。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    try
    {
        lastTaskIsFinish=false;
        lastTaskName="到打标位";
        toLaserMarkPosInSide();
        //toLaserMarkPosThreadInSide();

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toLaserMarkPosFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException(QString("到打标位失败。"),mye.getExceptCode()));
    }
}
void DeviceProxy::toLaserApTestPos()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化,未复位,无法执行到功率测量位。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行到功率测量位。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    //    int ret = UpdateWorkData(0);
    //    if (ret != 0)
    //    {
    //        emit exceptSGL(MyException(QString("测量功率文件打开错误，请检查文件路径"),MY_WARN));
    //        return;
    //    }
    try
    {
        lastTaskIsFinish=false;
        lastTaskName="功率测量";
        toLaserApTestPosInSide();
        //        bRunning = true;
        //        emit RunSGL(!bRunning);
        //        step = 2;
        //        StopFindEdgeFlag = false;
        //        MODBUSTCP->stopFlag = false;
        //        checkZaxisAlarmFlag = true;
        //        LaserTestApFlag = true;
        //        StopGonglvCheckFlag = false;

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toLaserApTestPosFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException(QString("功率测量失败。"),mye.getExceptCode()));
    }
}
void DeviceProxy::toHeightFindPosInSide()
{
    DEVICE_INFO->printDeviceSystemInfo(QString("到晶锭预测量位运动中..."));

    acsCtl->stopBuffer(1);
    char vname[]= ACSCTL_RUNF_V;
    acsCtl->setGlobalInt(vname,0);
    MAxisABSMoveCode mAxisABSMoveCode;

    RS_SETTINGS->beginGroup("device/ZAAxisSafe");
    double ZAAxisSafePos = RS_SETTINGS->readNumEntry("/pos");
    double ZAAxisToSafePosVel = RS_SETTINGS->readNumEntry("/vel");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setZAAxisSafePos(ZAAxisSafePos);
    mAxisABSMoveCode.setZAAxisToSafePosVel(ZAAxisToSafePosVel);

    mAxisABSMoveCode.setXAxisIsMove(true);
    mAxisABSMoveCode.setYAxisIsMove(true);
    mAxisABSMoveCode.setZAxisIsMove(false);
    mAxisABSMoveCode.setZAAxisIsMove(true);
    mAxisABSMoveCode.setZ0AxisIsMove(true);
    mAxisABSMoveCode.disableZAAxisToSafePos(false);


    RS_SETTINGS->beginGroup("device/HeightFindPos");
    double XAxisPos = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisPos = RS_SETTINGS->readNumDEntry("/YAxis");
    RS_SETTINGS->endGroup();
    RS_SETTINGS->beginGroup("device/LaserMark");
    double dsbZ0Offset = RS_SETTINGS->readNumDEntry("/Z0Offset");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setXAxisTGPos(XAxisPos);
    mAxisABSMoveCode.setYAxisTGPos(YAxisPos);
    mAxisABSMoveCode.setZ0AxisTGPos(0-dsbZ0Offset );
    mAxisABSMoveCode.setZAAxisTGPos(workpieceHeight);

    // 加载PTP位置设置
    RS_SETTINGS->beginGroup("device/ABSMove/Vel");
    double XAxisVel = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisVel = RS_SETTINGS->readNumDEntry("/YAxis");
    double ZAxisVel = RS_SETTINGS->readNumDEntry("/ZAxis");
    double ZAAxisVel = RS_SETTINGS->readNumDEntry("/ZAAxis");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setXAxisVel(XAxisVel);
    mAxisABSMoveCode.setYAxisVel(YAxisVel);
    mAxisABSMoveCode.setZAxisVel(ZAxisVel);
    mAxisABSMoveCode.setZAAxisVel(ZAAxisVel);
    mAxisABSMoveCode.setZ0AxisVel(5);
    char *code;
    QByteArray byCode = mAxisABSMoveCode.getCode().toLatin1();
    code = byCode.data();

    acsCtl->loadBuffer(1,code);
    acsCtl->compileBuffer(1);
    acsCtl->runBuffer(1);
}

void DeviceProxy::toEdgeSearchPosInSide()
{
    DEVICE_INFO->printDeviceSystemInfo(QString("到寻边位运动中..."));

    acsCtl->stopBuffer(1);
    char vname[]= ACSCTL_RUNF_V;
    acsCtl->setGlobalInt(vname,0);
    MAxisABSMoveCode mAxisABSMoveCode;

    RS_SETTINGS->beginGroup("device/ZAAxisSafe");
    double ZAAxisSafePos = RS_SETTINGS->readNumEntry("/pos");
    double ZAAxisToSafePosVel = RS_SETTINGS->readNumEntry("/vel");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setZAAxisSafePos(ZAAxisSafePos);
    mAxisABSMoveCode.setZAAxisToSafePosVel(ZAAxisToSafePosVel);

    mAxisABSMoveCode.setXAxisIsMove(true);
    mAxisABSMoveCode.setYAxisIsMove(true);
    mAxisABSMoveCode.setZAxisIsMove(false);
    mAxisABSMoveCode.setZAAxisIsMove(true);
    mAxisABSMoveCode.disableZAAxisToSafePos(true);


    RS_SETTINGS->beginGroup("device/RSToZeroPos");
    double XAxisPos = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisPos = RS_SETTINGS->readNumDEntry("/YAxis");
    RS_SETTINGS->endGroup();




    RS_SETTINGS->beginGroup("device/Type");
    QString strType = RS_SETTINGS->readEntry("/value");
    RS_SETTINGS->endGroup();
    double Yoffset;
    if (strType == "6寸")
    {
        Yoffset = INCHES6-7;
    }
    else if (strType == "8寸")
    {
        Yoffset = INCHES8-6;
    }
    else
    {
        Yoffset = INCHES4-7;
    }
    RS_SETTINGS->beginGroup("device/Rposition");
    double FindEdageOffset = RS_SETTINGS->readNumDEntry("/FindEdageOffset");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setXAxisTGPos(XAxisPos);
    mAxisABSMoveCode.setYAxisTGPos(YAxisPos - Yoffset);
    double ZAAxisPos = workpieceHeight;   //-2.5
    mAxisABSMoveCode.setZAAxisTGPos(ZAAxisPos);

    // 加载PTP位置设置
    RS_SETTINGS->beginGroup("device/ABSMove/Vel");
    double XAxisVel = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisVel = RS_SETTINGS->readNumDEntry("/YAxis");
    double ZAxisVel = RS_SETTINGS->readNumDEntry("/ZAxis");
    double ZAAxisVel = RS_SETTINGS->readNumDEntry("/ZAAxis");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setXAxisVel(XAxisVel);
    mAxisABSMoveCode.setYAxisVel(YAxisVel);
    mAxisABSMoveCode.setZAxisVel(ZAxisVel);
    mAxisABSMoveCode.setZAAxisVel(ZAAxisVel);
    char *code;
    QByteArray byCode = mAxisABSMoveCode.getCode().toLatin1();
    code = byCode.data();

    acsCtl->loadBuffer(1,code);
    acsCtl->compileBuffer(1);
    acsCtl->runBuffer(1);
}


void DeviceProxy::toEdgeSearchPosThreadInSide()
{
    DEVICE_INFO->printDeviceSystemInfo(QString("到寻边位运动中..."));

    acsCtl->stopBuffer(1);
    char vname[]= ACSCTL_RUNF_V;
    acsCtl->setGlobalInt(vname,0);
    MAxisABSMoveCode mAxisABSMoveCode;

    RS_SETTINGS->beginGroup("device/ZAAxisSafe");
    double ZAAxisSafePos = RS_SETTINGS->readNumEntry("/pos");
    double ZAAxisToSafePosVel = RS_SETTINGS->readNumEntry("/vel");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setZAAxisSafePos(ZAAxisSafePos);
    mAxisABSMoveCode.setZAAxisToSafePosVel(ZAAxisToSafePosVel);

    mAxisABSMoveCode.setXAxisIsMove(true);
    mAxisABSMoveCode.setYAxisIsMove(true);
    mAxisABSMoveCode.setZAxisIsMove(false);
    mAxisABSMoveCode.setZAAxisIsMove(true);
    mAxisABSMoveCode.disableZAAxisToSafePos(true);


    RS_SETTINGS->beginGroup("device/EdgeSearchPos");
    double XAxisPos = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisPos = RS_SETTINGS->readNumDEntry("/YAxis");
    RS_SETTINGS->endGroup();



    RS_SETTINGS->beginGroup("device/Type");
    QString strType = RS_SETTINGS->readEntry("/value");
    RS_SETTINGS->endGroup();
    int Yoffset;
    if (strType == "6寸")
    {
        Yoffset = INCHES6+3;
    }
    else if (strType == "8寸")
    {
        Yoffset = INCHES8;
    }
    else
    {
        Yoffset = INCHES4;
    }
    RS_SETTINGS->beginGroup("device/Rposition");
    double FindEdageOffset = RS_SETTINGS->readNumDEntry("/FindEdageOffset");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setXAxisTGPos(XAxisPos);
    mAxisABSMoveCode.setYAxisTGPos(YAxisPos - Yoffset + FindEdageOffset);
    double ZAAxisPos = workpieceHeight;
    mAxisABSMoveCode.setZAAxisTGPos(ZAAxisPos);

    // 加载PTP位置设置
    RS_SETTINGS->beginGroup("device/ABSMove/Vel");
    double XAxisVel = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisVel = RS_SETTINGS->readNumDEntry("/YAxis");
    double ZAxisVel = RS_SETTINGS->readNumDEntry("/ZAxis");
    double ZAAxisVel = RS_SETTINGS->readNumDEntry("/ZAAxis");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setXAxisVel(XAxisVel);
    mAxisABSMoveCode.setYAxisVel(YAxisVel);
    mAxisABSMoveCode.setZAxisVel(ZAxisVel);
    mAxisABSMoveCode.setZAAxisVel(ZAAxisVel);
    char *code;
    QByteArray byCode = mAxisABSMoveCode.getToCameraCode().toLatin1();
    code = byCode.data();

    acsCtl->loadBuffer(1,code);
    acsCtl->compileBuffer(1);
    acsCtl->runBuffer(1);
}

void DeviceProxy::toRecordPosInSide()
{
    DEVICE_INFO->printDeviceSystemInfo(QString("到记录位运动中..."));

    acsCtl->stopBuffer(1);
    char vname[]= ACSCTL_RUNF_V;
    acsCtl->setGlobalInt(vname,0);
    MAxisABSMoveCode mAxisABSMoveCode;

    RS_SETTINGS->beginGroup("device/ZAAxisSafe");
    double ZAAxisSafePos = RS_SETTINGS->readNumEntry("/pos");
    double ZAAxisToSafePosVel = RS_SETTINGS->readNumEntry("/vel");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setZAAxisSafePos(ZAAxisSafePos);
    mAxisABSMoveCode.setZAAxisToSafePosVel(ZAAxisToSafePosVel);

    mAxisABSMoveCode.setXAxisIsMove(true);
    mAxisABSMoveCode.setYAxisIsMove(true);
    mAxisABSMoveCode.setZAxisIsMove(false);
    mAxisABSMoveCode.setZAAxisIsMove(true);
    mAxisABSMoveCode.disableZAAxisToSafePos(false);


    RS_SETTINGS->beginGroup("device/RecordPos");
    double XAxisPos = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisPos = RS_SETTINGS->readNumDEntry("/YAxis");
    double ZAAxisPos = RS_SETTINGS->readNumDEntry("/ZAAxis");
    RS_SETTINGS->endGroup();


    mAxisABSMoveCode.setXAxisTGPos(XAxisPos);
    mAxisABSMoveCode.setYAxisTGPos(YAxisPos);
    mAxisABSMoveCode.setZAAxisTGPos(ZAAxisPos);

    // 加载PTP位置设置
    RS_SETTINGS->beginGroup("device/ABSMove/Vel");
    double XAxisVel = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisVel = RS_SETTINGS->readNumDEntry("/YAxis");
    double ZAxisVel = RS_SETTINGS->readNumDEntry("/ZAxis");
    double ZAAxisVel = RS_SETTINGS->readNumDEntry("/ZAAxis");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setXAxisVel(XAxisVel);
    mAxisABSMoveCode.setYAxisVel(YAxisVel);
    mAxisABSMoveCode.setZAxisVel(ZAxisVel);
    mAxisABSMoveCode.setZAAxisVel(ZAAxisVel);
    char *code;
    QByteArray byCode = mAxisABSMoveCode.getCode().toLatin1();
    code = byCode.data();

    acsCtl->loadBuffer(1,code);
    acsCtl->compileBuffer(1);
    acsCtl->runBuffer(1);
}
void DeviceProxy::toCompenTestPosInSide()
{
    DEVICE_INFO->printDeviceSystemInfo(QString("到上料准备位运动中..."));

    acsCtl->stopBuffer(1);
    char vname[]= ACSCTL_RUNF_V;
    acsCtl->setGlobalInt(vname,0);
    MAxisABSMoveCode mAxisABSMoveCode;

    RS_SETTINGS->beginGroup("device/ZAAxisSafe");
    double ZAAxisSafePos = RS_SETTINGS->readNumEntry("/pos");
    double ZAAxisToSafePosVel = RS_SETTINGS->readNumEntry("/vel");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setZAAxisSafePos(ZAAxisSafePos);
    mAxisABSMoveCode.setZAAxisToSafePosVel(ZAAxisToSafePosVel);

    mAxisABSMoveCode.setXAxisIsMove(true);
    mAxisABSMoveCode.setYAxisIsMove(true);
    mAxisABSMoveCode.setZAxisIsMove(false);
    mAxisABSMoveCode.setZAAxisIsMove(true);
    mAxisABSMoveCode.disableZAAxisToSafePos(false);


    RS_SETTINGS->beginGroup("device/CompenTestPos");
    double XAxisPos = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisPos = RS_SETTINGS->readNumDEntry("/YAxis");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setXAxisTGPos(XAxisPos);
    if (bAutoLoadUnloadFlag == false)
        mAxisABSMoveCode.setYAxisTGPos(YAxisPos - 400);
    else
        mAxisABSMoveCode.setYAxisTGPos(YAxisPos);
    mAxisABSMoveCode.setZAAxisTGPos(ZAAxisSafePos);

    // 加载PTP位置设置
    RS_SETTINGS->beginGroup("device/ABSMove/Vel");
    double XAxisVel = RS_SETTINGS->readNumDEntry("/XAxis");
    double YAxisVel = RS_SETTINGS->readNumDEntry("/YAxis");
    double ZAxisVel = RS_SETTINGS->readNumDEntry("/ZAxis");
    double ZAAxisVel = RS_SETTINGS->readNumDEntry("/ZAAxis");
    RS_SETTINGS->endGroup();

    mAxisABSMoveCode.setXAxisVel(XAxisVel);
    mAxisABSMoveCode.setYAxisVel(YAxisVel);
    mAxisABSMoveCode.setZAxisVel(ZAxisVel);
    mAxisABSMoveCode.setZAAxisVel(ZAAxisVel);
    char *code;
    QByteArray byCode = mAxisABSMoveCode.getCode().toLatin1();
    code = byCode.data();

    acsCtl->loadBuffer(1,code);
    acsCtl->compileBuffer(1);
    acsCtl->runBuffer(1);
}

void DeviceProxy::toHeightFindPos()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化,未复位,无法执行到晶锭预测量位。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行到晶锭预测量位。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }

    try
    {
        lastTaskIsFinish=false;
        lastTaskName="电阻测量位";
        toHeightFindPosInSide();

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toHeightFindPosFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException(QString("到测高位失败。"),mye.getExceptCode()));
    }
}

void DeviceProxy::toEdgeSearchPos()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化,未复位,无法执行到寻边位。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行到寻边位。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    int axisBuf[4] = {0};
    axisBuf[1] = 1;
    int ret = AxisMoveSafeCheckXY(axisBuf,nullptr,nullptr);
    if(ret < 0)
    {
        emit exceptSGL(MyException(QString("晶碇与Z轴间距太小，不能执行动作。"),MY_WARN));
        return;
    }

    try
    {
        lastTaskIsFinish=false;
        lastTaskName="到寻边位";
        toEdgeSearchPosInSide();
        //toEdgeSearchPosThreadInSide();

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toEdgeSearchPosFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException(QString("到寻边位失败。"),mye.getExceptCode()));
    }
}

void DeviceProxy::toCompenTestPos()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化,未复位,无法执行到上料准备位。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行到上料准备位。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    try
    {
        lastTaskIsFinish=false;
        lastTaskName="到上料准备位";
        toCompenTestPosInSide();

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toCompenTestPosFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException(QString("到上料准备位失败。"),mye.getExceptCode()));
    }
}

void DeviceProxy::toRecordPos()
{
    if(!devIsReset)
    {
        emit exceptSGL(MyException(QString("设备未初始化,未复位,无法执行到记录位。请先复位。"),MY_WARN));
        return;
    }

    if(!lastTaskIsFinish)
    {
        emit exceptSGL(MyException(QString("%1任务执行中，无法执行到到记录位。请先停止运动或等待任务结束。").arg(lastTaskName),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    if(bRunning)
    {
        emit exceptSGL(MyException(QString("自动运行执行中，请等待运行结束。"),MY_WARN));
        return;
    }
    RS_SETTINGS->beginGroup("device/RecordPos");
    double ZAAxisPos = RS_SETTINGS->readNumDEntry("/ZAAxis");
    RS_SETTINGS->endGroup();

    if (ZAAxisPos < workpieceHeight)
    {
        emit exceptSGL(MyException(QString("目标Z轴位置，低于安全距离。"),MY_WARN));
        return;
    }

    try
    {
        lastTaskIsFinish=false;
        lastTaskName="到记录位";
        toRecordPosInSide();

        connect(this,SIGNAL(CMDRunFinishSGL()),this,SLOT(toRecordPosFHandl()));
        reqCMDRunFState = true;
    }
    catch (MyException mye)
    {
        exceptHandl(MyException(QString("到记录位失败。"),mye.getExceptCode()));
    }
}


//////////////////////////////////////////////////////////
void CDeviceProxyWorker::doWork_custom()
{
    int hasToBuffer = 0;
    while(1)
    {

        if (mParent->bRunning)
        {

            //DEV->ShowSmallAreasSGL();
            if (mParent->step >= mParent->fFileContent.count())
            {
                mParent->bRunning = false;
                //                mParent->vacuumSuckerCloseInSide();
                //                mParent->VacuumBreakOpen();
                mParent->bRunning = false;
                emit mParent->RunSGL(!mParent->bRunning);
                mParent->StepNameSGL(30);
                emit mParent->StopStateSGL(true);
                mParent->SuspendFlag = false;
                mParent->lastTaskIsFinish = true;
                mParent->reqCMDRunFState = false;
                DEV->workpieceHeight = DEV->Palletheight + MAXHEIGHT;
                mParent->step = 0;
                emit mParent->AutoSmachStateSGL(false);
                emit mParent->VacuumSuckerOnOrOffStateSGL(true);
                if (mParent->bUserPower)
                    emit mParent->SmachTypeStateSGL(true);
                DEVICE_INFO->printDeviceSystemInfo("自动加工完成！");
                continue;
            }
            QString aLineText=mParent->fFileContent.at(mParent->step); //获取数据区的一行
            //一个或多个空格、TAB等分隔符隔开的字符串， 分解为一个StringList
            QStringList tmpList=aLineText.split(",",QString::SkipEmptyParts);//",",QString::SkipEmptyParts
            QString StrIsEnable = tmpList.at(3);
            if (QString(StrIsEnable).toInt() == 0)
            {
                mParent->step = mParent->step + 1;
                continue;
            }
            try
            {
                mParent->mutex.lock();
                if (tmpList.at(0) == "上料")
                {
                    if (mParent->SuspendFlag)
                    {
                        mParent->mutex.unlock();
                        Sleep(10);
                        continue;
                    }
                    //                    if ((MODBUSTCP->PLCSts[0] != 4) || (MODBUSTCP->TransferPLCSts == 1))
                    //                    {
                    //                        emit mParent->AutoExceptSGL(MyException(QString("横移模块状态不满足要求，请确认状态后 点击 是 继续运行，点击 否 直接退出")));
                    //                        if (mParent->DataCheckFlag)
                    //                        {
                    //                            mParent->mutex.unlock();
                    //                            continue;
                    //                        }
                    //                        else
                    //                            throw MyException(QString("上料失败，横移模块未准备好！"),9011);
                    //                    }

                    {
                        mParent->StepNameSGL(1);
                        mParent->vacuumSuckerOpenInSide();
                        mParent->VacuumBreakClose();
                        Sleep(3000);

                        {//检查气压计读数是否符合要求

                            short value = 0;
                            if (BAROMETER->m_hComm == nullptr)
                            {
                                BAROMETER->getSerialSet("barometer");
                                bool ret = BAROMETER->OpenComm();
                                if (!ret)
                                {
                                    throw MyException(QString("气压计串口打开失败！"),9020);
                                }
                            }
                            int ret = BAROMETER->GetHeightValue(18,1,&value);
                            if (ret != 0)
                            {
                                throw MyException(QString("气压计读数失败！"),9021);
                            }
                            double tmp = value / 10.0;
                            if (tmp < -30)
                            {
                                throw MyException(QString("请先取走机台晶碇，再上料！"),9030);
                            }
                        }
                        mParent->vacuumSuckerCloseInSide();
                        mParent->VacuumBreakOpen();
                        //Sleep(1000);

                        mParent->lastTaskIsFinish = false;
                        mParent->reqCMDRunFState = true;
                        int ret = mParent->ShangProc();
                        if (ret != 0)
                        {
                            if (ret == -2)
                            {
                                emit mParent->AutoExceptSGL(MyException(QString("RFID读取失败，是否继续加工？")));
                                if (mParent->DataCheckFlag)
                                {
                                    //mParent->step = 2;
                                    //mParent->mutex.unlock();
                                    //continue;
                                }
                                else
                                    throw MyException(QString("RFID读取失败！"),9011);
                            }
                            else
                                throw MyException(QString("上料通讯失败！"),9010);
                        }
                        else
                        {
                            emit mParent->SETRfidText(MODBUSTCP->RFID);
                            if (strlen(MODBUSTCP->RFID) <= 1)
                            {
                                emit mParent->AutoExceptSGL(MyException(QString("RFID读取失败，是否继续加工？")));
                                if (mParent->DataCheckFlag)
                                {
                                    //mParent->step = 2;
                                    //mParent->mutex.unlock();
                                    //continue;
                                }
                                else
                                    throw MyException(QString("RFID读取失败！"),9011);
                            }
                            int chicun = MODBUSTCP->RFID[7] - '0';
                            int setChicun;
                            RS_SETTINGS->beginGroup("device/Type");
                            QString strType = RS_SETTINGS->readEntry("/value");
                            RS_SETTINGS->endGroup();
                            if (strType == "6寸")
                            {
                                setChicun = 6;
                            }
                            else if (strType == "8寸")
                            {
                                setChicun = 8;
                            }
                            else if (strType == "4寸")
                            {
                                setChicun = 4;
                            }
                            else
                                setChicun = 10000;
                            //if (DEV->ReadRfidFlag == 1)
                            {

                                if (chicun != setChicun)
                                {
                                    throw MyException(QString("晶碇编号尺寸和加工选择尺寸不一致"),9011);
                                }
                            }
                            if (setChicun == 10000)
                            {
                                throw MyException(QString("M片请手动加工！"),9011);
                            }

                            {//检查气压,如果需要读数失败重新读取功能，程序需要再if语句内增加 小步骤 功能
                                short value = 0;
                                if (BAROMETER->m_hComm == nullptr)
                                {
                                    BAROMETER->getSerialSet("barometer");
                                    bool ret = BAROMETER->OpenComm();
                                    if (!ret)
                                    {
                                        throw MyException(QString("气压计串口打开失败！"),9020);
                                    }
                                }

                                int ret = BAROMETER->GetHeightValue(18,1,&value);
                                if (ret != 0)
                                {
                                    //                                    emit mParent->AutoExceptSGL(MyException(QString("气压计读数失败，是否重新检测？")));
                                    //                                    if (mParent->DataCheckFlag)
                                    //                                    {
                                    //                                        //mParent->step = 2;
                                    //                                        mParent->mutex.unlock();
                                    //                                        continue;
                                    //                                    }
                                    //                                    else
                                    throw MyException(QString("气压计读数失败！"),9021);
                                }
                                double tmp = value / 10.0;
                                if (tmp > -60)
                                {
                                    //                                    emit mParent->VacuumSuckerOnOrOffStateSGL(true);
                                    //                                    emit mParent->AutoExceptSGL(MyException(QString("气压计压力不符合要求，是否重新检测？")));
                                    //                                    if (mParent->DataCheckFlag)
                                    //                                    {
                                    //                                        //mParent->step = 2;
                                    //                                        mParent->mutex.unlock();
                                    //                                        continue;
                                    //                                    }
                                    //                                    else
                                    throw MyException(QString("气压计压力不符合要求！"),9022);
                                }
                            }

                        }

                        mParent->lastTaskIsFinish = true;
                        mParent->reqCMDRunFState = false;
                        mParent->step = mParent->step + 1;

                    }
                }
                else if (tmpList.at(0) == "下料")
                {
                    if (mParent->SuspendFlag)
                    {
                        mParent->mutex.unlock();
                        Sleep(10);
                        continue;
                    }
                    //                    if ((MODBUSTCP->PLCSts[0] != 4) || (MODBUSTCP->TransferPLCSts == 2))
                    //                    {
                    //                        emit mParent->AutoExceptSGL(MyException(QString("横移模块状态不满足要求，请确认状态后 点击 是 继续运行，点击 否 直接退出")));
                    //                        if (mParent->DataCheckFlag)
                    //                        {
                    //                            mParent->mutex.unlock();
                    //                            continue;
                    //                        }
                    //                        else
                    //                            throw MyException(QString("下料失败，横移模块未准备好！"),9011);
                    //                    }

                    mParent->StepNameSGL(27);
                    mParent->lastTaskIsFinish = false;
                    mParent->reqCMDRunFState = true;

                    int ret = mParent->XiaProc();
                    if (ret != 0)
                    {
                        throw MyException(QString("下料通讯失败！"),9010);
                    }
                    mParent->lastTaskIsFinish = true;
                    mParent->reqCMDRunFState = false;
                    DEV->workpieceHeight = DEV->Palletheight + MAXHEIGHT;
                    mParent->step = mParent->step+1;
                }
                else if (tmpList.at(0) == "功率测量")
                {
                    if (mParent->SuspendFlag)
                    {
                        mParent->mutex.unlock();
                        continue;
                    }
                    if (hasToBuffer == 0)
                    {
                        mParent->StepNameSGL(2);

                        mParent->lastTaskIsFinish = false;
                        mParent->toLaserApTestPosInSide();
                        mParent->reqCMDRunFState = true;
                        hasToBuffer = 1;
                        emit mParent->VacuumSuckerOnOrOffStateSGL(false);
                    }
                    else
                    {
                        //检测buffer是否执行完毕？
                        if (!mParent->reqCMDRunFState)//buffer是否执行完毕
                        {
                            {
                                //检测功率
                                {
                                    float valueMath = 0;
                                    float valueLight = 0;
                                    int ret;
                                    mParent->StepNameSGL(3);
                                    mParent->LaserApValueP1 = 0;
                                    ret = IPGLASER->LaserClose();
                                    if (ret < 0)
                                    {
                                        if (!DEV->StopGonglvCheckFlag)
                                            throw MyException("激光器关闭失败。",acsc_GetLastError());
                                    }
                                    int paramnum = tmpList.at(1).toInt();
                                    if (paramnum < 1)
                                        throw MyException("功率检测参数无效！");
                                    ret = IPGLASER->SetParam(paramnum);
                                    if (ret < 0)
                                    {
                                        if (!DEV->StopGonglvCheckFlag)
                                            throw MyException("激光器设置参数失败。",acsc_GetLastError());
                                    }

                                    DEV->AirValveClose();
                                    int delayCount = 0;
                                    while(1)
                                    {
                                        Sleep(2);
                                        if ( DEV->StopGonglvCheckFlag)
                                        {
                                            break;
                                        }
                                        delayCount++;
                                        if (delayCount >= 1000)
                                            break;
                                    }
                                    if ( DEV->StopGonglvCheckFlag)
                                    {
                                        break;
                                    }
                                    if (delayCount < 1000)
                                        break;
                                    if (!DEV->airValveDiCloseSts)
                                    {
                                        if (!DEV->StopGonglvCheckFlag)
                                            throw MyException(QString("整形片位置错误！"),9030);
                                    }
                                    ret = IPGLASER->LaserOpen();
                                    if (ret < 0)
                                    {
                                        if (!DEV->StopGonglvCheckFlag)
                                            throw MyException("激光器打开失败。",acsc_GetLastError());
                                    }

                                    DEV->laserOpenInSide();
                                    delayCount = 0;

                                    while(1)
                                    {
                                        Sleep(15);
                                        if (DEV->StopGonglvCheckFlag)
                                        {
                                            break;
                                        }
                                        delayCount++;
                                        if (delayCount >= 1000)
                                            break;
                                    }
                                    if ( DEV->StopGonglvCheckFlag)
                                    {
                                        break;
                                    }
                                    if (delayCount < 1000)
                                        break;

                                    if (POWERMETERMACH->m_hComm == nullptr)
                                    {
                                        POWERMETERMACH->getSerialSet("jiagonggonglvji");
                                        bool ret = POWERMETERMACH->OpenComm();
                                        if (!ret)
                                        {
                                            DEV->laserClose();
                                            if (!DEV->StopGonglvCheckFlag)
                                                throw MyException(QString("加工功率计串口打开失败！"),9030);
                                        }

                                    }
                                    ret = POWERMETERMACH->GetValue(&valueMath);
                                    if (ret != 0)
                                    {
                                        DEV->laserClose();
                                        if (!DEV->StopGonglvCheckFlag)
                                            throw MyException(QString("加工功率计读数失败！"),9031);
                                    }


                                    //y = 4.6475* x + 0.0103

                                    if (POWERMETERLIGHT->m_hComm == nullptr)
                                    {
                                        POWERMETERLIGHT->getSerialSet("guanglugonglvji");
                                        bool ret = POWERMETERLIGHT->OpenComm();
                                        if (!ret)
                                        {
                                            DEV->laserClose();
                                            if (!DEV->StopGonglvCheckFlag)
                                                throw MyException(QString("光路功率计串口打开失败！"),9032);
                                        }

                                    }
                                    valueLight = 0;
                                    ret = POWERMETERLIGHT->GetValue(&valueLight);
                                    if (ret != 0)
                                    {
                                        DEV->laserClose();
                                        if (!DEV->StopGonglvCheckFlag)
                                            throw MyException(QString("光路功率计读数失败！"),9033);
                                    }

                                    mParent->LaserApValueP1 = valueLight;
                                    if ((valueLight >0) && (valueMath > 0.005))
                                    {
                                        //float tmpValue;
                                        //tmpValue = valueLight * 4.7567 - 0.0099;

                                        //tmpValue = valueLight * 4.9042 - 0.0381;
                                        //tmpValue = valueLight * 4.8267 - 0.0099;
                                        double tmpAp = IPGLASER->dstPower1;
                                        double piancha = fabs((tmpAp - valueMath*1000) / tmpAp * 100);
                                        if (piancha > 10)
                                        {

                                            {
                                                DEV->laserClose();
                                                if (!DEV->StopGonglvCheckFlag)
                                                    throw MyException(QString("光路异常，请检查光路！"),9034);
                                            }

                                        }
                                        else
                                        {
                                            if (mParent->LaserTestApFlag)
                                            {
                                                QString strInfo = QString("光路检测偏差 (%1%)").arg(piancha);
                                                emit mParent->AutoExceptSGL(MyException(strInfo));
                                            }
                                        }
                                    }
                                    else
                                    {
                                        {
                                            DEV->laserClose();
                                            if (!DEV->StopGonglvCheckFlag)
                                                throw MyException(QString("激光器未出光，请检查激光器！"),9034);
                                        }
                                    }

                                    DEV->laserClose();

                                }

                            }

                            mParent->step = mParent->step + 1;
                            hasToBuffer = 0;
                        }
                    }
                }
                else if (tmpList.at(0) == "对零")
                {
                    if (mParent->SuspendFlag)
                    {
                        mParent->mutex.unlock();
                        Sleep(10);
                        continue;
                    }
                    if (hasToBuffer == 0)
                    {
                        mParent->StepNameSGL(4);
                        mParent->lastTaskIsFinish = false;
                        mParent->toRSToZeroPosInSide();
                        mParent->compCloseInSide();
                        mParent->reqCMDRunFState = true;
                        hasToBuffer = 1;
                    }
                    else if (hasToBuffer == 1)
                    {
                        if (!mParent->reqCMDRunFState)//buffer是否执行完毕
                        {
                            mParent->StepNameSGL(5);
                            Sleep(1000);
                            mParent->lastTaskIsFinish = false;
                            mParent->RSToZeroInSide();
                            mParent->reqCMDRunFState = true;
                            hasToBuffer = 2;
                        }
                    }
                    else if (hasToBuffer == 2)
                    {
                        if (!mParent->reqCMDRunFState)//buffer是否执行完毕
                        {
                            mParent->step = mParent->step + 1;
                            mParent->workpieceHeight = mParent->ZAAxisCtPos;
                            hasToBuffer = 0;
                            //continue;
                        }
                    }

                }
                else if (tmpList.at(0) == "寻边")
                {
                    if (mParent->SuspendFlag)
                    {
                        mParent->mutex.unlock();
                        continue;
                    }
                    {
                        if (hasToBuffer == 0)
                        {
                            mParent->StepNameSGL(6);
                            mParent->lastTaskIsFinish = false;
                            mParent->toEdgeSearchPosInSide();
                            mParent->reqCMDRunFState = true;
                            hasToBuffer = 1;
                        }
                        else if (hasToBuffer == 1)
                        {
                            //检测buffer是否执行完毕？
                            if (!mParent->reqCMDRunFState)//buffer是否执行完毕
                            {
                                mParent->StepNameSGL(7);
                                int ret;
                                RS_SETTINGS->beginGroup("device/Type");
                                QString strType = RS_SETTINGS->readEntry("/value");
                                RS_SETTINGS->endGroup();
                                if (strType == "6寸")
                                {
                                    ret = DEV->FindEdgeThread_6();
                                }
                                else
                                {
                                    ret = DEV->FindEdgeThread();


                                }
                                if (DEV->StopFindEdgeFlag)
                                {
                                    throw MyException(QString("晶碇寻边失败！"),9070);
                                }
#if (JIADINGJIAGONG != 1)
                                if (ret != 0)   //lihongchang jia
                                {
                                    emit mParent->AutoExceptSGL(MyException(QString("晶碇寻边失败，是否重新检测？")));
                                    if (mParent->DataCheckFlag)
                                    {
                                        //mParent->step = 3;
                                        mParent->mutex.unlock();
                                        continue;
                                    }
                                    else
                                        throw MyException(QString("晶碇寻边失败！"),9070);
                                }
                                else
#endif
                                {
                                    hasToBuffer = 0;
                                    mParent->step = mParent->step + 1;
                                }
                            }
                        }

                    }
                }
                else if (tmpList.at(0) == "扫描")
                {
                    if (mParent->SuspendFlag)
                    {
                        mParent->mutex.unlock();
                        Sleep(10);
                        continue;
                    }
                    {
                        if (hasToBuffer == 0)
                        {
                            mParent->StepNameSGL(10);
                            {
                                short value = 0;
                                if (BAROMETER->m_hComm == nullptr)
                                {
                                    BAROMETER->getSerialSet("barometer");
                                    bool ret = BAROMETER->OpenComm();
                                    if (!ret)
                                    {
                                        emit mParent->AutoExceptSGL(MyException(QString("气压计串口打开失败！是否重新检测？")));
                                        if (mParent->DataCheckFlag)
                                        {
                                            mParent->mutex.unlock();
                                            continue;
                                        }
                                        else
                                        {
                                            //                                    if (mParent->pLaserMark != nullptr)
                                            //                                        mParent->pLaserMark->Abort();
                                            mParent->StepNameSGL(30);
                                            emit mParent->StopStateSGL(true);
                                            mParent->SuspendFlag = false;
                                            //mParent->laserClose();
                                            mParent->lastTaskIsFinish = true;
                                            mParent->reqCMDRunFState = false;
                                            mParent->step = 0;
                                            mParent->bRunning = false;
                                            emit mParent->RunSGL(!mParent->bRunning);

                                            emit mParent->AutoSmachStateSGL(false);
                                            emit mParent->VacuumSuckerOnOrOffStateSGL(true);
                                            if (mParent->bUserPower)
                                                emit mParent->SmachTypeStateSGL(true);
                                            mParent->mutex.unlock();
                                            continue;
                                        }
                                    }
                                }
                                int ret_BAROMETER = -1;
                                for (int i=0;i<5;i++)
                                {
                                    ret_BAROMETER = BAROMETER->GetHeightValue(18,1,&value);
                                    if (ret_BAROMETER == 0)
                                        break;
                                    else
                                        Sleep(100);

                                }
                                if (ret_BAROMETER != 0)
                                {
                                    emit mParent->AutoExceptSGL(MyException(QString("气压计读数失败！是否重新检测？")));
                                    if (mParent->DataCheckFlag)
                                    {
                                        mParent->mutex.unlock();
                                        continue;
                                    }
                                    else
                                    {
                                        //                                    if (mParent->pLaserMark != nullptr)
                                        //                                        mParent->pLaserMark->Abort();
                                        mParent->StepNameSGL(30);
                                        emit mParent->StopStateSGL(true);
                                        mParent->SuspendFlag = false;
                                        //mParent->laserClose();
                                        mParent->lastTaskIsFinish = true;
                                        mParent->reqCMDRunFState = false;
                                        mParent->step = 0;
                                        mParent->bRunning = false;
                                        emit mParent->RunSGL(!mParent->bRunning);

                                        emit mParent->AutoSmachStateSGL(false);
                                        emit mParent->VacuumSuckerOnOrOffStateSGL(true);
                                        if (mParent->bUserPower)
                                            emit mParent->SmachTypeStateSGL(true);
                                        mParent->mutex.unlock();
                                        continue;
                                    }
                                }
                                double tmp = value / 10.0;
                                if (tmp > -10)
                                {
                                    emit mParent->AutoExceptSGL(MyException(QString("真空压力值太小！是否重新检测？")));
                                    if (mParent->DataCheckFlag)
                                    {
                                        mParent->mutex.unlock();
                                        continue;
                                    }
                                    else
                                    {
                                        //                                    if (mParent->pLaserMark != nullptr)
                                        //                                        mParent->pLaserMark->Abort();
                                        mParent->StepNameSGL(30);
                                        emit mParent->StopStateSGL(true);
                                        mParent->SuspendFlag = false;
                                        //mParent->laserClose();
                                        mParent->lastTaskIsFinish = true;
                                        mParent->reqCMDRunFState = false;
                                        mParent->step = 0;
                                        mParent->bRunning = false;
                                        emit mParent->RunSGL(!mParent->bRunning);

                                        emit mParent->AutoSmachStateSGL(false);
                                        emit mParent->VacuumSuckerOnOrOffStateSGL(true);
                                        if (mParent->bUserPower)
                                            emit mParent->SmachTypeStateSGL(true);
                                        mParent->mutex.unlock();
                                        continue;
                                    }
                                }
                            }
                            mParent->lastTaskIsFinish = false;
                            mParent->toSScanStartPosInSide();
                            mParent->reqCMDRunFState = true;
                            hasToBuffer = 1;
                        }
                        else if (hasToBuffer == 1)
                        {
                            //检测buffer是否执行完毕？
                            if (!mParent->reqCMDRunFState)//buffer是否执行完毕
                            {
                                mParent->lastTaskIsFinish = false;
                                mParent->compSScanInSide();
                                mParent->reqCMDRunFState = true;
                                hasToBuffer = 2;
                            }
                        }
                        else if (hasToBuffer == 2)
                        {
                            //检测buffer是否执行完毕？
                            if (!mParent->reqCMDRunFState)//buffer是否执行完毕
                            {
                                if (JIADINGJIAGONG != 1)
                                {
                                    //mParent->lastTaskIsFinish = false;
                                    mParent->readCompSScanData();

                                    mParent->buildLookupTable();
                                    mParent->saveLookupTable();
                                    QVector<QVector<double>>().swap(mParent->lookupTable);
                                    mParent->buildLookupTable_lhc();
                                    //mParent->saveLookupTable_lhc();
                                    mParent->SScanDataCheck();
                                    mParent->lookupTableHeadEndDataHandl();
                                    //mParent->saveLookupTable_lhc();
                                    mParent->lookupTableHeadEndDataHandl_lhc2();
                                    mParent->saveLookupTable_lhc();
                                    try
                                    {
                                        mParent->SScanDataCheck_lhc();
                                    }
                                    catch (MyException mye)
                                    {
                                        emit mParent->AutoExceptSGL(MyException(QString("补偿面扫描数据校验失败,是否继续加工？")));
                                        if (mParent->DataCheckFlag)
                                            ;
                                        else
                                        {
                                            //                                    if (mParent->pLaserMark != nullptr)
                                            //                                        mParent->pLaserMark->Abort();
                                            mParent->StepNameSGL(30);
                                            emit mParent->StopStateSGL(true);
                                            mParent->SuspendFlag = false;
                                            //mParent->laserClose();
                                            mParent->lastTaskIsFinish = true;
                                            mParent->reqCMDRunFState = false;
                                            mParent->step = 0;
                                            mParent->bRunning = false;
                                            emit mParent->RunSGL(!mParent->bRunning);

                                            emit mParent->AutoSmachStateSGL(false);
                                            emit mParent->VacuumSuckerOnOrOffStateSGL(true);
                                            if (mParent->bUserPower)
                                                emit mParent->SmachTypeStateSGL(true);
                                            mParent->mutex.unlock();
                                            continue;
                                        }
                                    }
                                }
                                if (JIADINGJIAGONG != 1)
                                {
                                    mParent->MHCompOpenInSide();     //lihongchang  3处，b补偿 、加工开激光、寻边
                                    emit mParent->MHCompOpenFSGL();
                                    DEV->devPlaneScanCompState = 1;
                                }
                                mParent->step = mParent->step + 1;
                                hasToBuffer = 0;
                            }
                        }
                    }
                }
                else if (tmpList.at(0) == "打标")
                {
                    if (mParent->SuspendFlag)
                    {
                        mParent->mutex.unlock();
                        Sleep(10);
                        continue;
                    }
                    if (hasToBuffer == 0)
                    {
                        mParent->StepNameSGL(22);
                        mParent->lastTaskIsFinish = false;
                        //DEV->devLaserCheck = true;
                        mParent->toLaserMarkPosThreadInSide();
                        mParent->acsCtl->RToPointPos(DAXIS,180-PIANYIJIAODU+LASERMARKJIAODU);//90度，值不知道
                        Sleep(10);
                        mParent->reqCMDRunFState = true;
                        hasToBuffer = 1;
                    }
                    else if (hasToBuffer == 1)
                    {
                        if (!mParent->reqCMDRunFState)//buffer是否执行完毕
                        {
                            mParent->StepNameSGL(23);
                            if (mParent->pLaserMark != nullptr)
                            {

                                if (strlen(MODBUSTCP->RFID) > 1)
                                {
                                    QString str;//MODBUSTCP->RFID
                                    mParent->FanOpen();
                                    Sleep(200);
                                    mParent->pLaserMark->Start(MODBUSTCP->RFID,&str,1,true);
                                    char *code;
                                    QByteArray byCode = str.toLatin1();
                                    code = byCode.data();
                                    memset(MODBUSTCP->RFID,0,50);
                                    strcpy_s(MODBUSTCP->RFID,50,code);
                                    //memcpy_s(MODBUSTCP->RFID,50,code,strlen(code));
                                    //MODBUSTCP->RFID[strlen(code)] = 0;
                                    MODBUSTCP->ModbusWrite_force(MODBUSTCP->RFID,strlen(MODBUSTCP->RFID));
                                    Sleep(200);
                                    bool flag = false;
                                    QDateTime startTime=  QDateTime::currentDateTime();


                                    while(1)
                                    {
                                        flag = mParent->pLaserMark->GetMyMarkStatus();
                                        if (flag == false)
                                        {
                                            break;
                                        }
                                        QDateTime endTime=  QDateTime::currentDateTime();
                                        qint64 intervalTime = startTime.secsTo(endTime);
                                        if (intervalTime > 120)
                                            break;
                                        Sleep(200);
                                    }
                                }
                            }

                            Sleep(500);
                            mParent->FanClose();
                            mParent->step = mParent->step + 1;
                            hasToBuffer = 0;

                        }
                    }

                }
                else if (tmpList.at(0) == "加工")
                {
                    //lihongchang
                    if (mParent->SuspendFlag)
                    {
                        mParent->mutex.unlock();
                        Sleep(10);
                        continue;
                    }
                    {
                        if (hasToBuffer == 0)
                        {
                            mParent->StepNameSGL(13);
                            mParent->lastTaskIsFinish = false;
                            int ret;
                            //                            ret = IPGLASER->LaserClose();
                            //                            if (ret < 0)
                            //                            {
                            //                                if (!DEV->StopGonglvCheckFlag)
                            //                                    throw MyException("激光器关闭失败。",acsc_GetLastError());
                            //                            }
                            int paramnum = tmpList.at(1).toInt();
                            if (paramnum < 1)
                                throw MyException("功率检测参数无效！");

                            double p2k;
                            double p2b;
                            QString str;
                            if (paramnum == 1)
                            {
                                //                                RS_SETTINGS->beginGroup("device/Rposition");
                                //                                p2k = RS_SETTINGS->readNumDEntry("/p2k_t");
                                //                                p2b = RS_SETTINGS->readNumDEntry("/p2b_t");
                                //                                RS_SETTINGS->endGroup();
                                if (IPGLASER->PP_Enable == "0")
                                {
                                    IPGLASER->Power1 = QString::number(DEV->getPP(DEV->R_detection_pt,true), 'f', 3);
                                    mParent->ApPercentage = DEV->getPP(DEV->R_detection_pt,true);
                                }
                                else
                                {
                                    IPGLASER->Power1 = IPGLASER->Power1_set;
                                    mParent->ApPercentage = IPGLASER->Power1.toDouble();
                                }


                                //IPGLASER->Power1 = QString::number((DEV->R_detection_pt - p2b)/p2k, 'f', 3);
                            }
                            else
                            {
                                //                                RS_SETTINGS->beginGroup("device/Rposition");
                                //                                p2k = RS_SETTINGS->readNumDEntry("/p2k_s");
                                //                                p2b = RS_SETTINGS->readNumDEntry("/p2b_s");
                                //                                RS_SETTINGS->endGroup();

                                //IPGLASER->Power2 = QString::number((DEV->R_detection_ps - p2b)/p2k, 'f', 3);


                                if (IPGLASER->PP_Enable == "0")
                                {
                                    IPGLASER->Power2 = QString::number(DEV->getPP(DEV->R_detection_ps,false), 'f', 3);
                                    mParent->ApPercentage = DEV->getPP(DEV->R_detection_ps,false);
                                }
                                else
                                {
                                    IPGLASER->Power2 = IPGLASER->Power2_set;
                                    mParent->ApPercentage = IPGLASER->Power2.toDouble();
                                }


                            }
                            IPGLASER->SwitchMode(true);
                            ret = IPGLASER->SetParam(paramnum);
                            if (ret < 0)
                            {
                                if (!DEV->StopGonglvCheckFlag)
                                    throw MyException("激光器设置参数失败。",acsc_GetLastError());
                            }
                            paramnum = tmpList.at(2).toInt();
                            if (paramnum < 1)
                                throw MyException("加工文件参数无效！");
                            //这里读激光参数，读加工文件参数，做相应配置。
                            mParent->SMachInSide(paramnum);
                            mParent->reqCMDRunFState = true;
                            //mParent->ApPercentage = (DEV->R_detection_ps - p2b)/p2k;   //这个值不对，现在时序号，应该是百分比值   lihongchang
                            mParent->Mach_T_S_flag = paramnum;
                            hasToBuffer = 1;
                            DEV->devLaserCheck = true;
                        }
                        else
                        {
                            //检测buffer是否执行完毕？
                            if (!mParent->reqCMDRunFState)//buffer是否执行完毕
                            {
                                mParent->step = mParent->step + 1;
                                hasToBuffer = 0;
                                DEV->devLaserCheck = false;
                                mParent->compCloseInSide();
                                emit mParent->MHCompCloseFSGL();
                            }
                        }
                    }
                }
                else if (tmpList.at(0) == "晶锭预测量")
                {
                    if (mParent->SuspendFlag)
                    {
                        mParent->mutex.unlock();
                        Sleep(10);
                        continue;
                    }
                    mParent->StepNameSGL(34);
                    mParent->lastTaskIsFinish=false;
                    int ret = DEV->ElectricResistanceCheckThread();
                    mParent->lastTaskIsFinish=true;
                    if (DEV->StopElectricResistanceCheckFlag)
                    {
                        throw MyException(QString("停止按钮按下，晶锭预测量失败！"),9070);
                    }
                    if (ret < 0)
                    {
                        emit mParent->AutoExceptSGL(MyException(QString("晶锭预测量失败，是否重新检测？")));
                        if (mParent->DataCheckFlag)
                        {
                            //mParent->step = 3;
                            mParent->mutex.unlock();
                            continue;
                        }
                        else
                            throw MyException(QString("晶锭预测量失败！"),9070);
                    }

                    mParent->step = mParent->step + 1;
                }
                else if (tmpList.at(0) == "小面加工")
                {
                    if (mParent->SuspendFlag)
                    {
                        mParent->mutex.unlock();
                        Sleep(10);
                        continue;
                    }
                    if (hasToBuffer == 0)
                    {
                        mParent->StepNameSGL(35);
                        RS_SETTINGS->beginGroup("device/RecordPos");
                        RS_SETTINGS->writeEntry("/ZAxis", DEV->ZAxisCtPos);
                        RS_SETTINGS->writeEntry("/ZAAxis", DEV->ZAAxisCtPos);
                        RS_SETTINGS->endGroup();
                        mParent->lastTaskIsFinish=false;
                        int ret = DEV->GetGlobalPhotoThread();
                        if (DEV->StopElectricResistanceCheckFlag)
                        {
                            throw MyException(QString("停止按钮按下，自动拍照失败！"),9070);
                        }

                        emit DEV->ShowSmallAreasSGL();
                        if (mParent->DataCheckFlag)
                        {

                            int ret = IPGLASER->LaserClose();
                            if (ret < 0)
                            {
                                if (!DEV->StopGonglvCheckFlag)
                                    throw MyException("激光器关闭失败。",acsc_GetLastError());
                            }
                            //                            IPGLASER->Power2 = QString::number(DEV->getPP(DEV->R_detection_ps,false), 'f', 3);
                            //                            mParent->ApPercentage = DEV->getPP(DEV->R_detection_ps,false);
                            if (IPGLASER->PP_Enable == "0")
                            {
                                IPGLASER->Power2 = QString::number(DEV->getPP(DEV->R_detection_ps,false), 'f', 3);
                                mParent->ApPercentage = DEV->getPP(DEV->R_detection_ps,false);
                            }
                            else
                            {
                                IPGLASER->Power2 = IPGLASER->Power2_set;
                                mParent->ApPercentage = IPGLASER->Power2.toDouble();
                            }

                            ret = IPGLASER->SetParam(2);
                            if (ret < 0)
                            {
                                if (!DEV->StopGonglvCheckFlag)
                                    throw MyException("激光器设置参数失败。",acsc_GetLastError());
                            }
                            IPGLASER->SwitchMode(false);
                            //////////////////

                            DEV->lastTaskIsFinish=false;
                            DEV->lastTaskName="特定区域加工";
                            RS_SETTINGS->beginGroup("device/RecordPos");
                            double ZxisPos = RS_SETTINGS->readNumDEntry("/ZAxis");
                            double ZAxisPos = RS_SETTINGS->readNumDEntry("/ZAAxis");
                            RS_SETTINGS->endGroup();
                            DEV->acsCtl->ABSToPoint(ZAXIS,ZxisPos);
                            DEV->acsCtl->ABSToPoint(ZAAXIS,ZAxisPos);
                            Sleep(20);
                            bool motorstsZ,motorstsZA;
                            while(1)
                            {
                                motorstsZ = DEV->acsCtl->getMotorState(ZAXIS);
                                motorstsZA = DEV->acsCtl->getMotorState(ZAAXIS);
                                if (motorstsZ)
                                    break;
                                if (DEV->StopElectricResistanceCheckFlag)
                                {
                                    DEV->acsCtl->halt(ZAXIS);
                                    DEV->acsCtl->halt(ZAAXIS);
                                    break;
                                }
                                Sleep(20);
                            }

                            //mParent->ApPercentage = (DEV->R_detection_ps - p2b)/p2k;   //这个值不对，现在时序号，应该是百分比值   lihongchang
                            mParent->Mach_T_S_flag = 2;
                            //DEV->devLaserCheck = true;  //小面加工不检测功率

                            DEV->MachSmallAreaInSide();

                            DEV->reqCMDRunFState = true;
                            hasToBuffer = 1;
                        }
                        else
                        {
                            mParent->step = mParent->step + 1;
                            hasToBuffer = 0;
                        }


                    }
                    else
                    {
                        if (!mParent->reqCMDRunFState)//buffer是否执行完毕
                        {
                            mParent->step = mParent->step + 1;
                            //DEV->devLaserCheck = false;
                            hasToBuffer = 0;
                        }
                    }
                    //DEV->ShowSmallAreasSGL();


                }
                else if (tmpList.at(0) == "DD马达")
                {
                    if (mParent->SuspendFlag)
                    {
                        mParent->mutex.unlock();
                        Sleep(10);
                        continue;
                    }
                    bool motorsts;
                    double paramnum = tmpList.at(1).toDouble();
                    mParent->acsCtl->RToPointPos(DAXIS,paramnum);//90度，值不知道
                    Sleep(10);
                    while(1)
                    {

                        motorsts = mParent->acsCtl->getMotorState(DAXIS);
                        if (motorsts)
                            break;
                        if (mParent->StopFindEdgeFlag)
                        {
                            //acsCtl->stopBuffer(DAXIS);
                            mParent->acsCtl->halt(DAXIS);
                            break;
                        }
                        Sleep(1);
                    }
                    mParent->step = mParent->step + 1;
                }
                else
                {

                }



                mParent->mutex.unlock();
            }
            catch (MyException mye)
            {
                if (mParent->pLaserMark != nullptr)
                    mParent->pLaserMark->Abort();
                mParent->StepNameSGL(30);
                emit mParent->StopStateSGL(true);
                mParent->SuspendFlag = false;
                mParent->laserClose();
                //mParent->vacuumSuckerCloseInSide();
                //mParent->VacuumBreakOpen();
                mParent->lastTaskIsFinish = true;
                mParent->reqCMDRunFState = false;
                mParent->step = 0;
                mParent->bRunning = false;
                emit mParent->RunSGL(!mParent->bRunning);
                mParent->mutex.unlock();
                emit mParent->AutoSmachStateSGL(false);
                emit mParent->VacuumSuckerOnOrOffStateSGL(true);
                if (mParent->bUserPower)
                    emit mParent->SmachTypeStateSGL(true);
                mParent->exceptHandl_thread(MyException(mye.getExceptInfo() + ",半自动加工失败。",mye.getExceptCode()));

            }

        }
        else
        {
            hasToBuffer = 0;
        }
        Sleep(5);
    }
}

void DeviceProxy::LoadFromCsv(QString fileName)
{

    QFile file(fileName);

    /*如果以ReadWrite方式打开，不会把所有数据清除，若文件原来的长度为100字节，写操作写入了30字节，那还剩余70字节，并且这70字节和文件打开之前保持一致*/
    if(!file.open(QIODevice::ReadOnly))
    {
        qDebug()<<"请正确选择csv文件";
        return;
    }

    QTextStream * read = new QTextStream(&file);
    QStringList Data = read->readAll().split("\n",QString::SkipEmptyParts);   //每行以\n区分

    QVector<QVector<double>>().swap(lookupTable);

    for(int i=0;i<Data.count();++i)
    {
        QVector<double> lookupTableLine;
        QStringList strLine = Data.at(i).split(",");     //一行中的单元格以，区分
        for(int j=0; j<strLine.size()-1; j++)
            lookupTableLine.append(strLine.at(j).toDouble());
        lookupTable.append(lookupTableLine);                      //打印出每行的第一个单元格的数据

    }
    saveLookupTable_load();
    //关闭文件
    file.close();
}
void DeviceProxy::detectionZZAAxisPos()
{
    if (ZZAPosCheckFlag)
    {
        double safeLen = workpieceHeight - 5;
        //if ((ZAxisCtPos + ZAAxisCtPos) < workpieceHeight)
        if ((ZAAxisCtPos < safeLen) || ((ZAAxisCtPos + ZAxisCtPos - ZWORKPOS) < safeLen))
        {
            acsCtl->halt(ZAAXIS);
            acsCtl->halt(ZAXIS);

            lastTaskIsFinish=true;
            ZZAPosCheckFlag = false;
            emit exceptSGL(MyException(QString("碇与轴间距小于安全距离，停止运动！")));
        }
    }
}
int DeviceProxy::AxisMoveSafeCheckXY(int axisBuf[4],double distPos[4],int moveMode[2])
{
    RS_SETTINGS->beginGroup("device/ABSMove/Safe");
    double X1 = RS_SETTINGS->readNumDEntry("/X1");
    double X2 = RS_SETTINGS->readNumDEntry("/X2");
    double Y1 = RS_SETTINGS->readNumDEntry("/Y1");
    double Y2 = RS_SETTINGS->readNumDEntry("/Y2");
    RS_SETTINGS->endGroup();
    double safeLen = workpieceHeight - 5;
    //    double XAxisCtPos{0.0};
    //    double YAxisCtPos{0.0};
    //    double ZAxisCtPos{0.0};
    //    double ZAAxisCtPos{0.0};

    if (((axisBuf[0] == 1) || (axisBuf[1] == 1)) && ((axisBuf[2] == 0) && (axisBuf[3] == 0)))
    {
        if ((ZAAxisCtPos < safeLen) || ((ZAAxisCtPos + ZAxisCtPos - ZWORKPOS) < safeLen))
            return -1;
        else
            return 0;
    }
    else if (((axisBuf[0] == 1) || (axisBuf[1] == 1)) && ((axisBuf[2] == 1) || (axisBuf[3] == 1)))
    {
        if ((ZAAxisCtPos < safeLen) || ((ZAAxisCtPos + ZAxisCtPos - ZWORKPOS) < safeLen))
            return -1;
        else
        {
            if (((axisBuf[0] == 1) && ((distPos[0] >= X1) && (distPos[0] <= X2) )) &&
                    ((axisBuf[1] == 1) && ((distPos[1] >= Y1) && (distPos[1] <= Y2) )))
            {
                if ((axisBuf[2] == 1) && (axisBuf[3] == 0))
                {
                    {
                        if ((distPos[2] + ZAAxisCtPos) < safeLen)
                            return -1;
                        else
                            return 0;
                    }

                }
                else if ((axisBuf[2] == 0) && (axisBuf[3] == 1))
                {
                    {
                        if ((ZAAxisCtPos + distPos[3] + ZAxisCtPos - ZWORKPOS) < safeLen)
                            return -1;
                        else
                            return 0;
                    }
                }
                else if ((axisBuf[2] == 1) && (axisBuf[3] == 1))
                {
                    if ((distPos[2] < safeLen) || ((distPos[2] + distPos[3] - ZWORKPOS) < safeLen))
                        return -1;
                    else
                        return 0;
                }
            }

        }

    }
    else if (((axisBuf[0] == 0) && (axisBuf[1] == 0)) && ((axisBuf[2] == 1) || (axisBuf[3] == 1)))
    {
        if (((XAxisCtPos >= X1) && (XAxisCtPos <= X2)) && ((YAxisCtPos >= Y1) && (YAxisCtPos <= Y2)))
        {
            if ((axisBuf[2] == 1) && (axisBuf[3] == 0))
            {
                if (moveMode[0] == 0)//位置模式
                {
                    if ((ZAAxisCtPos + distPos[2]) < safeLen)
                        return -1;
                    else
                        return 0;
                }
                else
                {
                    if ((ZAAxisCtPos < safeLen) || ((ZAAxisCtPos + ZAxisCtPos - ZWORKPOS) < safeLen))
                        return -1;
                    else
                    {
                        ZZAPosCheckFlag = true;//置标记，运动时时刻判断zza
                        return 0;
                    }

                }
            }
            else if ((axisBuf[2] == 0) && (axisBuf[3] == 1))
            {
                if (moveMode[1] == 0)//位置模式
                {
                    if ((distPos[3] + ZAxisCtPos) < safeLen)
                        return -1;
                    else
                        return 0;
                }
                else
                {
                    if ((ZAAxisCtPos < safeLen) || ((ZAAxisCtPos + ZAxisCtPos - ZWORKPOS) < safeLen))
                        return -1;
                    else
                    {
                        ZZAPosCheckFlag = true;//置标记，运动时时刻判断zza
                        return 0;
                    }
                }
            }
            else if ((axisBuf[2] == 1) && (axisBuf[3] == 1))
            {
                if ((distPos[2] < safeLen) || ((distPos[2] + distPos[3] - ZWORKPOS) < safeLen))
                    return -1;
                else
                    return 0;
            }
        }
        else
            return 0;
    }
    return 0;
}

int DeviceProxy::ShangProc(void)
{

    int step = 0;
    int ret = 0;
    int  result = 0;
    bool connFlag;
    //connFlag = MODBUSTCP->ConnPLC();
    //    if (!connFlag)
    //    {
    //        return -1;
    //    }
    MODBUSTCP->stopFlag = false;
    bool hasToBuffer = false;
    int count = 0;
    while (1)
    {
        //        ret = MODBUSTCP->ModbusRead(MODBUSTCP->shangWriteHeartbeatAddr, 1);
        //        if (ret !=  0)
        //            count++;
        //        else
        //            count = 0;
        //        if (count >= 3)
        //        {
        //            DEVICE_INFO->printDeviceSystemInfo("分离模块不在线，退出上料过程");
        //            return -1;
        //        }
        //        Sleep(100);
        if (MODBUSTCP->PLCSts[0] != 4)
        {
            DEVICE_INFO->printDeviceSystemInfo("横移模块不在运行状态，退出上料过程");
            return -1;
        }


        if (step == 0)
        {
            if (!hasToBuffer)
            {
                bAutoLoadUnloadFlag = false;
                //DEV->lastTaskIsFinish = false;
                toCompenTestPosInSide();
                reqCMDRunFState = true;
                hasToBuffer = true;
            }
            else
            {
                //检测buffer是否执行完毕？
                if (!reqCMDRunFState)//buffer是否执行完毕
                {
                    step = step + 1;
                    hasToBuffer = false;
                    //continue;
                }
                else
                {
                    //continue;
                }

            }

        }
        else if (step == 1)
        {
            ret = MODBUSTCP->ModbusWrite(0x06,MODBUSTCP->xiaWriteAddr, 0);
            Sleep(100);
            ret = MODBUSTCP->ModbusWrite(0x06,MODBUSTCP->shangWriteAddr, 1);
            if (ret != 0)
            {
                result = -1;
                break;
            }
            else
                step++;
        }
        else if (step == 2)
        {
            ret = MODBUSTCP->ModbusRead(MODBUSTCP->shangReadAddr,1);
            if (ret < 0)
            {
                result = -1;
                break;
            }
            else
            {
                DEVICE_INFO->printDeviceSystemInfo(QString("请求11命令，现返回：%1").arg(QString::number(ret)));
                if (ret == 11)
                {
                    int tmp;
                    tmp = MODBUSTCP->ModbusWrite(0x06,MODBUSTCP->shangWriteAddr, 0);
                    if (tmp != 0)
                    {
                        result = -1;
                        break;
                    }
                    else
                    {
                        step++;
                    }
                }
            }
        }
        else if (step == 3)
        {
            if (!hasToBuffer)
            {
                bAutoLoadUnloadFlag = true;
                //DEV->lastTaskIsFinish = false;
                toCompenTestPosInSide();
                reqCMDRunFState = true;
                hasToBuffer = true;
            }
            else
            {
                //检测buffer是否执行完毕？
                if (!reqCMDRunFState)//buffer是否执行完毕
                {
                    step = step + 1;
                    hasToBuffer = false;
                    //continue;
                }
            }
        }
        else if (step == 4)
        {
            ret = MODBUSTCP->ModbusWrite(0x06,MODBUSTCP->shangWriteAddr, 2);
            if (ret != 0)
            {
                result = -1;
                break;
            }
            else
                step++;
        }
        else if (step == 5)
        {
            ret = MODBUSTCP->ModbusRead(MODBUSTCP->shangReadAddr,1);
            if (ret < 0)
            {
                result = -1;
                break;
            }
            else
            {
                if (ret == 12)
                {
                    int tmp;
                    tmp = MODBUSTCP->ModbusWrite(0x06,MODBUSTCP->shangWriteAddr, 0);
                    if (tmp != 0)
                    {
                        result = -1;
                        break;
                    }
                    else
                    {
                        step++;
                    }

                }
            }
        }
        else if (step == 6)
        {

            if (!hasToBuffer)
            {
                //Sleep(2000);
                vacuumSuckerOpen();//开真空,然后延时等待开真空生效
                VacuumBreakClose();
                Sleep(2000);
                bAutoLoadUnloadFlag = false;
                //DEV->lastTaskIsFinish = false;
                toCompenTestPosInSide();
                reqCMDRunFState = true;
                hasToBuffer = true;
            }
            else
            {
                //检测buffer是否执行完毕？
                if (!reqCMDRunFState)//buffer是否执行完毕
                {
                    step = step + 1;
                    hasToBuffer = false;
                    //continue;
                }
            }
        }
        else if (step == 7)
        {
            ret = MODBUSTCP->ModbusWrite(0x06,MODBUSTCP->shangWriteAddr, 3);
            if (ret != 0)
            {
                result = -1;
                break;
            }
            else
            {
                step = step + 1;//result = 0;  //这里跳出，如果加入读RFID，这里step++
                //break;
            }
        }
        else if (step == 8)
        {

            ret = MODBUSTCP->ModbusRead(MODBUSTCP->shangReadRFIDAddr,RFIDCount/2 + 1);
            if (ret < 0)
            {
                result = -2;
                break;
            }
            else
            {
                MODBUSTCP->RFID[RFIDCount] = 0;
                emit SETRfidText(MODBUSTCP->RFID);
                result = 0;
                break;
            }
        }
        //Sleep(100);
        //MODBUSTCP->ModbusWrite(0x06,MODBUSTCP->shangWriteHeartbeatAddr, 1);
        Sleep(500);

        if (MODBUSTCP->stopFlag)
        {
            result = 1;
            break;
        }
        //1、发送命令上料   1
        //2、读取夹爪已到位
        //3、X轴到位，然后Y轴到位，发送命令已送到位 2
        //4、读取已放好信号
        //5、开真空，发送已开真空。Y到准备位，发送已取走，开始加工 3
    }
    //MODBUSTCP->CloseConn();
    if (result == 0)
    {
        DEVICE_INFO->printDeviceSystemInfo("上料完成");
    }
    else
    {
        DEVICE_INFO->printDeviceSystemInfo("上料失败");
    }
    return result;


}


int DeviceProxy::XiaProc(void)
{

    int step = 0;
    int ret = 0;
    int  result = 0;
    //    bool connFlag;
    //    connFlag = MODBUSTCP->ConnPLC();
    //    if (!connFlag)
    //    {
    //        return -1;
    //    }
    MODBUSTCP->stopFlag = false;
    bool hasToBuffer = false;
    //1、发送命令下料
    //2、读取夹爪已到位
    //3、X轴到位，然后Y轴到位，发送命令已送到位
    //4、读取夹爪已夹紧信号
    //5、开破真空，延时，Y轴到准备位，发送Y轴已离开
    int count = 0;
    while (1)
    {
        //        ret = MODBUSTCP->ModbusRead(MODBUSTCP->shangWriteHeartbeatAddr, 1);
        //        if (ret !=  0)
        //            count++;
        //        else
        //            count = 0;
        //        if (count >= 3)
        //        {
        //            DEVICE_INFO->printDeviceSystemInfo("分离模块不在线，退出下料过程");
        //            return -1;
        //        }
        //        Sleep(100);
        if (MODBUSTCP->PLCSts[0] != 4)
        {
            DEVICE_INFO->printDeviceSystemInfo("横移模块不在运行状态，退出下料过程");
            return -1;
        }
        if (step == 0)
        {
            if (!hasToBuffer)
            {
                bAutoLoadUnloadFlag = false;
                //DEV->lastTaskIsFinish = false;
                toCompenTestPosInSide();
                reqCMDRunFState = true;
                hasToBuffer = true;
            }
            else
            {
                //检测buffer是否执行完毕？
                if (!DEV->reqCMDRunFState)//buffer是否执行完毕
                {
                    step = step + 1;
                    hasToBuffer = false;
                    //continue;
                }
            }

        }
        else if (step == 1)
        {
            ret = MODBUSTCP->ModbusWrite(0x06,MODBUSTCP->shangWriteAddr, 0);
            Sleep(100);
            ret = MODBUSTCP->ModbusWrite(0x06,MODBUSTCP->xiaWriteAddr, 21);
            if (ret != 0)
            {
                result = -1;
                break;
            }
            else
                step++;
        }
        else if (step == 2)
        {
            ret = MODBUSTCP->ModbusRead(MODBUSTCP->xiaReadAddr,1);
            if (ret < 0)
            {
                result = -1;
                break;
            }
            else
            {
                //QString str;
                //str = QString("请求31命令，现返回：%1").arg(QString::number(ret));
                DEVICE_INFO->printDeviceSystemInfo(QString("请求31命令，现返回：%1").arg(QString::number(ret)));
                if (ret == 31)
                {
                    int tmp;
                    tmp = MODBUSTCP->ModbusWrite(0x06,MODBUSTCP->xiaWriteAddr, 0);
                    if (tmp != 0)
                    {
                        result = -1;
                        break;
                    }
                    else
                    {
                        step++;
                    }
                }
            }
        }
        else if (step == 3)
        {
            if (!hasToBuffer)
            {
                bAutoLoadUnloadFlag = true;
                toCompenTestPosInSide();
                reqCMDRunFState = true;
                hasToBuffer = true;
            }
            else
            {
                //检测buffer是否执行完毕？
                if (!reqCMDRunFState)//buffer是否执行完毕
                {
                    step = step + 1;
                    hasToBuffer = false;
                    //continue;
                }
            }
        }
        else if (step == 4)
        {
            vacuumSuckerClose();//关真空,然后延时等待开真空生效
            VacuumBreakOpen();
            Sleep(2000);
            ret = MODBUSTCP->ModbusWrite(0x06,MODBUSTCP->xiaWriteAddr, 22);
            if (ret != 0)
            {
                result = -1;
                break;
            }
            else
                step++;
        }
        else if (step == 5)
        {
            ret = MODBUSTCP->ModbusRead(MODBUSTCP->xiaReadAddr,1);
            if (ret < 0)
            {
                result = -1;
                break;
            }
            else
            {
                if (ret == 32)
                {
                    int tmp;
                    tmp = MODBUSTCP->ModbusWrite(0x06,MODBUSTCP->xiaWriteAddr, 0);
                    if (tmp != 0)
                    {
                        result = -1;
                        break;
                    }
                    else
                    {
                        step++;
                    }

                }
            }
        }
        else if (step == 6)
        {

            if (!hasToBuffer)
            {

                bAutoLoadUnloadFlag = false;
                //DEV->lastTaskIsFinish = false;
                toCompenTestPosInSide();
                reqCMDRunFState = true;
                hasToBuffer = true;
            }
            else
            {
                //检测buffer是否执行完毕？
                if (!reqCMDRunFState)//buffer是否执行完毕
                {
                    step = step + 1;
                    hasToBuffer = false;
                    //continue;
                }
            }
        }
        else if (step == 7)
        {
            ret = MODBUSTCP->ModbusWrite(0x06,MODBUSTCP->xiaWriteAddr, 23);
            if (ret != 0)
            {
                result = -1;
                break;
            }
            else
            {
                step = step + 1;//result = 0;  //这里跳出，如果加入写高度，这里step++
                break;
            }
        }
        else if (step == 8)
        {

            ret = MODBUSTCP->ModbusWrite(0x06,MODBUSTCP->xiaWriteHeightAddr,(unsigned short)(workpieceHeight - Palletheight) * 100);
            if (ret < 0)
            {
                result = -1;
                break;
            }
            else
            {
                result = 0;
                break;
            }
        }
        //DEV->workpieceHeight = DEV->Palletheight + MAXHEIGHT;
        //        ret = MODBUSTCP->ModbusWrite(0x06,MODBUSTCP->xiaWriteHeightAddr,workpieceHeight - Palletheight);
        //        if (ret < 0)
        //        {
        //            result = -1;
        //            break;
        //        }
        //        else
        //        {
        //            result = 0;
        //            break;
        //        }

        //        Sleep(100);
        //        MODBUSTCP->ModbusWrite(0x06,MODBUSTCP->shangWriteHeartbeatAddr, 1);

        Sleep(500);
        if (MODBUSTCP->stopFlag)
        {
            result = 1;
            break;
        }

    }
    //MODBUSTCP->CloseConn();
    if (result == 0)
    {
        DEVICE_INFO->printDeviceSystemInfo("下料完成");
    }
    else
    {
        DEVICE_INFO->printDeviceSystemInfo("下料失败");
    }
    return result;


}
int  DeviceProxy::UpdateWorkData()
{
    QString ModeName;
    QString aFileName;
    //if (flag == 1)
    {
        RS_SETTINGS->beginGroup("device/WorkFile"); //?path读不到
        ModeName = RS_SETTINGS->readEntry("/workfilename");
        RS_SETTINGS->endGroup();
    }
    //    else
    //        aFileName = ".\\WorkFile\\PowerDetection.WI";


    if (ModeName.isEmpty())
        return -1; //如果未选择文件，退出
    ModeName = "/" + ModeName;
    RS_SETTINGS->beginGroup("device/WorkFile"); //?path读不到
    aFileName = RS_SETTINGS->readEntry(ModeName);
    RS_SETTINGS->endGroup();

    QFile aFile(aFileName); //以文件方式读出
    if (aFile.open(QIODevice::ReadOnly)) //以只读文本方式打开文件
    {
        //        QTextStream aStream(&aFile); //用文本流读取文件
        //        DEV->fFileContent.clear();
        //        while (!aStream.atEnd())
        //        {
        //            QString str=aStream.readLine();//读取文件的一行
        //            DEV->fFileContent.append(str); //添加到 StringList
        //        }
        //        aFile.close();//关闭文件
        QString lineStr;
        QTextStream aStream(&aFile); //用文本流读取文件
        while (!aStream.atEnd())
        {
            lineStr += aStream.readLine();
        }
        aFile.close();//关闭文件
        std::string cstr;
        cstr = std::string((const char *)lineStr.toLocal8Bit());
        using base64 = cppcodec::base64_rfc4648;
        std::vector<uint8_t> decoded = base64::decode(cstr);
        std::string deStr(decoded.begin(), decoded.end());
        QString qstring;
        qstring = QString(QString::fromLocal8Bit(deStr.c_str()));

        fFileContent = qstring.split("\n");
        fFileContent.removeAll("");
        aFile.close();//关闭文件
    }
    else
        return -1;
    return 0;
}
int  DeviceProxy::deCode_file(QString strFileName)
{
    QFile f(strFileName);
    if(!f.open(QIODevice::ReadOnly | QIODevice::Text))
    {
        return -1;
    }
    QTextStream txtInput(&f);
    QString lineStr;
    while(!txtInput.atEnd())
    {
        lineStr += txtInput.readLine();

    }
    f.close();
    std::string cstr;
    cstr = std::string((const char *)lineStr.toLocal8Bit());

    using base64 = cppcodec::base64_rfc4648;
    std::vector<uint8_t> decoded = base64::decode(cstr);
    std::string deStr(decoded.begin(), decoded.end());

    deCodeString = QString(QString::fromLocal8Bit(deStr.c_str()));
    return 0;
}


//ZA安全高度增加2.5、托盘高度增加2.5、功率测量位高2.5、z1轴回零偏差设置-2.5
//
//激光参数设置可选择参数组，整形片一个输出控制,功率检测后，真空吸盘按钮未启用.PID偏差，显示正负