//---------------------------------------------------------------------
#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    "LoRaCell.h"
#include    "gpio_driver.h"
#include "Common/crc16.h"
#include "Common/classxml.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)))
//---------------------------------------------------------------------
static unsigned char S_LoRaConfig[6] =
{
    0x00,0xA0, //AddrH,AddrL
    0x64,  //011 00 100  UART=9600,8N1, 空速9.6kbps
    0xC0,  //11 0 000 00  分包32字节，RSSI禁用，发射功率22dbm
    0x17,  //信道23 ，实际频率 = 410.125+ch*1M = 433.125M
    0x40   //0 1 0 0 0 000 ,禁用RSSI字节，定点传输，禁用LBT
};

static QMutex rs485_mutex;

//---------------------------------------------------------------------
LORACELL::LORACELL(const char *dev, int fre, int order)
{
    memset(battVolData,0x00,sizeof(battVolData));
    memset(battVolErrCnt,0x00,sizeof(battVolErrCnt));
    memset(module0vol,0x00,sizeof(module0vol));
    memset(monversion,0x00,sizeof(monversion));

    memset(tx_count,0x00,sizeof(tx_count));
    memset(rx_count,0x00,sizeof(rx_count));
    all_tx = all_rx = 0;

    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');
    //初始配置
    Write_LoRa_Config(fre);

    Work_Order = order;
    Work_Num = 0;
    BattGroup = 0;
    EachGroupBattSum = 1;
    EachGroupModule = 1;
    readmode = MODE_CYCLE;
    addr_singlemodule = 0;
    adj_index = 0;
}

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

//---------------------------------------------------------------------
//---------------------------------------------------------------------
/**
*@brief  设置串口通信速率
*@param  fd     类型 int  打开串口的文件句柄
*@param  speed  类型 int  串口速度
*@return  void
*/
//---------------------------------------------------------------------
//---------------------------------------------------------------------
static int speed_arr1[] = { B115200, B57600, B38400, B19200, B9600};
static int name_arr1[] =  {	 115200,  57600,  38400,  19200,  9600};
void LORACELL::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 LORACELL::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 LORACELL::OpenDev(const char *Dev)
{
    int fd = open(Dev, O_RDWR|O_NOCTTY|O_NDELAY);

    return fd;
}
//---------------------------------------------------------------------
void LORACELL::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 LORACELL::WriteDev(int fd,void *buf, int len)
{
    if(fd < 0)
        return 0;

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

    char *pbuff = (char *)buf;
    return (read(fd, pbuff, len));
}
//---------------------------------------------------------------------
void LORACELL::run()
{
    runEn = true;

    if(FD_NRF905<0)
        runEn = false;

    bool error_count[75];
    int  error_num = 0;

    while(true == runEn)
    {
        if(readmode == MODE_CYCLE){
            memset(error_count,0x01,sizeof(error_count));
            for(int retry=1;retry<2;retry++){
                error_num = retryerrormodule(retry,retry*500,error_count);
                if(error_num == 0)
                    break;
            }
            msleep(1000);
        }
        else {
            readMonVol(addr_singlemodule,2000);
            msleep(1000);
//            qDebug("addr_singlemodule = %d",addr_singlemodule);
            readMonVersion(addr_singlemodule,2000);
            msleep(1000);
        }

    }
}

void LORACELL::set_readmode(int mode){
    readmode = mode;
}

void LORACELL::set_addrsingle(int addr){
    addr_singlemodule = addr;
}

int LORACELL::retryerrormodule(int times, int timeout_ms, bool *error_count){
    int error_num = 0;
    for(int maddr=0;maddr<Work_Num;maddr++){
        if(!error_count[maddr]){
            continue;
        }
        int res = readMonVol(maddr,timeout_ms);
        if(res == CommOK){
            tx_count[maddr]++;
            rx_count[maddr]++;
            all_tx++;
            all_rx++;
            error_count[maddr] = false;
        }
        else {
            error_count[maddr] = true;
            error_num++;
            if(res != CommTxError){
                tx_count[maddr]++;
                all_tx++;
            }
        }
//        battVolData[(maddr)*4+2] = tx_count[maddr];
//        battVolData[(maddr)*4+3] = rx_count[maddr];
        msleep(times*100);
        if(readmode == MODE_SINGLE)
            break;
    }
    QString tmp;
    tmp.clear();
    for(int i=0;i<Work_Num;i++){
        if(error_count[i]){
            tmp.append(QString::number(i+1)).append(",");
        }
    }

    return error_num;
}

//---------------------------------------------------------------------
//---------------------------------------------------------------------
int LORACELL::TxPacket(const unsigned char *addr, const void *datas,int fre)
{
    int res = CommOK;
    unsigned char tx_data[24] = {0};
    unsigned char index = 0;

    unsigned char *pdatas = (unsigned char *)datas;

    tx_data[index++] = addr[2]; //addrH
    tx_data[index++] = addr[3]; //addrL
    int xd = addr[3]+fre;
    if(xd<0)
        xd = 0;
    tx_data[index++] = xd;//信道
    //tx_data[index++] = S_LoRaConfig[4]; //FM_CH

    for(int n=0;n<TRDATA_len;n++)
    {
        tx_data[index++] = *pdatas++;
    }

//    for(int i=0;i<index;i++){
//        qDebug("tx_data[%d]=%x",i,tx_data[i]);
//    }
    if(index != WriteDev(FD_NRF905, tx_data, index))
        res = CommTxError;

    return res;
}

unsigned char LORACELL::CheckDataIfOK(const unsigned char *ADDR,RFData m_TXData, RFData* m_RFData)
{
    unsigned int crc;
    //---------------- 数据的CRC校验和从机的地址核对 -------------------
    crc = CRC16::CalCRC16(m_RFData, sizeof(RFData)-2);
    if((crc==m_RFData->CRC)&&(m_RFData->CMD == m_TXData.CMD)
       &&((m_RFData->Addr[2])==ADDR[2])&&((m_RFData->Addr[3])==ADDR[3]))
    {
        return 0;
    }
    else
    {
        return 1;
    }
}

int LORACELL::Write_LoRa_Config(int fre)
{
    QMutexLocker locker(&rs485_mutex);//添加锁
    nowfre = fre;//0,15
    int ret = 0;
    Set_LoRa_Mode(3);
    //msleep(500);如果出现设置不了频段
    for(unsigned char n=0;n<3;n++){
        ret = Uart_Write_LoRa_Config(fre);
        if(0 == ret)
            break;
        else
            msleep(500);
    }
    Set_LoRa_Mode(0);
    //msleep(500);
    return ret;
}

int LORACELL::Uart_Write_LoRa_Config(int fre)
{
    int res = CommOK;
    unsigned char tx_data[9] = {0};
    unsigned char rx_data[9] = {0};
//    switch(fre)
//    {
//        case 0:  S_LoRaConfig[4] = 23;   break;
//        case 1:  S_LoRaConfig[4] = 25;   break;
//        case 2:  S_LoRaConfig[4] = 27; 	 break;
//        case 3:  S_LoRaConfig[4] = 29; 	 break;
//        case 4:  S_LoRaConfig[4] = 31;   break;
//        case 5:  S_LoRaConfig[4] = 33;   break;
//        case 6:  S_LoRaConfig[4] = 35;   break;
//        case 7:  S_LoRaConfig[4] = 37;   break;
//        case 8:  S_LoRaConfig[4] = 39;   break;
//        case 9:  S_LoRaConfig[4] = 41;   break;
//        case 10: S_LoRaConfig[4] = 43;   break;
//        case 11: S_LoRaConfig[4] = 45;   break;
//        case 12: S_LoRaConfig[4] = 47;   break;
//        case 13: S_LoRaConfig[4] = 49;   break;
//        case 14: S_LoRaConfig[4] = 51;   break;
//        case 15: S_LoRaConfig[4] = 53;   break;

//        default:break;
//    }
//    switch(fre)
//    {
//        case 0:  S_LoRaConfig[1] = 0xF0;   break;
//        case 1:  S_LoRaConfig[1] = 0xF1;   break;
//        case 2:  S_LoRaConfig[1] = 0xF2;   break;
//        case 3:  S_LoRaConfig[1] = 0xF3;   break;
//        case 4:  S_LoRaConfig[1] = 0xF4;   break;
//        case 5:  S_LoRaConfig[1] = 0xF5;   break;
//        case 6:  S_LoRaConfig[1] = 0xF6;   break;
//        case 7:  S_LoRaConfig[1] = 0xF7;   break;
//        case 8:  S_LoRaConfig[1] = 0xF8;   break;
//        case 9:  S_LoRaConfig[1] = 0xF9;   break;
//        case 10: S_LoRaConfig[1] = 0xFA;   break;
//        case 11: S_LoRaConfig[1] = 0xFB;   break;
//        case 12: S_LoRaConfig[1] = 0xFC;   break;
//        case 13: S_LoRaConfig[1] = 0xFD;   break;
//        case 14: S_LoRaConfig[1] = 0xFE;   break;
//        case 15: S_LoRaConfig[1] = 0xFF;   break;

//        default:break;
//    }

    S_LoRaConfig[1] = 0xA0+fre;
    S_LoRaConfig[4] = fre;

    tx_data[0] = 0xC0; //指令
    tx_data[1] = 0x00; //起始地址
    tx_data[2] = 0x06;

    for(unsigned char n=0;n<6;n++)
    {
        tx_data[3+n] = S_LoRaConfig[n];
    }
//    for(quint8 i=0;i<9;i++)
//        qDebug("tx_data %d %x",i,tx_data[i]);

    struct timeval tv;
    fd_set rfds;
    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_NRF905,tmp, 64);
            if(len > 0)
                continue;
            else break;
        }

        if(sizeof(tx_data) != WriteDev(FD_NRF905, tx_data, sizeof(tx_data)))
            res = CommTxError;
        if(res == CommOK){
            tv.tv_sec = 0;
            tv.tv_usec = 200000;

            FD_ZERO(&rfds);
            FD_SET( FD_NRF905,&rfds );
            int sres = select(FD_NRF905+1,&rfds,NULL,NULL,&tv);
            if(sres>0){
                if(sizeof(rx_data) == ReadDev(FD_NRF905,rx_data,sizeof(rx_data)))
                {
                    if(rx_data[0] != 0xC1)
                    {
                        res = CommDataError;
                    }
                    for(unsigned char n=1;n<sizeof(rx_data);n++)
                    {
                        if(rx_data[n] != tx_data[n])
                        {
                            res = CommDataError;
                            break;
                        }
                    }
                }
                else
                {
                    res = CommRxError;
                }
            }
            else{//无返回
                res = CommWrFailError;
            }
        }
        if(res == CommOK)
            break;
        else
        {
            msleep(200);
            qDebug("Uart_Write_LoRa_Config res = %d",res);
        }
    }
    return res;
}

int LORACELL::Read_LoRa_Config(unsigned char *pbuf)
{
    int ret = CommOK;
    Set_LoRa_Mode(3);
    ret = Uart_Read_LoRa_Config(pbuf);
    Set_LoRa_Mode(0);
    return ret;
}

int LORACELL::Uart_Read_LoRa_Config(unsigned char *pbuf)
{
    unsigned char tx_data[3] = {0};
    unsigned char rx_data[9] = {0};
    int res = CommOK;
    tx_data[0] = 0xC1; //指令
    tx_data[1] = 0x00; //起始地址
    tx_data[2] = 0x06;

    struct timeval tv;
    fd_set rfds;
    for(quint8 t = 0;t<3;t++) //retry 3 times
    {
        res = CommOK;

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

        if(sizeof(tx_data) != WriteDev(FD_NRF905, tx_data, sizeof(tx_data)))
            res = CommTxError;
        if(res == CommOK){
            tv.tv_sec = 0;
            tv.tv_usec = 200000;

            FD_ZERO(&rfds);
            FD_SET( FD_NRF905,&rfds );
            int sres = select(FD_NRF905+1,&rfds,NULL,NULL,&tv);
            if(sres>0){
                if(sizeof(rx_data) == ReadDev(FD_NRF905,rx_data,sizeof(rx_data)))
                {
                    for(unsigned char n=0;n<sizeof(tx_data);n++)
                    {
                        if(rx_data[n] != tx_data[n])
                        {
                            res = CommDataError;
                            break;
                        }
                    }
                    memcpy(pbuf,&rx_data[3],6);
                }
                else
                {
                    res = CommRxError;
                }
            }
            else{//无返回
                res = CommWrFailError;
            }
        }
        if(res == CommOK)
            break;
        else
        {
            msleep(200);
            qDebug("Uart_Read_LoRa_Config res = %d",res);
        }
    }
    return res;
}

void LORACELL::Set_LoRa_Mode(const unsigned char mode){
    msleep(20); //延时，重要
    switch(mode)
    {
        case 0: //M1_0; M0_0;break;   //透传模式
        {
            gpio_set_level(GPIO_INDEX_TX,GPIO_LEVEL_LOW);
            gpio_set_level(GPIO_INDEX_RX,GPIO_LEVEL_LOW);
            break;
        }
        case 3: //M1_1; M0_1;break;   //休眠模式，可配置参数
        {
            gpio_set_level(GPIO_INDEX_TX,GPIO_LEVEL_HIGH);
            gpio_set_level(GPIO_INDEX_RX,GPIO_LEVEL_HIGH);
            break;
        }
        default:break;
    }
    msleep(20); //延时，重要
}

void LORACELL::setWorkNum(int num_g,int num_eachm){
    BattGroup = num_g;
    EachGroupBattSum = num_eachm;
    if((EachGroupBattSum%4) == 0)
            EachGroupModule = EachGroupBattSum/4;
        else EachGroupModule = EachGroupBattSum/4 + 1;

    Work_Num = EachGroupModule*num_g;
}

void LORACELL::setWorkParam(int param1, int param2){
    //编号顺序、频段
    Work_Order = param1;
    if(param2>=1 && param2 <=16)
        Write_LoRa_Config(param2);
    memset(battVolData,0x00,sizeof(battVolData));
    memset(battVolErrCnt,0x00,sizeof(battVolErrCnt));
}

int LORACELL::setWorkFre(int fre){
    int res = CommOK;
    if(fre>=0 && fre <=15)
        res = Write_LoRa_Config(fre);
    memset(battVolData,0x00,sizeof(battVolData));
    memset(battVolErrCnt,0x00,sizeof(battVolErrCnt));
    return res;
}

int LORACELL::getWorkFre(){
    int workfre = -1;
    unsigned char rx_data[6] = {0};
    if(Read_LoRa_Config(rx_data)==CommOK){
        switch(rx_data[4])
        {
            case 23:  workfre = 0;   break;
            case 25:  workfre = 1;   break;
            case 27:  workfre = 2; 	 break;
            case 29:  workfre = 3; 	 break;
            case 31:  workfre = 4;   break;
            case 33:  workfre = 5;   break;
            case 35:  workfre = 6;   break;
            case 37:  workfre = 7;   break;
            case 39:  workfre = 8;   break;
            case 41:  workfre = 9;   break;
            case 43: workfre = 10;   break;
            case 45: workfre = 11;   break;
            case 47: workfre = 12;   break;
            case 49: workfre = 13;   break;
            case 51: workfre = 14;   break;
            case 53: workfre = 15;   break;

            default:break;
        }
    }
    return workfre+1;
}

bool LORACELL::readMonVol(int maddr,int timeout_ms){
    QMutexLocker locker(&rs485_mutex);
    int res = CommOK;
    RFData TX_Data;
    RFData RX_Data;
    quint8 tx_addr[4] = {0xAB,0xCD,0x00,0x01};
    if(readmode == MODE_CYCLE){
        tx_addr[3] = maddr+1;
    }
    else {
        tx_addr[3] = maddr;
    }
    memset(&TX_Data,0,sizeof(TX_Data));
    memset(&RX_Data,0,sizeof(RX_Data));

    TX_Data.Addr[0] = 0xAB;
    TX_Data.Addr[1] = 0xCD;
    TX_Data.Addr[2] = S_LoRaConfig[4];
    TX_Data.Addr[3] = S_LoRaConfig[1];
    TX_Data.CMD = CMD_READVOL;
    TX_Data.CRC = CRC16::CalCRC16(&TX_Data,sizeof(TX_Data)-2);

    res = TxPacket(tx_addr,&TX_Data,nowfre);
    if(res == CommOK){
        res = ReadData(&RX_Data,sizeof(RX_Data),timeout_ms/5);
    }
    if(res == CommOK){
        if(CheckDataIfOK(tx_addr,TX_Data,&RX_Data)!=0)//校验失败
            res = CommDataError;
    }
    if(res == CommOK){
        for(int i=0;i<4;i++){
            if(RX_Data.VolData[i]>MON_MAX_VOL)
                RX_Data.VolData[i] = MON_MAX_VOL;
        }
        if(readmode == MODE_CYCLE){
            ClassXML::set_battVolData(maddr,RX_Data.VolData,battVolData,
                                Work_Order,EachGroupBattSum,EachGroupModule,BattGroup);
            if(battVolErrCnt[maddr] != 0)
            {
                //qDebug("clean maddr=%d,  battVolErrCnt=%d",maddr+1,battVolErrCnt[maddr]);
                battVolErrCnt[maddr] = 0;
            }
        }
        else {
            module0vol[0] = RX_Data.VolData[0];
            module0vol[1] = RX_Data.VolData[1];
            module0vol[2] = RX_Data.VolData[2];
            module0vol[3] = RX_Data.VolData[3];
        }
    }
    else {
        if(readmode == MODE_CYCLE){
            if(++battVolErrCnt[maddr] > 4)
            {
                //数据清零
                Rx_Data_RF temp;
                memset(&temp,0,sizeof(temp));
                temp.Addr = maddr+1;
                ClassXML::set_battVolData(maddr,temp.VolData,battVolData,Work_Order,
                                        EachGroupBattSum,EachGroupModule,BattGroup);
                battVolErrCnt[maddr] = 0;
            }
        }
        else {
            for(int b=0;b<4;b++)
            {
                module0vol[b] = 0;
            }
        }
    }
    return res;
}

bool LORACELL::readMonVersion(int maddr,int timeout_ms){
    QMutexLocker locker(&rs485_mutex);
    int res = CommOK;
    RFData TX_Data;
    RFData RX_Data;
    quint8 tx_addr[4] = {0xAB,0xCD,0x00,0x01};
    tx_addr[3] = maddr;

    memset(&TX_Data,0,sizeof(TX_Data));
    memset(&RX_Data,0,sizeof(RX_Data));

    TX_Data.Addr[0] = 0xAB;
    TX_Data.Addr[1] = 0xCD;
    TX_Data.Addr[2] = S_LoRaConfig[4];
    TX_Data.Addr[3] = S_LoRaConfig[1];
    TX_Data.CMD = CMD_VERSION;
    TX_Data.CRC = CRC16::CalCRC16(&TX_Data,sizeof(TX_Data)-2);

    res = TxPacket(tx_addr,&TX_Data,nowfre);
    if(res == CommOK){
        res = ReadData(&RX_Data,sizeof(RX_Data),timeout_ms/5);
    }
    if(res == CommOK){
        if(CheckDataIfOK(tx_addr,TX_Data,&RX_Data)!=0)//校验失败
            res = CommDataError;
    }
    if(res == CommOK){
        if(readmode == MODE_CYCLE){
            ;
        }
        else {
            monversion[0] = RX_Data.VolData[0];
            monversion[1] = RX_Data.VolData[1];
            monversion[2] = RX_Data.VolData[2];
            monversion[3] = RX_Data.VolData[3];
        }
    }
    else {
        memset(monversion,0x00,sizeof(monversion));
    }
    return res;
}

bool LORACELL::setmoduleaddr(int num, int num2){//目标模块，设置地址
    QMutexLocker locker(&rs485_mutex);
    int res = CommOK;
    RFData TX_Data;
    RFData RX_Data;
    quint8 tx_addr[4] = {0xAB,0xCD,0x00,0x00};
    tx_addr[3] = num;

    memset(&TX_Data,0,sizeof(TX_Data));

    TX_Data.Addr[0] = 0xAB;
    TX_Data.Addr[1] = 0xCD;
    TX_Data.Addr[2] = S_LoRaConfig[4];
    TX_Data.Addr[3] = S_LoRaConfig[1];
    TX_Data.CMD = CMD_SETMONADDR;//0x00A2
    TX_Data.VolData[0] = 0xCDAB;
    TX_Data.VolData[1] = (num2<<8);
    TX_Data.VolData[2] = 0;
    TX_Data.VolData[3] = 0;
    TX_Data.CRC = CRC16::CalCRC16(&TX_Data,sizeof(TX_Data)-2);

    struct timeval tv;
    fd_set rfds;
    for(quint8 t = 0;t<3;t++) //retry 3 times
    {
        memset(&RX_Data,0,sizeof(RX_Data));
        res = CommOK;

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

        res = TxPacket(tx_addr,&TX_Data,nowfre);
        if(res == CommOK){
            tv.tv_sec = 2;
            tv.tv_usec = 0;

            FD_ZERO(&rfds);
            FD_SET( FD_NRF905,&rfds );
            int sres = select(FD_NRF905+1,&rfds,NULL,NULL,&tv);
            if(sres>0){
                if(sizeof(RX_Data) != ReadDev(FD_NRF905,&RX_Data,sizeof(RX_Data))){//读取失败
                    res = CommRxError;
                }
                else {
                    tx_addr[3] = num2;
                    if(CheckDataIfOK(tx_addr,TX_Data,&RX_Data)!=0)//校验失败
                        res = CommDataError;
                }
            }
            else{//无返回
                res = CommWrFailError;
            }
        }

        if(res == CommOK)
            break;
        else
        {
            msleep(200);
            qDebug("setmoduleaddr res = %d",res);
        }
    }
    return res;
}

bool LORACELL::setmodulefre(int num, int num2){
    QMutexLocker locker(&rs485_mutex);
    int res = CommOK;
    RFData TX_Data;
    RFData RX_Data;
    quint8 tx_addr[4] = {0xAB,0xCD,0x00,0x00};
    tx_addr[3] = num;

    memset(&TX_Data,0,sizeof(TX_Data));
    memset(&RX_Data,0,sizeof(RX_Data));

    TX_Data.Addr[0] = 0xAB;
    TX_Data.Addr[1] = 0xCD;
    TX_Data.Addr[2] = S_LoRaConfig[4];
    TX_Data.Addr[3] = S_LoRaConfig[1];
    TX_Data.CMD = CMD_SETMONFRE;//0x00A8
    TX_Data.VolData[0] = 0xCDAB;
    TX_Data.VolData[1] = (num2<<8);
    TX_Data.VolData[2] = 0;
    TX_Data.VolData[3] = 0;
    TX_Data.CRC = CRC16::CalCRC16(&TX_Data,sizeof(TX_Data)-2);

    struct timeval tv;
    fd_set rfds;
    for(quint8 t = 0;t<3;t++) //retry 3 times
    {
        res = CommOK;

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

        res = TxPacket(tx_addr,&TX_Data,nowfre);
        if(res == CommOK){
            tv.tv_sec = 2;
            tv.tv_usec = 0;

            FD_ZERO(&rfds);
            FD_SET( FD_NRF905,&rfds );
            int sres = select(FD_NRF905+1,&rfds,NULL,NULL,&tv);
            if(sres>0){
                if(sizeof(RX_Data) != ReadDev(FD_NRF905,&RX_Data,sizeof(RX_Data))){//读取失败
                    res = CommRxError;
                }
                else {
                    if(CheckDataIfOK(tx_addr,TX_Data,&RX_Data)!=0)//校验失败
                        res = CommDataError;
                }
            }
            else{//无返回
                res = CommWrFailError;
            }
        }
        if(res == CommOK)
            break;
        else
        {
            msleep(200);
            qDebug("setmodulefre res = %d",res);
        }
    }
    return res;
}

void LORACELL::GetBattVolData(void *data)
{
    int monnum = BattGroup*EachGroupBattSum;
    for(int i=monnum;i<MONOMER_NUM_MAX;i++)
        battVolData[i]=0;
    memcpy(data,battVolData,sizeof(battVolData));
}

int LORACELL::ReadData(void *buf, const int len, const int timeout_5ms)
{
    quint16 rx_len = 0;
    quint16 rx_time_out = 0;
    quint8 *p_rxdata = (quint8 *)buf;

    quint8 rx_databuff[512] = {0};
    quint16 bytes = 16;

    while(1)
    {
        int rlen = ReadDev(FD_NRF905,&rx_databuff, bytes);
        //qDebug("rlen = %d",rlen);
        if(rlen > 0){
            for(int i=0;i<rlen;i++)
            {
                if(rx_len < len){
                    p_rxdata[rx_len++] = rx_databuff[i];
                    //qDebug("p_rxdata[%d]=%x",rx_len,p_rxdata[rx_len-1]);
                }
                else
                    break;
            }

            rx_time_out = 0;
        }
        else{
            if(rx_len>0 && rx_time_out>20) //收到了部分字节后,字节之间超时 x*5ms
            {
                //qDebug("rx_len = %d",rx_len);
                return CommRxError;
            }
            //qDebug("rx_time_out = %d timeout_5ms = %d",rx_time_out,timeout_5ms);
            if(rx_time_out > timeout_5ms) //接收超时 timeout_5ms * 5ms
            {
                return CommWrFailError;
            }
        }

        if(rx_len >= len){
            return CommOK;
        }

        rx_time_out++;

        msleep(5);
    }
}

//一个单体模块的四节单体一起校准
bool LORACELL::adjmon_offset(int num, int vol){//模块地址，偏移量(差值)mV
    QMutexLocker locker(&rs485_mutex);
    int res = CommOK;
    RFData TX_Data;
    RFData RX_Data;
    quint8 tx_addr[4] = {0xAB,0xCD,0x00,0x00};
    unsigned int TXmoduladdr = 0;
    TXmoduladdr = num;//单体模块地址

    tx_addr[3] = (unsigned char)TXmoduladdr;
    tx_addr[2] = (unsigned char)(TXmoduladdr>>8);

    memset(&TX_Data,0,sizeof(TX_Data));
    if(vol<0)
        vol = 0;
    TX_Data.Addr[0] = 0xAB;
    TX_Data.Addr[1] = 0xCD;
    TX_Data.Addr[2] = S_LoRaConfig[4];
    TX_Data.Addr[3] = S_LoRaConfig[1];
    TX_Data.CMD = CMD_SetADJOffSet;
    TX_Data.VolData[0] = vol;
    TX_Data.VolData[1] = 0;
    TX_Data.VolData[2] = 0;
    TX_Data.VolData[3] = 0;
    TX_Data.CRC = CRC16::CalCRC16(&TX_Data,sizeof(TX_Data)-2);

    struct timeval tv;
    fd_set rfds;
    for(quint8 t = 0;t<3;t++) //retry 3 times
    {
        memset(&RX_Data,0,sizeof(RX_Data));
        res = CommOK;

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

        res = TxPacket(tx_addr,&TX_Data,nowfre);
        if(res == CommOK){
            tv.tv_sec = 0;
            tv.tv_usec = 2000000;

            FD_ZERO(&rfds);
            FD_SET( FD_NRF905,&rfds );
            int sres = select(FD_NRF905+1,&rfds,NULL,NULL,&tv);
            if(sres>0){
                if(sizeof(RX_Data) != ReadDev(FD_NRF905,&RX_Data,sizeof(RX_Data))){//读取失败
                    res = CommRxError;
                }
                else {
                    if(CheckDataIfOK(tx_addr,TX_Data,&RX_Data)!=0)//校验失败
                        res = CommDataError;
                }
            }
            else{//无返回
                res = CommWrFailError;
            }
        }

        if(res == CommOK)
            break;
        else
        {
            msleep(200);
            qDebug("adjmon_offset res = %d",res);
        }
    }
    if(res == CommOK)
        return true;
    else
        return false;
}

bool LORACELL::adjmon_slope(int num, int vol){//模块地址，斜率值*10000
    QMutexLocker locker(&rs485_mutex);
    int res = CommOK;
    RFData TX_Data;
    RFData RX_Data;
    quint8 tx_addr[4] = {0xAB,0xCD,0x00,0x00};
    unsigned int TXmoduladdr = 0;
    TXmoduladdr = num;//单体模块地址

    tx_addr[3] = (unsigned char)TXmoduladdr;
    tx_addr[2] = (unsigned char)(TXmoduladdr>>8);

    memset(&TX_Data,0,sizeof(TX_Data));

    TX_Data.Addr[0] = 0xAB;
    TX_Data.Addr[1] = 0xCD;
    TX_Data.Addr[2] = S_LoRaConfig[4];
    TX_Data.Addr[3] = S_LoRaConfig[1];
    TX_Data.CMD = CMD_SetADJSlope;
    TX_Data.VolData[0] = vol;
    TX_Data.VolData[1] = 0;
    TX_Data.VolData[2] = 0;
    TX_Data.VolData[3] = 0;
    TX_Data.CRC = CRC16::CalCRC16(&TX_Data,sizeof(TX_Data)-2);

    struct timeval tv;
    fd_set rfds;
    for(quint8 t = 0;t<3;t++) //retry 3 times
    {
        memset(&RX_Data,0,sizeof(RX_Data));
        res = CommOK;

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

        res = TxPacket(tx_addr,&TX_Data,nowfre);
        if(res == CommOK){
            tv.tv_sec = 0;
            tv.tv_usec = 2000000;

            FD_ZERO(&rfds);
            FD_SET( FD_NRF905,&rfds );
            int sres = select(FD_NRF905+1,&rfds,NULL,NULL,&tv);
            if(sres>0){
                if(sizeof(RX_Data) != ReadDev(FD_NRF905,&RX_Data,sizeof(RX_Data))){//读取失败
                    res = CommRxError;
                }
                else {
                    if(CheckDataIfOK(tx_addr,TX_Data,&RX_Data)!=0)//校验失败
                        res = CommDataError;
                }
            }
            else{//无返回
                res = CommWrFailError;
            }
        }

        if(res == CommOK)
            break;
        else
        {
            msleep(200);
            qDebug("adjmon_slope res = %d",res);
        }
    }
    if(res == CommOK)
        return true;
    else
        return false;
}

void LORACELL::setadjindex(int param){
    adj_index = param;
}

int LORACELL::AdjMonoVol(const quint8 index,const quint16 vol,int index_type)
{
    QMutexLocker locker(&rs485_mutex);
    int res = CommOK;
    int get_index = index;
    if(index_type == 1)
        get_index = adj_index;
    quint8 addr_index = ClassXML::getMonModuleAddr(get_index,EachGroupModule,EachGroupBattSum);//计算单体号对应的模块地址

    if(addr_index >= Work_Num)
        res = CommTxError;

    if(res == CommOK){
        RFData TX_Data;
        RFData RX_Data;
        quint8 tx_addr[4] = {0xAB,0xCD,0x00,0x00};
        unsigned int TXmoduladdr = 0;
        TXmoduladdr = addr_index+1;//单体模块地址

        tx_addr[3] = (unsigned char)TXmoduladdr;
        tx_addr[2] = (unsigned char)(TXmoduladdr>>8);

        memset(&TX_Data,0,sizeof(TX_Data));

        TX_Data.Addr[0] = 0xAB;
        TX_Data.Addr[1] = 0xCD;
        TX_Data.Addr[2] = S_LoRaConfig[4];
        TX_Data.Addr[3] = S_LoRaConfig[1];
        TX_Data.CMD = CMD_ADJMONVOL;
        for(int i=0;i<4;i++)
            TX_Data.VolData[i] = 0;

        ClassXML::set_addr_VolData(addr_index,TX_Data.VolData,battVolData,
                                    Work_Order,EachGroupBattSum,EachGroupModule,BattGroup);

        ClassXML::set_adj_vol(addr_index,get_index,TX_Data.VolData,vol,
                            Work_Order,EachGroupBattSum,EachGroupModule);

        TX_Data.CRC = CRC16::CalCRC16(&TX_Data,sizeof(TX_Data)-2);

        struct timeval tv;
        fd_set rfds;
        for(quint8 t = 0;t<3;t++) //retry 3 times
        {
            memset(&RX_Data,0,sizeof(RX_Data));
            res = CommOK;

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

            res = TxPacket(tx_addr,&TX_Data,nowfre);
            if(res == CommOK){
                tv.tv_sec = 0;
                tv.tv_usec = 2000000;

                FD_ZERO(&rfds);
                FD_SET( FD_NRF905,&rfds );
                int sres = select(FD_NRF905+1,&rfds,NULL,NULL,&tv);
                if(sres>0){
                    if(sizeof(RX_Data) != ReadDev(FD_NRF905,&RX_Data,sizeof(RX_Data))){//读取失败
                        res = CommRxError;
                    }
                    else {
                        if(CheckDataIfOK(tx_addr,TX_Data,&RX_Data)!=0)//校验失败
                            res = CommDataError;
                    }
                }
                else{//无返回
                    res = CommWrFailError;
                }
            }

            if(res == CommOK)
                break;
            else
            {
                msleep(200);
            }
        }
    }
    if(res == CommOK)
        return true;
    else
        return false;
}

QString LORACELL::get_version(){
    QString ver = QString("version: %1.%2.%3").arg(QString::number(monversion[2]))
                                              .arg(QString::number(monversion[1]))
                                              .arg(QString::number(monversion[0]));
    return ver;
}

void LORACELL::getmodulevol(void *data){
    memcpy(data,module0vol,sizeof(module0vol));
}