#include "machine.h"

QByteArray g_receiveBuff;
DataExFuns g_exfuns = {NULL,NULL,NULL,NULL,NULL};

// 发送数据
int operatorSendData(u8 * pDatBuf, int len)
{
    if (pDatBuf != NULL && len != 0)
    {
        // 不准备通过该函数发送数据
    }
    return 0;
}

// 得到发送缓冲区空闲长度
int operatorGetSdFreeLen(void)
{
    return 0;  // 认没有空间
}

// 接收数据
int operatorGetData(u8 * pDat, int expectLen)
{
    int len = g_receiveBuff.size();
    if (len > expectLen)
    {
        len = expectLen;
    }

    //if (len != 0 && pDat != NULL)
    if (len == expectLen && pDat != NULL)  //使len等于expectLen(串口下接收数据暴露的问题)
    {
        memcpy(pDat, g_receiveBuff.data(), len);
        g_receiveBuff.remove(0, len);
    }
    else
    {
        len = 0;
    }

    return len;
}

// 已接收数据长度
int operatorGetRsLen(void)
{
    return g_receiveBuff.size();
}

void delayMs(u32 ms)
{
    QDateTime oldTime, curTime;
    oldTime = QDateTime::currentDateTime();
    while(1)
    {
        curTime = QDateTime::currentDateTime();
        if(oldTime.msecsTo(curTime) > ms)
        {
            break;
        }
    }
}

void initDataExFuns(void)
{
    g_exfuns.sendCommData = operatorSendData;
    g_exfuns.getCommData = operatorGetData;
    g_exfuns.getRsvLen = operatorGetRsLen;
    g_exfuns.getTrsFreeLen = operatorGetSdFreeLen;

    g_exfuns.delay = delayMs;
}

Machine::Machine(QObject *parent) : QObject(parent)
{
    m_connected = 0;
    m_mcParaEn = 0;
    m_wkParaEn = 0;
    m_transBreak = 0;

    m_pTcpClient = new TcpClient();
    m_pTcpBmpThread = new QThread();
    m_pCreatPrintDat = new CreatPrintBmp();
    m_mcPrintInfo.clear();

    memset(&m_transCtrl, 0, sizeof(FileTransCtrl));     // 文件传输信息
    m_transCtrl.pAppHead  = new AppFileHead;
    m_transCtrl.pBmpHead  = new CompBmpHead;
    m_transCtrl.pDatBuff  = new u8[MAX_FILE_SIZE];

    m_pPlotFileList = new PlotFileList();
    memset(m_pPlotFileList,0,sizeof(PlotFileList));

    m_pCompBmpHead = new CompBmpHead();
    memset(m_pCompBmpHead,0,sizeof(CompBmpHead));

    m_pSendTimer = new QTimer(this);
    m_pSendTimer->setInterval(100);    // 设置定时间隔100毫秒
    connect(m_pSendTimer, SIGNAL(timeout()), this, SLOT(onSendTimer()));
    initDataExFuns();
}

Machine::~Machine()
{
    if(m_pTcpBmpThread != NULL)
    {
        m_pTcpBmpThread->quit();
        m_pTcpBmpThread->wait();
        delete m_pTcpBmpThread;
    }

    if(m_pSendTimer != NULL)
    {
        m_pSendTimer->stop();
        delete m_pSendTimer;
        m_pSendTimer = NULL;
    }

    if (m_transCtrl.pAppHead != NULL)
    {
        delete []m_transCtrl.pAppHead;
        m_transCtrl.pAppHead = NULL;
    }

    if (m_transCtrl.pBmpHead != NULL)
    {
        delete []m_transCtrl.pBmpHead;
        m_transCtrl.pBmpHead = NULL;
    }

    if (m_transCtrl.pDatBuff != NULL)
    {
        delete []m_transCtrl.pDatBuff;
        m_transCtrl.pDatBuff = NULL;
    }
}

void Machine::startFileTrans(FileTransCtrl &transCtrl)
{
    int rslt;
    OperPacket sendPacket;
    memset(&sendPacket, 0, sizeof(OperPacket));
    sendPacket.startTrans.cmdCode = UCMD_START_TRANS;
    sendPacket.startTrans.fileType = transCtrl.fileType;
    sendPacket.startTrans.fileIdx = transCtrl.fileIdx;
    sendPacket.startTrans.fileId = transCtrl.fileId;

    if(transCtrl.fileType == FILE_TYPE_PLOT)
    {
        rslt = packetAVLDP(&sendPacket.packet, (u8*)transCtrl.pBmpHead, sizeof(CompBmpHead));
    }

    if (rslt == 0)
    {
        QByteArray dat((char*)(&sendPacket.packet), LEN_NORMAL_PACKET+sizeof(CompBmpHead));
        emit(siSendData(dat));
    }
}

void Machine::startFileDyTrans(FileTransCtrl &transCtrl)
{
    int rslt = -1;
    OperPacket sendPacket;
    memset(&sendPacket, 0, sizeof(OperPacket));
    sendPacket.startTrans.cmdCode = UCMD_START_TRANS;
    sendPacket.startTrans.fileType = transCtrl.fileType;
    sendPacket.startTrans.fileIdx = transCtrl.fileIdx;
    sendPacket.startTrans.fileId = transCtrl.fileId;

    if( transCtrl.fileType == FILE_TYPE_DAT)
    {
        //rslt = packetAVLDP(&sendPacket.packet, (u8*)transCtrl.pFileHead, sizeof(DataDs16FileHead));
    }
    else
    {
        return ;
    }

    if (rslt == 0)
    {
        if( transCtrl.fileType == FILE_TYPE_DAT)
        {

        }
    }
}

// 文件数据传输
void Machine::transFileData(FileTransCtrl &transCtrl, int pktidx)
{
    int rslt;
    int actsize;
    u8 buff[MAX_EXDP_LEN];

    if (pktidx < 0 || transCtrl.pDatBuff == NULL)
    {
        return;
    }

    OperPacket sendPacket;
    memset(&sendPacket, 0, sizeof(OperPacket));
    sendPacket.transFileData.cmdCode = UCMD_TRANS_FILE_DATA;
    sendPacket.transFileData.fileId = transCtrl.fileId;
    sendPacket.transFileData.pktIdx = pktidx;

    if (pktidx < (int)transCtrl.packetNum)
    {
        if(transCtrl.fileType == FILE_TYPE_PLOT)
        {
            actsize = transCtrl.pBmpHead->datSize - pktidx*transCtrl.packetSize;

            if (actsize >= transCtrl.packetSize)
            {
                actsize = transCtrl.packetSize;
            }
            else
            {
                memset(buff, 0, MAX_EXDP_LEN);
            }
        }
        else
        {
            actsize = 0;
        }

        memcpy(buff, &(transCtrl.pDatBuff[pktidx*transCtrl.packetSize]), actsize);
        qDebug("TransFileData pktidx=%d", pktidx);

        rslt = packetAVLDP(&sendPacket.packet, buff, MAX_EXDP_LEN);
        if (rslt == 0)
        {
            QByteArray dat((char*)(&sendPacket.packet), LEN_NORMAL_PACKET+MAX_EXDP_LEN);
            emit(siSendData(dat));
        }
    }
}

void Machine::setAParasToMachine(int type, int idx, u32 value)
{
    int rslt;
    OperPacket sendPacket;
    int size = sizeof(value);
    memset(&sendPacket, 0, sizeof(OperPacket));
    sendPacket.setParas.cmdCode = UCMD_SET_MC_PARAS;
    sendPacket.setParas.paraType = (u16)type;
    sendPacket.setParas.paraId = idx;

    rslt = packetAVLDP(&sendPacket.packet, (u8*)&value, size);

    if (rslt == 0)
    {
        QByteArray dat((char*)(&sendPacket.packet), LEN_NORMAL_PACKET + size);
        emit(siSendData(dat));
    }
}

void Machine::setMcStatusAsMc(u8 *buff, u16 len, int toggle)
{
    memcpy(&m_mcStatus, buff, len);
    emit(siStatusChange(toggle));
}

void Machine::updateFirmware()
{
    OperPacket sendPacket;
    memset(&sendPacket, 0, sizeof(OperPacket));
    sendPacket.mcUpdate.cmdCode  = UCMD_MC_UPDATE;
    sendPacket.mcUpdate.upObj     = 0;
    sendPacket.mcUpdate.upFileID  = 0;
    packetAFLDP(&sendPacket.packet);

    QByteArray dat((char*)(&sendPacket.packet), LEN_NORMAL_PACKET);
    emit(siSendData(dat));
}

int Machine::dySendFileProc(int type, int idx, int id, u8 *pDatBuff)
{
    if (pDatBuff == NULL)
    {
        return -1;
    }

    int datSize = sizeof(pDatBuff);
    if (datSize <= 0 || datSize > MAX_FILE_SIZE)
    {
        qDebug("datSize <= 0 || datSize > MAX_FILE_SIZE, not support");
        return -2;
    }

    QTime delayTime;
    int counter = 0;
    delayTime.start();

    if (m_transCtrl.filetransing != 0)      // 已经有文件在传输
    {
        return -3;
    }

    while (m_transCtrl.filetransing != 0)   // 已经有文件在传输
    {
        if (delayTime.elapsed() > 1000)
        {
            counter++;
            qDebug("%d. wait old file trans over", counter);
            delayTime.restart();
        }

        QCoreApplication::processEvents(QEventLoop::AllEvents, 100);
    }

    m_transBreak = 0;

    m_transCtrl.fileType = (u8)type;
    m_transCtrl.fileIdx = (u8)idx;
    m_transCtrl.fileId = (u16)id;
    memcpy(m_transCtrl.pDatBuff, pDatBuff, datSize);
    m_transCtrl.packetSize = MAX_EXDP_LEN;
    m_transCtrl.packetNum = (datSize + MAX_EXDP_LEN - 1) / MAX_EXDP_LEN;

    qDebug("StartFileTrans, fileType=%d, fileIdx=%d, fileId=%d, packetNum=%d, ",
           m_transCtrl.fileType, m_transCtrl.fileIdx, m_transCtrl.fileId, m_transCtrl.packetNum);

    m_transCtrl.filetransing = 1;
    m_transCtrl.transflag = TRANS_REQUEST;
    m_transCtrl.transActive = TRANS_ACTIVE;
    startFileDyTrans(m_transCtrl);
    m_transCtrl.filetransing = 0;

    return 0;
}

//  发送文件过程
int Machine::sendAPPFileProc(int type, int idx, int id, AppFileHead & fileHead, u8 * pDatBuff)
{
    if (pDatBuff == NULL || fileHead.dataSize <= 0)
    {
        return -1;
    }

    if (fileHead.dataSize > MAX_FILE_SIZE)
    {
        qDebug("fileHead.dataSize > MAX_FILE_SIZE, not support");
        return -2;
    }

    QTime delayTime;
    int counter = 0;
    delayTime.start();

    while (m_transCtrl.filetransing != 0)   // 已经有文件在传输
    {
        if (delayTime.elapsed() > 1000)
        {
            counter++;
            qDebug("%d. wait old file trans over", counter);
            delayTime.restart();
        }

        QCoreApplication::processEvents(QEventLoop::AllEvents, 100);
    }

    m_transBreak = 0;

    // 拷贝数据到传输控制结构
    m_transCtrl.fileType = (u8)type;
    m_transCtrl.fileIdx = (u8)idx;
    m_transCtrl.fileId = (u16)id;
    memcpy(m_transCtrl.pAppHead, &fileHead, sizeof(AppFileHead));
    memcpy(m_transCtrl.pDatBuff, pDatBuff, fileHead.dataSize);
    m_transCtrl.packetSize = MAX_EXDP_LEN;
    m_transCtrl.packetNum = (fileHead.dataSize + MAX_EXDP_LEN - 1 ) / MAX_EXDP_LEN;

    qDebug("StartFileTrans, fileType=%d, fileIdx=%d, fileId=%d, packetNum=%d, ",
           m_transCtrl.fileType, m_transCtrl.fileIdx, m_transCtrl.fileId, m_transCtrl.packetNum);

    m_transCtrl.transphase = SEND_STEP1;
    m_transCtrl.filetransing = 1;

    // 启动定时器
    m_pSendTimer->start();
    return 0;
}

void Machine::mcWorkCmd(int workcode, int para1, int para2)
{
    OperPacket sendPacket;
    memset(&sendPacket, 0, sizeof(OperPacket));
    sendPacket.mcWork.cmdCode = UCMD_MC_WORK;
    sendPacket.mcWork.workCode = (u16)workcode;
    sendPacket.mcWork.para1 = (u32)para1;
    sendPacket.mcWork.para2 = (u16)(para2);
    packetAFLDP(&sendPacket.packet);

    QByteArray dat((char*)(&sendPacket.packet), LEN_NORMAL_PACKET);
    emit(siSendData(dat));
}

void Machine::deleteFilePrintDat(int fileIdx)
{
    m_pCreatPrintDat->setDeleteFile(&m_mcPrintInfo,fileIdx);
}

void Machine::moveFilePrintDat(int fileIdx,int dir)
{
    m_pCreatPrintDat->setMoveFile(&m_mcPrintInfo,fileIdx,dir);
}

void Machine::invalidateWorkFile(int idx)
{
    setMcStatus(MC_INVALID_FILE, idx);
}

void Machine::creatPrintDat(int fileIdx,int setFlag)
{
    if(setFlag == 1)
    {
        m_pCreatPrintDat->setMcPrintInfo(fileIdx,&m_mcPrintInfo);
    }
    emit siCreatData();
}

void Machine::stopPrint()
{
    m_pCreatPrintDat->stopCreatPrintDat();
    m_transBreak = 1;
}

void Machine::setIpAndPort(QString mcName, QString serverIp, quint16 serverPort, QString localIp, quint16 localPort)
{
    m_mcName = mcName;
    m_mcIp = serverIp;
    m_pTcpClient->setIpAndPort(serverIp,serverPort,localIp,localPort);
}

void Machine::startCommunication()
{
    //TCP通讯
    m_pTcpClient->moveToThread(m_pTcpBmpThread);     // 移动对象到线程中
    connect(m_pTcpBmpThread, SIGNAL(started()), m_pTcpClient, SLOT(connectToServer()) );
    connect(m_pTcpBmpThread, SIGNAL(finished()), m_pTcpClient, SLOT(deleteLater()) );  // 退出删除对象
    connect(m_pTcpClient, SIGNAL(siConnectSta(int)),
            this, SLOT(slotConnectSta(int)), Qt::AutoConnection);             // 连接状态改变
    connect(m_pTcpClient, SIGNAL(siConnectErr(QString)),
            this, SLOT(slotConnectErr(QString)), Qt::AutoConnection);         // 接收到通讯错误
    connect(m_pTcpClient, SIGNAL(siReceiveData(QByteArray)),
            this, SLOT(slotReceiveData(QByteArray)), Qt::AutoConnection);     // 接收到数据
    connect(this, SIGNAL(siSendData(QByteArray)),
            m_pTcpClient, SLOT(slotSendData(QByteArray)), Qt::AutoConnection); // 发送数据的槽

    //生成打印数据
    m_pCreatPrintDat->moveToThread(m_pTcpBmpThread);
    connect(m_pTcpBmpThread, SIGNAL(finished()), m_pCreatPrintDat, SLOT(deleteLater()) );  // 退出删除对象
    connect(this, SIGNAL(siCreatData()),
            m_pCreatPrintDat, SLOT(slotCreatBmp()), Qt::QueuedConnection); // 开始创建位图的槽
    connect(this, SIGNAL(siSendDataDone()),
            m_pCreatPrintDat, SLOT(slotCreatNextBmpBlockDat()), Qt::QueuedConnection); // 创建位图块并发送的槽
    connect(this, SIGNAL(siCreatBmpBlockDatAndSend()),
            m_pCreatPrintDat, SLOT(slotCreatNextBmpBlockDat()), Qt::QueuedConnection); // 创建位图块并发送的槽

    connect(m_pCreatPrintDat, SIGNAL(siSendFileListDatToMc(int)),
            this, SLOT(slotSendPlotFileListToMc(int)), Qt::QueuedConnection); // 发送文件列表的槽
    connect(m_pCreatPrintDat, SIGNAL(siSendDatToMc(QByteArray)),
            this, SLOT(slotSendDatToMc(QByteArray)), Qt::QueuedConnection); // 发送数据的槽

    connect(m_pCreatPrintDat, SIGNAL(siOneFilePrintFinished(int,int,int)),
            this, SIGNAL(siOneFilePrintFinished(int,int,int)), Qt::AutoConnection); // 完成一个文件的打印
    connect(m_pCreatPrintDat, SIGNAL(siRefreshPrintProgress(int,int)),
            this, SIGNAL(siRefreshPrintProgress(int,int)), Qt::AutoConnection); // 刷新打印进度

    m_pTcpBmpThread->start();    // 启动线程
}

void Machine::getInfoFromMachine()
{
    OperPacket sendPacket;
    memset(&sendPacket, 0, sizeof(OperPacket));
    sendPacket.getMcInfo.cmdCode = UCMD_GET_MC_INFO;

    packetAFLDP(&sendPacket.packet);

    QByteArray dat((char*)(&sendPacket.packet), LEN_NORMAL_PACKET);
    emit(siSendData(dat));
}

void Machine::getParasFromMachine(int type, int id)
{
    int mctype = -1;
    int wktype = -1;

    if (type == -1)
    {
        mctype = MCPARA_MACH;
        wktype = MCPARA_WORK;
        m_mcParaEn = 0;
        m_wkParaEn = 0;
    }
    else
    {
        if(type == MCPARA_MACH)
        {
            mctype = MCPARA_MACH;
            m_mcParaEn = 0;
        }
        if(type == MCPARA_WORK)
        {
            wktype = MCPARA_WORK;
            m_wkParaEn = 0;
        }
    }

    OperPacket sendPacket;
    memset(&sendPacket, 0, sizeof(OperPacket));
    sendPacket.getMcParas.cmdCode = UCMD_GET_MC_PARAS;

    if (mctype == MCPARA_MACH)
    {
        sendPacket.getMcParas.paraType = (u16)mctype;
    }

    if (wktype == MCPARA_WORK)
    {
        sendPacket.getMcParas.paraType = (u16)wktype;
    }

    sendPacket.getMcParas.paraId = id;
    packetAFLDP(&sendPacket.packet);

    QByteArray dat((char*)(&sendPacket.packet), LEN_NORMAL_PACKET);
    emit(siSendData(dat));
}

// 读取传输结果
void Machine::getTransResultFromMachine(int fileid)
{
    OperPacket sendPacket;
    memset(&sendPacket, 0, sizeof(OperPacket));
    sendPacket.getTransResult.cmdCode = UCMD_GET_TRANS_RESULT;
    sendPacket.getTransResult.fileId = (u16)fileid;
    packetAFLDP(&sendPacket.packet);

    QByteArray dat((char*)(&sendPacket.packet), LEN_NORMAL_PACKET);
    emit(siSendData(dat));
}

void Machine::sleep(int sec)
{
    QTime dieTime = QTime::currentTime().addSecs(sec);//延时sec秒
    //QTime dieTime = QTime::currentTime().addMSecs(msec);//延时msec毫秒
    while( QTime::currentTime() < dieTime )
        QCoreApplication::processEvents(QEventLoop::AllEvents, 100);
}

void Machine::setMcStatus(int stacode, int para)
{
    OperPacket sendPacket;
    memset(&sendPacket, 0, sizeof(OperPacket));
    sendPacket.setMcStatus.cmdCode = UCMD_SET_MC_STATUS;
    sendPacket.setMcStatus.staCode = (u16)stacode;
    sendPacket.setMcStatus.para = (u16)para;
    packetAFLDP(&sendPacket.packet);

    QByteArray dat((char*)(&sendPacket.packet), LEN_NORMAL_PACKET);
    emit(siSendData(dat));
}

void Machine::setParasToMachine(ParaStruct &para)
{
    int rslt;
    OperPacket sendPacket;
    int size = sizeof(ParaStruct);
    memset(&sendPacket, 0, sizeof(OperPacket));
    //sendPacket.setParas.cmdCode = UCMD_SET_MC_PARAS;

    rslt = packetAVLDP(&sendPacket.packet, (u8*)&para, size);

    if (rslt == 0)
    {
        QByteArray dat((char*)(&sendPacket.packet), LEN_NORMAL_PACKET + size);
        emit(siSendData(dat));
    }
}

void Machine::setAMcPara(int id, u32 value)
{
    setAParasToMachine(MCPARA_MACH, id, value);
}

void Machine::setAWkPara(int id, u32 value)
{
    setAParasToMachine(MCPARA_WORK, id, value);
}

// 启动工作
void Machine::startWork()
{
    mcWorkCmd(WORK_START);
}

// 暂停工作
void Machine::pauseWork()
{
    mcWorkCmd(WORK_PAUSE);
}

int Machine::sendFileProc( int idx, u8 *dat, int datSize)
{
    if(dat == NULL)
    {
        return -1;
    }

    if (datSize <= 0 || datSize > MAX_FILE_SIZE)
    {
        return -2;
    }

    QTime delayTime;
    int counter = 0;
    delayTime.start();

    if (m_transCtrl.filetransing != 0)      // 已经有文件在传输
    {
        return -3;
    }

    while (m_transCtrl.filetransing != 0)   // 已经有文件在传输
    {
        if (delayTime.elapsed() > 1000)
        {
            counter++;
            qDebug("%d. wait old file trans over", counter);
            delayTime.restart();
        }

        QCoreApplication::processEvents(QEventLoop::AllEvents, 100);
    }

    m_transBreak = 0;

    m_transCtrl.fileIdx = (u8)idx;
    memcpy(m_transCtrl.pDatBuff, dat, datSize);
    m_transCtrl.packetSize = MAX_EXDP_LEN;
    m_transCtrl.packetNum = (datSize + MAX_EXDP_LEN - 1) / MAX_EXDP_LEN;

    qDebug("StartFileTrans, fileType=%d, fileIdx=%d, packetNum=%d, ",
           m_transCtrl.fileType, m_transCtrl.fileIdx, m_transCtrl.packetNum);

    m_transCtrl.transphase = SEND_STEP1;
    m_transCtrl.filetransing = 1;
    m_pSendTimer->start();
    return 0;
}

void Machine::slotConnectSta(int sta)
{
    m_connected = sta;
}

void Machine::slotConnectErr(QString errinfo)
{
    if(errinfo.length() <= 0){}
}

// 接收到数据的槽函数
void Machine::slotReceiveData(QByteArray dat)
{
    int rslt;
    DataPacket packet;
    OperPacket * operpkt = (OperPacket *)(&packet);

    //qDebug() << "SlotReceiveData size=" << dat.size();
    g_receiveBuff.append(dat);
    //qDebug()<<"append dat size"<<dat.size();

    do
    {
        rslt = getANormalPacket(&g_exfuns, &packet);
        // 分析数据包，并执行
        if (rslt > 0)	// 收到数据包
        {
            //qDebug()<<"getANormalPacket rslt="<<rslt<<operpkt->packet.fldp.cmd;
            switch(operpkt->packet.fldp.cmd)	// 先按固定长度解析
            {
            case DCMD_REQUEST_DAT:          	// 请求文件数据
            {
               if (m_transCtrl.transActive == TRANS_ACTIVE)
                {
                    if (1   &&
                            m_transCtrl.transflag == TRANS_REQUEST &&       // 请求传输数据模式
                            m_transCtrl.fileType    == operpkt->dRequestDatBlock.fileType &&
                            m_transCtrl.fileIdx     == operpkt->dRequestDatBlock.fileIdx &&
                            m_transCtrl.fileId      == operpkt->dRequestDatBlock.fileId &&
                            1   )
                    {
                        qDebug("in request mode, send block idx=%d", operpkt->dRequestDatBlock.datBlockIdx);
                        transFileData(m_transCtrl, operpkt->dRequestDatBlock.datBlockIdx);
                    }
                }
                break;
            }
            case DCMD_SEND_MC_INFO:         	// 发送机器信息
            {
                memcpy(&m_mcInfo, operpkt->dSendMcInfo.exData, sizeof(MCInfo));
                emit(siMcInfoChange( ));
                break;
            }

            case DCMD_SEND_MC_STATUS:			// 发送机器状态
            {
                setMcStatusAsMc(operpkt->dSendMcStatus.exData, operpkt->dSendMcStatus.exLen, operpkt->dSendMcStatus.toggle);
                break;
            }

            case DCMD_SEND_MC_PARAS:			// 发送机器参数
            {
                int type;

                type = operpkt->dSendMcParas.paraType;
                if (operpkt->dSendMcParas.exLen == sizeof(ParaStruct))
                {
                    if (type == MCPARA_MACH)
                    {
                        memcpy(&m_mcPara, operpkt->dSendMcParas.exData, sizeof(ParaStruct));
                        m_mcParaEn = 1;
                    }
                    else if (type == MCPARA_WORK)
                    {
                        memcpy(&m_wkPara, operpkt->dSendMcParas.exData, sizeof(ParaStruct));
                        m_wkParaEn = 1;
                    }
                    else
                    {
                        break;
                    }

                    //因为之前请求了机器参数和工作参数，所以当两个参数都返回时，再触发信号和槽
                    //  if( m_mcParaEn==1 && m_wkParaEn==1)
                    {
                        printf("emit SiParaChange\r\n");
                        emit(siParaChange(type, 0));
                    }
                }
                else if (operpkt->dSendMcParas.exLen == sizeof(u32))
                {
                    int id, idx;
                    id = operpkt->dSendMcParas.paraId;
                    idx = id - 1;
                    if (idx > 0 && idx < PARA_NUM)
                    {
                        idx *= sizeof(u32);
                        if (type == MCPARA_MACH)
                        {
                            memcpy((u8*)(&m_mcPara)+idx, operpkt->dSendMcParas.exData, sizeof(u32));
                            m_mcParaEn = 1;
                        }
                        else if (type == MCPARA_WORK)
                        {
                            memcpy((u8*)(&m_wkPara)+idx, operpkt->dSendMcParas.exData, sizeof(u32));
                            m_wkParaEn = 1;
                        }
                        else
                        {
                            break;
                        }
                        emit(siParaChange(type, id));
                    }
                }

                break;
            }

            case DCMD_SEND_TRANS_RESULT:		// 发送传输结果
            {
                printf("get DCMD_SEND_TRANS_RESULT\r\n");
                m_transCtrl.lenBmp = operpkt->dSendTransResult.exLen;
                m_transCtrl.transActive = operpkt->dSendTransResult.active;
                m_transCtrl.transflag = operpkt->dSendTransResult.result;
                if (m_transCtrl.lenBmp != 0)
                {
                    memcpy(m_transCtrl.rsvBitmap, operpkt->dSendTransResult.exData, m_transCtrl.lenBmp);
                }
                m_fileTransEn = 1;

                emit (siTransResultChange());

                break;
            }

            default:
                break;
            }
        }
        else
        {
            break;
        }
    }while(1);
}

void Machine::onSendTimer()
{
    int rslt;
    rslt = 0;

    //qDebug("file trans timer");

    if (m_transBreak != 0)      // 中断传输
    {
        //qDebug("break file trans");
        m_transCtrl.transphase = SEND_STEP5;
    }

    if (m_transCtrl.transphase == SEND_STEP0)      // 文件失效
    {
        m_fileTransEn = 0;
        qDebug("SEND_STEP1 InvalidateWorkFile");
        invalidateWorkFile(m_transCtrl.fileIdx);        // 文件失效
        m_transCtrl.transphase = SEND_STEP1;
        rslt = 1;
    }
    else if (m_transCtrl.transphase == SEND_STEP1)      // 启动文件传输
    {
        m_fileTransEn = 0;
        startFileTrans(m_transCtrl);

        qDebug("trans progress %d/%d", 0, m_transCtrl.packetNum);
        m_totalSendNum = 0;
        m_totalPacketNum = m_transCtrl.packetNum;
        emit(siTransProgress(m_transCtrl.fileType, m_totalSendNum, m_totalPacketNum));     // 发送进度信号
        m_transCtrl.transphase = SEND_STEP2;
        rslt = 1;
    }
    else if (m_transCtrl.transphase == SEND_STEP2)       // 读取传输结果
    {
        qDebug("SEND_STEP2 send GetTransResult cmd");

        m_fileTransEn = 0;
        getTransResultFromMachine(m_transCtrl.fileId);
        m_transCtrl.transphase = SEND_STEP3;
        rslt = 1;
    }
    else if (m_transCtrl.transphase == SEND_STEP3)       // 根据传输结果传输文件数据
    {
        if (m_fileTransEn == 1)
        {
            qDebug("GetTransResult from machine");

            if (m_transCtrl.transActive == TRANS_ACTIVE)
            {
                if (m_transCtrl.transflag == TRANS_READY ||  // 准备好接收
                     m_transCtrl.transflag == TRANS_DOING ||  // 正在接收
                        0)
                {
                    //qDebug("trans sta = TRANS_READY or TRANS_DOING flag=%d", m_transCtrl.transflag);

                    int thissendnum = 0;
                    int totalsendnum = 0;
                    int send_count = 400;

                    if ( m_transCtrl.fileType == FILE_TYPE_PGM)  //升级等文件（小文件）
                    {
                        send_count = 25;
                    }

                    u8 mod, temp;
                    for (int i = 0; i < m_transCtrl.lenBmp; i++)
                    {
                        temp = m_transCtrl.rsvBitmap[i];
                        mod = 0x01;
                        for (int j = 0; j < 8; j++)
                        {
                            if ((temp & mod) == 0)
                            {
                                if (thissendnum < send_count)       // 每发送send_count个包，查询一次结果
                                {
                                    thissendnum++;

                                    transFileData(m_transCtrl, i*8+j);
                                }
                            }
                            else
                            {
                                totalsendnum++;
                            }
                            mod <<= 1;
                        }
                    }
                    m_totalSendNum = totalsendnum;
                    m_totalPacketNum = m_transCtrl.packetNum;
                    emit(siTransProgress(m_transCtrl.fileType, m_totalSendNum, m_totalPacketNum));             // 发送进度信号
                    m_transCtrl.transphase = SEND_STEP2;     // 重新发送查询命令
                }
                else if (m_transCtrl.transflag == TRANS_DONE)    // 接收完成
                {
                    //qDebug("trans sta = TRANS_DONE");

                    emit siSendDataDone();

                    m_totalSendNum = m_transCtrl.packetNum;
                    m_totalPacketNum = m_transCtrl.packetNum;
                    emit(siTransProgress(m_transCtrl.fileType, m_totalSendNum, m_totalPacketNum));     // 发送进度信号
                    m_transCtrl.transphase = SEND_STEP4;

                    if( m_transCtrl.fileType == FILE_TYPE_PGM )
                    {
                        updateFirmware();
                    }
                }
                else if (m_transCtrl.transflag == TRANS_REQUEST)    // 请求传输数据模式
                {
                    //qDebug("trans sta = TRANS_REQUEST, sta=%d", m_transCtrl.transflag);
                    m_transCtrl.transphase = SEND_ANSWER;
                }
                else // if (m_transCtrl.transflag == TRANS_NOT_BEG) // 没有收到启动命令
                {
                    //qDebug("trans sta = TRANS_NOT_BEG, sta=%d, back to SEND_STEP1", m_transCtrl.transflag);
                    m_transCtrl.transphase = SEND_STEP1;    // 重新发送启动文件传输
                }
            }
            else
            {
                //qDebug("transActive != TRANS_ACTIVE, back to SEND_STEP1");
                m_transCtrl.transphase = SEND_STEP1;    // 重新发送启动文件传输
            }
            rslt = 1;
        }
        else
        {
            if (m_transCtrl.waitcount > SEND_STEP_MAX)      // 1秒没有回复
            {
                //qDebug("waitcount > SEND_STEP_MAX, back to SEND_STEP2");
                m_transCtrl.transphase = SEND_STEP2;     // 重新发送查询命令
                rslt = 1;
            }
        }
    }

    if (rslt == 0)
    {
        m_transCtrl.waitcount++;
    }
    else
    {
        m_transCtrl.waitcount = 0;
    }

    if (    m_transCtrl.transphase != SEND_STEP1 &&
            m_transCtrl.transphase != SEND_STEP2 &&
            m_transCtrl.transphase != SEND_STEP3    )       // 结束
    {
        //qDebug("trans file over, step=%d", m_transCtrl.transphase);
        if (m_transCtrl.transphase == SEND_STEP4)
        {
            m_totalSendNum = 0;
            m_totalPacketNum = 0;
            emit(siTransProgress(m_transCtrl.fileType, m_totalSendNum, m_totalPacketNum));        // 发送结束信号（成功）
        }
        else
        {
            m_totalSendNum = -1;
            m_totalPacketNum = -1;
            emit(siTransProgress(m_transCtrl.fileType, m_totalSendNum, m_totalPacketNum));      // 发送结束信号（失败）
        }
        m_pSendTimer->stop();               // 停止定时器
        m_transCtrl.filetransing = 0;
    }
}

void Machine::slotSendDatToMc(QByteArray dat)
{
    if(m_connected == Connected)
    {
        if (dat.size() <= 0 || m_pCompBmpHead == NULL)
        {
            return;
        }

        QTime delayTime;
        int counter = 0;
        delayTime.start();

        if (m_transCtrl.filetransing != 0)      // 已经有文件在传输
        {
            return;
        }

        while (m_transCtrl.filetransing != 0)   // 已经有文件在传输
        {
            if (delayTime.elapsed() > 1000)
            {
                counter++;
                qDebug("%d. wait old file trans over", counter);
                delayTime.restart();
            }

            QCoreApplication::processEvents(QEventLoop::AllEvents, 100);//进度条
        }

        qDebug()<<"dat.size()"<<dat.size();

        memcpy((u8*)m_pCompBmpHead,(u8*)dat.data(),sizeof(CompBmpHead));

        m_pCompBmpHead->fileId = m_pPlotFileList->fileId;

        if (m_pCompBmpHead->datSize <= 0 || m_pCompBmpHead->datSize > MAX_FILE_SIZE)
        {
            qDebug("m_pCompBmpHead->datSize <= 0 || m_pCompBmpHead->datSize > MAX_FILE_SIZE, not support");
            return;
        }

        m_transBreak = 0;

        m_transCtrl.fileType = (u8)FILE_TYPE_PLOT;
        m_transCtrl.fileId = m_pCompBmpHead->fileId;
        memcpy(m_transCtrl.pBmpHead, m_pCompBmpHead, sizeof(CompBmpHead));
        memcpy(m_transCtrl.pDatBuff, dat.data()+sizeof(CompBmpHead), m_pCompBmpHead->datSize);
        m_transCtrl.packetSize = MAX_EXDP_LEN;
        m_transCtrl.packetNum = (m_pCompBmpHead->datSize + MAX_EXDP_LEN - 1) / MAX_EXDP_LEN;

        qDebug("StartFileTrans, fileType=%d, fileIdx=%d, fileId=%d, packetNum=%d, ",
               m_transCtrl.fileType, m_transCtrl.fileIdx, m_transCtrl.fileId, m_transCtrl.packetNum);

        m_transCtrl.transphase = SEND_STEP1;
        m_transCtrl.filetransing = 1;

        m_pSendTimer->start();
        qDebug()<<"slotSendDatToMc";
        return;
    }
}

void Machine::slotSendPlotFileListToMc(int idx)
{
    if(m_connected == Connected)
    {
        int oft = (int)(m_mcPrintInfo.m_filesList[idx].m_startPoint*MMPIXELY);
        qDebug()<<"slotSendPlotFileListToMc";
        qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
        u32 id =qrand() % (UINT16_MAX);//产生0到UINT16_MAX的随机数
        m_pPlotFileList->fileId = id;
        m_pPlotFileList->totalWidth = (m_mcPrintInfo.m_filesList[idx].m_pic.width() - oft) * m_mcPrintInfo.m_filesList[idx].m_printNum;
        m_pPlotFileList->totalHeight = m_mcPrintInfo.m_filesList[idx].m_pic.height();
        m_pPlotFileList->blkNums = m_mcPrintInfo.m_filesList[idx].m_totalBlocks;
        m_pPlotFileList->blkWidth = PIXMAPWIDTH;

        int rslt;
        OperPacket sendPacket;
        int size = sizeof(PlotFileList);
        memset(&sendPacket, 0, sizeof(OperPacket));
        sendPacket.setParas.cmdCode = UCMD_SET_FILE_LIST;

        rslt = packetAVLDP(&sendPacket.packet, (u8*)m_pPlotFileList, size);

        if (rslt == 0)
        {
            QByteArray dat((char*)(&sendPacket.packet), LEN_NORMAL_PACKET + size);
            emit(siSendData(dat));
            emit siCreatBmpBlockDatAndSend();
        }
    }
}

void Machine::breakFileTrans()
{
    m_transBreak = 1;
}