//---------------------------------------------------------------------
#include	<stdio.h>      /*标准输入输出定义*/
#include	<stdlib.h>     /*标准函数库定义*/
#include 	<string.h>
#include	<unistd.h>     /*Unix 标准函数定义*/
#include	<sys/types.h>
#include	<sys/stat.h>
#include	<fcntl.h>      /*文件控制定义*/
#include	<termios.h>    /*PPSIX 终端控制定义*/
#include	<errno.h>      /*错误号定义*/
//---------------------------------------------------------------------
#include    "module_drv.h"

//#define EN_THREAD_WORK_DEBUG
#ifdef EN_THREAD_WORK_DEBUG
#define THREAD_WORK_DEBUG qDebug
#else
#define THREAD_WORK_DEBUG(...)
#endif

#define Swap16(u16) ((quint16)(((quint16)(u16) >> 8)|((quint16)(u16) << 8)))
#define Swap32(u32) ((quint32)(((quint32)(u32) >> 16)|((quint32)(u32) << 16)))
//---------------------------------------------------------------------
const unsigned char auchCRCHi[] =
{
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
    0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
    0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
    0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
    0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
    0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
    0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
    0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
    0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
    0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
    0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
    0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
    0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
    0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
    0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
    0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
    0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
    0x80, 0x41, 0x00, 0xC1, 0x81, 0x40
};

const unsigned char auchCRCLo[] =
{
    0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06,
    0x07, 0xC7, 0x05, 0xC5, 0xC4, 0x04, 0xCC, 0x0C, 0x0D, 0xCD,
    0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
    0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A,
    0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC, 0x14, 0xD4,
    0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
    0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3,
    0xF2, 0x32, 0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4,
    0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
    0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29,
    0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED,
    0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
    0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60,
    0x61, 0xA1, 0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67,
    0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
    0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68,
    0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA, 0xBE, 0x7E,
    0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
    0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71,
    0x70, 0xB0, 0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92,
    0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
    0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B,
    0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89, 0x4B, 0x8B,
    0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
    0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42,
    0x43, 0x83, 0x41, 0x81, 0x80, 0x40
};

static QMutex N905M_mutex;

static int commErrTimes = 0;
//---------------------------------------------------------------------
ModuleDrv::ModuleDrv(const char *dev)
{
    MonomerNum = 24;

    FD_NRF905 = this->OpenDev(dev);
    if (-1 == FD_NRF905)
        qDebug("Can't Open %s\n", dev);
    else
        qDebug("Open %s OK!\n", dev);
    this->SetDevAttr(FD_NRF905,9600, 8,1,'N');

    IF_MONCLEAR = 0;
}

ModuleDrv::~ModuleDrv()
{
    quit();
    wait();
}

void ModuleDrv::SetMonomerNum(const quint16 num)
{
    MonomerNum = num;
}
//---------------------------------------------------------------------
//---------------------------------------------------------------------
/**
*@brief  设置串口通信速率
*@param  fd     类型 int  打开串口的文件句柄
*@param  speed  类型 int  串口速度
*@return  void
*/
//---------------------------------------------------------------------
//---------------------------------------------------------------------
int speed_arr1[] = { B115200, B57600, B38400, B19200, B9600};
int name_arr1[] =  {	 115200,  57600,  38400,  19200,  9600};
void ModuleDrv::set_speed(int fd, int speed)
{
    int   status;
    struct termios   Opt;
    tcgetattr(fd, &Opt);
    for ( unsigned int i= 0;  i < sizeof(speed_arr1) / sizeof(int);  i++)
    {
        if(speed == name_arr1[i])
        {
            tcflush(fd, TCIOFLUSH);
            cfsetispeed(&Opt, speed_arr1[i]);
            cfsetospeed(&Opt, speed_arr1[i]);
            status = tcsetattr(fd, TCSANOW, &Opt);
            if(status != 0)
            {
                perror("tcsetattr fd1");
                return;
            }
            tcflush(fd,TCIOFLUSH);
        }
    }
}
//---------------------------------------------------------------------
/**
*@brief   设置串口数据位，停止位和效验位
*@param  fd     类型  int  打开的串口文件句柄
*@param  databits 类型  int 数据位   取值 为 7 或者8
*@param  stopbits 类型  int 停止位   取值为 1 或者2
*@param  parity  类型  int  效验类型 取值为N,E,O,,S
*/
//---------------------------------------------------------------------
int ModuleDrv::set_Parity(int fd,int databits,int stopbits,int parity)
{
    struct termios options;
    if(tcgetattr(fd, &options) != 0)
    {
        perror("SetupSerial 1");
        return(-1);
    }

    //--------------- 二进制传输模式 -------------------------
    options.c_iflag = 0;
    options.c_oflag = 0;
    //------------------------------------------------------

    options.c_cflag &= ~CSIZE;
    options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);/*Input*/
    options.c_oflag &= ~OPOST;/*Output*/
    switch (databits) /*设置数据位数*/
    {
        case 7:
            options.c_cflag |= CS7;
            break;
        case 8:
            options.c_cflag |= CS8;
            break;
        default:
            fprintf(stderr,"Unsupported data size\n");
            return (-1);
    }
    switch (parity)
    {
        case 'n':
        case 'N':
            options.c_cflag &= ~PARENB;   			/* Clear parity enable */
            options.c_iflag &= ~INPCK;    			/* Enable parity checking */
            break;
        case 'o':
        case 'O':
            options.c_cflag |= (PARODD | PARENB); 	/* 设置为奇效验*/
            options.c_iflag |= INPCK;             	/* Disnable parity checking */
            break;
        case 'e':
        case 'E':
            options.c_cflag |= PARENB;     			/* Enable parity */
            options.c_cflag &= ~PARODD;   			/* 转换为偶效验*/
            options.c_iflag |= INPCK;       		/* Disnable parity checking */
            break;
        case 'S':
        case 's':  									/*as no parity*/
            options.c_cflag &= ~PARENB;
            options.c_cflag &= ~CSTOPB;
            break;
        default:
            fprintf(stderr,"Unsupported parity\n");
            return (-1);
    }
    /* 设置停止位*/
    switch (stopbits)
    {
        case 1:
            options.c_cflag &= ~CSTOPB;
            break;
        case 2:
            options.c_cflag |= CSTOPB;
            break;
        default:
            fprintf(stderr,"Unsupported stop bits\n");
            return (-1);
    }
    /* Set input parity option */
    if (parity != 'n')
        options.c_iflag |= INPCK;

    tcflush(fd, TCIFLUSH);
    options.c_cc[VTIME] = 0; /* 0.1S */
    options.c_cc[VMIN] = 0;
    /* Update the options and do it NOW */
    if (tcsetattr(fd,TCSANOW,&options) != 0)
    {
        perror("SetupSerial 3");
        return (-1);
    }
    return (0);
}
//---------------------------------------------------------------------
int ModuleDrv::OpenDev(const char *Dev)
{
    int fd = open(Dev, O_RDWR|O_NOCTTY|O_NDELAY);

    return fd;
}
//---------------------------------------------------------------------
void ModuleDrv::SetDevAttr(int fd, int bitrate, char bitlen,
                             char stopbitlen, char checktype)
{
    if(fd < 0)
        return;

    set_speed(fd, bitrate);

    if(set_Parity(fd, bitlen, stopbitlen, checktype) < 0)
    {
        qDebug("Set Parity Error\n");
    }


    if(fcntl(fd, F_SETFL, FNDELAY) < 0)//非阻塞，覆盖前面open的属性
    {
        qDebug("fcntl failed\n");
    }
}
//---------------------------------------------------------------------
int ModuleDrv::WriteDev(int fd,void *buf, int len)
{
    if(fd < 0)
        return 0;

    return write(fd, (char *)buf, len);
}
//---------------------------------------------------------------------
int ModuleDrv::ReadDev(int fd,void *buf, int len)
{
    if(fd < 0)
        return 0;

    char *pbuff = (char *)buf;
    return (read(fd, pbuff, len));
}
//---------------------------------------------------------------------
unsigned short ModuleDrv::CalModbusCRC16(void *puchMsg, unsigned short usDataLen, const quint8 mode_type)
{
    unsigned char *pdata = (unsigned char *)puchMsg;
    unsigned short uchCRCHi = 0xFF;
    unsigned short uchCRCLo = 0xFF;
    unsigned int uIndex ;
    while (usDataLen--)
    {
        uIndex = uchCRCHi ^ *pdata++ ;
        uchCRCHi = uchCRCLo ^ auchCRCHi[uIndex];
        uchCRCLo = auchCRCLo[uIndex];
    }

    // //
    if(mode_type)
        return ((uchCRCLo << 8) | uchCRCHi);
    else
        return (uchCRCLo | uchCRCHi<< 8);
}
//---------------------------------------------------------------------
//---------------------------------------------------------------------
//---------------------------------------------------------------------
int ModuleDrv::ReadFromIOModule( int fd,const quint16 data_addr,const quint16 read_data_num, void *read_data_buf, const quint8 CRC_mode)
{
//return 0;
    int res = CommOK;

    quint8 txData[16] = {0};
    quint8 rxData[264] = {0};

    txData[0] = 255;
    txData[1] = FUNC_CODE_READ;
    txData[2] = data_addr/256;
    txData[3] = data_addr%256;
    txData[4] = read_data_num/256;
    txData[5] = read_data_num%256;
    unsigned short crc = CalModbusCRC16(txData,6,CRC_mode);
    txData[6] = (quint8)(crc>>8);
    txData[7] = (quint8)crc;

    struct timeval tv;
    fd_set rfds;
    int timeout = 0;
    const quint16 tx_data_len = 8;
    quint16 rx_data_len = 0;

    for(quint8 t = 0;t<1;t++) //retry 3 times
    {
        res = CommOK;

        //flush rx buffer
        char tmp[64] = {0};
        while(1)
        {
            int len = ReadDev(fd,tmp, 64);
            if(len > 0)
                continue;
            else break;
        }

        if(tx_data_len != WriteDev(fd, txData, tx_data_len))
            res = CommTxError;

        rx_data_len = read_data_num*2+5;
        if(rx_data_len>264)
            rx_data_len = 264;

        timeout = rx_data_len*1000+100000;
        if(timeout > 400000)
            timeout = 400000;

        if(CommOK == res)
        {
            tv.tv_sec = 0;
            tv.tv_usec = timeout;

            FD_ZERO(&rfds);
            FD_SET( fd,&rfds );
            int sres = select(fd+1,&rfds,NULL,NULL,&tv); //block wait
            if(sres > 0)
            {
                if(rx_data_len != ReadDev(fd, rxData, rx_data_len))
                {
                    res = CommRxError;
                }
            }
            else
            {
                res = CommRxError;
            }
        }

        if(CommOK == res)
        {
            crc = rxData[rx_data_len-2];
            crc = (crc<<8) + rxData[rx_data_len-1];

            if(crc == CalModbusCRC16(rxData, rx_data_len-2, CRC_mode))
            {
                if(NULL != read_data_buf)
                {
                    quint8 *pRecvData = (quint8 *)read_data_buf;
                    for (quint8 i = 3; i<rx_data_len-2; i++)
                    {
                        *pRecvData++ = rxData[i];
                    }
                }
            }
            else
            {
                res = CommDataError;
            }
        }

        if(CommOK == res)
            break;
        else
        {
            //qDebug("905 Read Error,ErrorCode = %d",res);
            msleep(100);
            commErrTimes++;
        }
    }

    return res;
}
//---------------------------------------------------------------------
int ModuleDrv::MultiWriteIOModule( int fd,const quint16 data_addr,quint16 *wr_data_buf, const quint16 WriteDataNum,const quint8 CRC_mode)
{
//return 0;
    int res = CommOK;

    quint8 txData[128] = {0};
    quint8 rxData[16] = {0};

    quint16 wrdatanum = WriteDataNum;

    if(wrdatanum >48)
        wrdatanum = 48;

    quint16 lenth = 0;

    txData[lenth++] = 255;
    txData[lenth++] = FUNC_CODE_MULTY_WRITE; //多点写
    txData[lenth++] = data_addr/256;
    txData[lenth++] = data_addr%256;
    txData[lenth++] = wrdatanum/256;
    txData[lenth++] = wrdatanum%256;
    txData[lenth++] = wrdatanum*2;

    for(int i=0;i<wrdatanum;i++)
    {
        txData[lenth++] = wr_data_buf[i]/256;
        txData[lenth++] = wr_data_buf[i]%256;
    }

    unsigned short crc = CalModbusCRC16(txData,lenth,CRC_mode);
    txData[lenth++] = (quint8)(crc>>8);
    txData[lenth++] = (quint8)crc;

    struct timeval tv;
    fd_set rfds;

    const quint16 rx_data_len = 8;
    quint16 rx_data = 0;

    for(quint8 t = 0;t<3;t++)
    {
        res = CommOK;

        char tmp[64] = {0};
        while(1)
        {
            int len = ReadDev(fd, tmp, 64);
            if(len > 0)
                continue;
            else break;
        }

        if(lenth != WriteDev(fd, txData, lenth))
            res = CommTxError;

        if(CommOK == res)
        {
            tv.tv_sec = 0;
            tv.tv_usec = 200000;

            FD_ZERO(&rfds);
            FD_SET( fd,&rfds );
            int sres = select(fd+1,&rfds,NULL,NULL,&tv);
            if(sres > 0)
            {
                if(rx_data_len != ReadDev(fd, rxData, rx_data_len))
                {
                    res = CommRxError;

                    //qDebug("%d-%d-%d",rxData[0],rxData[1],rxData[2]);
                }
            }
            else
            {
                res = CommRxError;
                //qDebug("comm rx error");
            }
        }

        if(CommOK == res)
        {
            crc = rxData[rx_data_len-2];
            crc = (crc<<8) + rxData[rx_data_len-1];

            if(crc == CalModbusCRC16(rxData, rx_data_len-2, CRC_mode))
            {
                rx_data = (quint16)(rxData[4]<<8)+rxData[5];
                if(0 == rx_data) //pass==1
                    res = CommWrFailError;
            }
            else
            {
                res = CommDataError;
            }
        }



        if(CommOK == res)
            break;
        else
        {
            msleep(100);
            //qDebug("MultiWrite Error,ErrorCode = %d",res);
        }
    }

    return res;
}
//---------------------------------------------------------------------
int ModuleDrv::SingleWriteIOModule(int fd, const quint16 data_addr,
                                      const quint16 wr_data, const quint16 timeout_ms, const quint8 CRC_mode)
{
//return 0;
    int res = CommOK;

    quint8 txData[16] = {0};
    quint8 rxData[16] = {0};

    txData[0] = DEVICE_ADDR_BROADCAST;
    txData[1] = FUNC_CODE_SINGLE_WRITE;
    txData[2] = data_addr/256;
    txData[3] = data_addr%256;
    txData[4] = wr_data/256;
    txData[5] = wr_data%256;

    unsigned short crc = CalModbusCRC16(txData,6,CRC_mode);
    txData[6] = (quint8)(crc>>8);
    txData[7] = (quint8)crc;

    struct timeval tv;
    fd_set rfds;

    quint16 rx_data_len = 8;
    quint16 tx_data_len = 8;
    quint16 rx_data = 0;

    for(quint8 t = 0;t<3;t++)
    {
        res = CommOK;

        char tmp[64] = {0};
        while(1)
        {
            int len = ReadDev(fd, tmp, 64);
            if(len > 0)
                continue;
            else break;
        }

        if(tx_data_len != WriteDev(fd, txData, tx_data_len))
            res = CommTxError;

        if(CommOK == res)
        {
            tv.tv_sec = 0;
            tv.tv_usec = timeout_ms*1000;

            FD_ZERO(&rfds);
            FD_SET( fd,&rfds );
            int sres = select(fd+1,&rfds,NULL,NULL,&tv);
            if(sres > 0)
            {
                if(rx_data_len != ReadDev(fd, rxData, rx_data_len))
                {
                    res = CommRxError;
                }
            }
            else
                res = CommRxError;
        }

        if(CommOK == res)
        {
            crc = rxData[rx_data_len-2];
            crc = (crc<<8) + rxData[rx_data_len-1];

            if(crc == CalModbusCRC16(rxData, rx_data_len-2,CRC_mode))
            {
                rx_data = (quint16)(rxData[4]<<8)+rxData[5];
                //qDebug("rx_data2 = %d",rx_data);
                if(0 == rx_data) //pass==1
                    res = CommWrFailError;
            }
            else
            {
                res = CommDataError;
            }
        }

        if(CommOK == res)
            break;
        else
        {
            msleep(100);
            //qDebug("SingleWrite Error,ErrorCode = %d",res);
        }
    }

    return res;
}

int ModuleDrv::SingleWriteIOModuleEx( int fd,const quint16 data_addr,const quint16 wr_data,
        const quint16 wr_data2,const quint16 wr_data3,const quint16 timeout_ms,const quint8 CRC_mode)
{
 //   return 0;
    int res = CommOK;

    quint8 txData[16] = {0};
    quint8 rxData[16] = {0};

    txData[0] = DEVICE_ADDR_BROADCAST;
    txData[1] = FUNC_CODE_SINGLE_WRITE;
    txData[2] = data_addr/256;
    txData[3] = data_addr%256;
    txData[4] = wr_data/256;
    txData[5] = wr_data%256;
    txData[6] = wr_data2/256;
    txData[7] = wr_data2%256;
    txData[8] = wr_data3/256;
    txData[9] = wr_data3%256;

    unsigned short crc = CalModbusCRC16(txData,10,CRC_mode);
    txData[10] = (quint8)(crc>>8);
    txData[11] = (quint8)crc;

    struct timeval tv;
    fd_set rfds;

    quint16 rx_data_len = 8;
    quint16 tx_data_len = 12;
    quint16 rx_data = 0;

    for(quint8 t = 0;t<3;t++)
    {
        res = CommOK;

        char tmp[64] = {0};
        while(1)
        {
            int len = ReadDev(fd, tmp, 64);
            if(len > 0)
                continue;
            else break;
        }

        if(tx_data_len != WriteDev(fd, txData, tx_data_len))
            res = CommTxError;

        if(CommOK == res)
        {
            tv.tv_sec = 0;
            tv.tv_usec = timeout_ms*1000;

            FD_ZERO(&rfds);
            FD_SET( fd,&rfds );
            int sres = select(fd+1,&rfds,NULL,NULL,&tv);
            if(sres > 0)
            {
                if(rx_data_len != ReadDev(fd, rxData, rx_data_len))
                {
                    res = CommRxError;
                }
            }
            else
                res = CommRxError;
        }

        if(CommOK == res)
        {
            crc = rxData[rx_data_len-2];
            crc = (crc<<8) + rxData[rx_data_len-1];

            if(crc == CalModbusCRC16(rxData, rx_data_len-2,CRC_mode))
            {
                rx_data = (quint16)(rxData[4]<<8)+rxData[5];
                qDebug("rx_data = %d",rx_data);
                if(0 == rx_data) //pass==1
                    res = CommWrFailError;
            }
            else
            {
                res = CommDataError;
            }
        }



        if(CommOK == res)
            break;
        else
        {
            msleep(100);
            qDebug("SingleWrite Error,ErrorCode = %d",res);
        }
    }

    return res;
}

int ModuleDrv::ReadFromModule(const quint16 data_addr,const quint16 read_data_num, void *read_data_buf)
{
//return 0;
    N905M_mutex.lock();
    int ret = -1;


    ret = ReadFromIOModule(FD_NRF905,data_addr,read_data_num,read_data_buf);
    N905M_mutex.unlock();
    return ret;
}

int ModuleDrv::MultiWriteModule(const quint16 data_addr,quint16 *wr_data_buf, const quint16 WriteDataNum)
{
    N905M_mutex.lock();
    int ret = -1;

    ret = MultiWriteIOModule(FD_NRF905,data_addr,wr_data_buf, WriteDataNum);
    N905M_mutex.unlock();

    return ret;
}

int ModuleDrv::SingleWriteModule(const quint16 data_addr,const quint16 wr_data, const quint16 timeout_ms)
{
    //return 0;
    N905M_mutex.lock();
    int ret = -1;


    ret = SingleWriteIOModule(FD_NRF905,data_addr,wr_data,timeout_ms);
    N905M_mutex.unlock();

    return ret;
}

int ModuleDrv::SingleWriteModuleEx(const quint16 data_addr, const quint16 wr_data,
                                  const quint16 wr_data2, const quint16 wr_data3,const quint16 timeout_ms)
{
    N905M_mutex.lock();
    int ret = -1;

    ret = SingleWriteIOModuleEx(FD_NRF905,data_addr,wr_data,wr_data2,wr_data3,timeout_ms);
    N905M_mutex.unlock();

    return ret;
}

//---------------------------------------------------------------------
void ModuleDrv::run()
{
    runEn = true;

    if(FD_NRF905<0)
        runEn = false;

    quint16 databuff[50] = {0};
    quint16 mt = 0;
    quint16 rate_index = 0;
    quint8 errorN905M = 0;
    quint8 moncount = 0;
    N905_MODULE_DATA n905ModuleData;

    memset(&n905ModuleData,0x00,sizeof(n905ModuleData));

    while(true == runEn)
    {
        if(rate_index%6 == 1)
        {
            if (CommOK == ReadFromModule(NRegAddr_GetMonomerVol+mt*50, 50, databuff))
            {
                errorN905M = 0;
                for(int i=0;i<50;i++)
                {

                    n905ModuleData.monomerVol[i+mt*50] = Swap16(databuff[i]);/*2000+i*10;//*/
                    //qDebug("n905ModuleData.monomerVol[%d] = %d",i+mt*50,n905ModuleData.monomerVol[i+mt*50]);
                }

                //qDebug("Nversion:V%.1f, m0:%d,m100:%d,m100:%d",(float)(n905ModuleData.moduleVersion)/10,n905ModuleData.monomerVol[0],n905ModuleData.monomerVol[100],n905ModuleData.monomerVol[200]);
            }
            else
                errorN905M++;

            if((50+mt*50) < MonomerNum)
            {
                mt++;
                if(mt>5)
                    mt = 0;
            }
            else
                mt = 0;
        }
        else if(rate_index%3 == 0)
        {
            if (CommOK == ReadFromModule(NRegAddr_GetVersion, 2, databuff))
            {
                errorN905M = 0;
                n905ModuleData.moduleVersion = Swap16(databuff[0]);
                n905ModuleData.moduleDropIndex = Swap16(databuff[1]);
            }
            else
                errorN905M++;
        }
        else
            msleep(100);
        rate_index++;
        if(errorN905M >= 100)
        {
            errorN905M = 0;
            memset(&n905ModuleData,0x00,sizeof(n905ModuleData));
        }
//        n905ModuleData.monomerVol[0] = 6000;
//        n905ModuleData.monomerVol[1] = 5800;
//        n905ModuleData.monomerVol[2] = 6100;
//        n905ModuleData.monomerVol[3] = 6200;
        if(( IF_MONCLEAR == 1)&&(moncount<3))
        {
              moncount++;
              memset(&n905ModuleData.monomerVol[0], 0x00, MONOMER_NUM_MAX);
        }
        else
        {
              IF_MONCLEAR = 0;
              moncount = 0;
        }

        emit sendN905ModuleData(n905ModuleData);
    //    qDebug(" n905ModuleData.monomerVol[21] = %d, n905ModuleData.monomerVol[22] = %d",n905ModuleData.monomerVol[21],n905ModuleData.monomerVol[22]);
        msleep(300);
    }
}

//---------------------------------------------------------------------
//---------------------------------------------------------------------