A1210_Desktop/comWorks.cpp

#include "comWorks.h"
#include "mainwindow.h"
#include <QtSerialPort/QSerialPort>
#include <QtSerialPort/QSerialPortInfo>
#include "QThread"


//bool connectToCom();

#define PACKET_STATE_SIZE 26
#define PACKET_SENS_SIZE 10

#define READY_FOR_READ_INT 400

extern QSerialPort *serial;

static const uint16_t Crc16Table[256] =
{
    0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241,
    0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440,
    0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40,
    0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841,
    0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40,
    0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41,
    0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641,
    0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040,
    0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240,
    0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441,
    0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41,
    0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840,
    0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41,
    0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40,
    0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640,
    0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041,
    0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240,
    0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441,
    0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41,
    0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840,
    0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41,
    0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40,
    0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640,
    0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041,
    0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241,
    0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440,
    0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40,
    0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841,
    0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40,
    0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41,
    0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641,
    0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040
};

uint16_t Crc16(uint16_t len, uint16_t iobuf[])  //CRC  для сообщения такой то длинны /Len - начало контрольной сумимы
{
uint16_t i;
uint16_t crc = 0xFFFF;

    for(i = 0; i < len; i++) {
        crc = (crc >> 8) ^ Crc16Table[(crc & 0xFF) ^ (iobuf[i]& 0xFF)];
    }
    return crc;
}


uint16_t Crc16(uint16_t len, QByteArray iobuf)  //CRC  для сообщения такой то длинны /Len - начало контрольной сумимы
{
uint16_t i;
uint16_t crc = 0xFFFF;

    for(i = 0; i < len; i++) {
        crc = (crc >> 8) ^ Crc16Table[(crc & 0xFF) ^ (iobuf[i] & 0xFF)]; // ввел маску 0xFF, тк прилетает 0хFFFFFFxx
    }
    return crc;
}


stateStruct readSet(QSerialPort *serial, uint16_t adr){


 //   qDebug()<<"чтение состояния";
    stateStruct readed;
    uint16_t recived[PACKET_STATE_SIZE]; /// поменял
    uint16_t toSend[8];
    toSend[0]=adr;
    toSend[1]=0x3;  // comand
    toSend[2]=0x13;//hi addr 5001
    toSend[3]=0x89; //low addr
    toSend[4]=0x00; //hi regs
    toSend[5]=0xb;//low regs  //11 регистров

    uint16_t crcToSend;
    crcToSend= Crc16((uint16_t)6, toSend);
    toSend[6]=LO(crcToSend);//lo CRC
    toSend[7]=HI(crcToSend);//hi CRC

    QByteArray readCom;
    readCom.resize(8);
    readCom[0]=toSend[0];
    readCom[1]=toSend[1];
    readCom[2]=toSend[2];  //hi addr 5001
    readCom[3]=toSend[3];     //low addr
    readCom[4]=toSend[4];  //hi regs
    readCom[5]=toSend[5];  //low regs
    readCom[6]=toSend[6];  //lo CRC
    readCom[7]=toSend[7];  //hi CRC


    QByteArray rec;
    rec.resize(PACKET_STATE_SIZE);

    serial->open(QIODevice::ReadWrite);
    serial->write(readCom);
    serial->waitForReadyRead(READY_FOR_READ_INT);   //todo: блочное устройство, иногда читаю не все байты нужна функция приема
    rec = serial->readAll();
    serial->close();


    for(int i=0; i<=PACKET_STATE_SIZE;i++){
    recived[i]=rec.constData()[i];
    }

    int indNachalaCrc = recived[2]+3;
    uint16_t crcRecived = Crc16(indNachalaCrc, recived);  // в функции используют больше или меньше

     if((recived[indNachalaCrc]&0xFF)==LO(crcRecived)&&(recived[indNachalaCrc+1]&0xFF)==HI(crcRecived)){ //todo внимание костыль
        qDebug()<<"чтение состояния CRC Ок ";
        readed.crcOk = true;
    }else{
        qDebug()<<"чтение состояния CRC не катит";
        readed.crcOk = false;
    }


    readed.fn=(typeIFN)recived[8];
    readed.fv=(typeIFV)recived[6];
    readed.in=(typeIIN)recived[2]; //!!!шляпа он точно не второй
    readed.ku=(typeIKU)recived[10];
    readed.unit=(typeUnit)recived[22];
    readed.overload=(typeOverload)recived[24];
    readed.pz=(typePlavGround)recived[18];

    return readed;
};

sensStruct readSens(QSerialPort *serial,uint16_t adr){   //todo: неплохо если ты посчитаешь контрольные суммы, Дима.

//    qDebug()<<"Сработало чтение чувствительности";
 sensStruct result;
    usfloat res;
    res.ch[0] =0;
    res.ch[1] =0;
    res.ch[2] =0;
    res.ch[3] =0;
    //структура на отправку
    uint16_t toSend[8]={0,};
    uint16_t recived[25]={0,};
    toSend[0]=adr;
    toSend[1]=0x3;  // comand

    toSend[2]=0x1b;//hi addr 7004
    toSend[3]=0x5c; //low addr 7004

    toSend[4]=0x00; //hi regs
    toSend[5]=0x02;//low regs
    uint16_t crc = Crc16(6, toSend);
    toSend[6]=LO(crc);//lo CRC
    toSend[7]=HI(crc);//hi CRC

    QByteArray readCom;
    readCom.resize(8);

    readCom[0]=toSend[0];
    readCom[1]=toSend[1];
    readCom[2]=toSend[2];  //hi addr 5001
    readCom[3]=toSend[3];     //low addr
    readCom[4]=toSend[4];  //hi regs
    readCom[5]=toSend[5];  //low regs
    readCom[6]=toSend[6];  //lo CRC
    readCom[7]=toSend[7];  //hi CRC

    QByteArray rec;
    rec.resize(PACKET_SENS_SIZE);
    serial->open(QIODevice::ReadWrite); // открыли порт на запись и чтение
    serial->write(readCom);
    serial->waitForReadyRead(READY_FOR_READ_INT);
    rec = serial->readAll();
    serial->close();



    for(int i=0; i<PACKET_SENS_SIZE;i++){
    recived[i]=rec.constData()[i];
    }

    int indNachalaCrc = recived[2]+3; //todo: проверить
    uint16_t crcRecived = Crc16(indNachalaCrc, recived);  // в функции используют больше или меньше



    if((recived[indNachalaCrc]&0xFF)==LO(crcRecived)&&(recived[indNachalaCrc+1]&0xFF)==HI(crcRecived)){ //todo внимание костыль
        result.crcOk =true;
    }else{
       result.crcOk =false;
    }

    res.ch[3]=recived[3];				// Собираю флоат
    res.ch[2]=recived[4];
    res.ch[1]=recived[5];
    res.ch[0]=recived[6];

    qDebug()<<(float)res.fl;
    result.sens =res.fl;
    return result;
}



bool writePalam(QSerialPort *serial, uint16_t adr, typeParam typeparam, uint16_t value)
{
    QByteArray writeCom;
    writeCom.resize(11);
    writeCom[0]=adr;
    writeCom[1]=0x10;  // comand

    switch (typeparam) {

    case in:
        writeCom[2]=0x13;//hi addr 5001
        writeCom[3]=0x89; //low addr5001
        break;

    case ku:
        writeCom[2]=0x13;//hi addr 5004
        writeCom[3]=0x8c; //low addr5004
        break;

    case fv:
        writeCom[2]=0x13;//hi addr 5002
        writeCom[3]=0x8a; //low addr5002
        break;

    case fn:
        writeCom[2]=0x13;//hi addr 5003
        writeCom[3]=0x8b; //low addr5003
        break;

    case unit:
        writeCom[2]=0x13;//hi addr 5010
        writeCom[3]=0x92; //low addr5010
        break;


    case overload:
        writeCom[2]=0x13;//hi addr 5011
        writeCom[3]=0x93; //low addr5011
        break;

    case pz:
        writeCom[2]=0x13;//hi addr 5008
        writeCom[3]=0x90; //low addr5008
        break;

    default:
        qDebug() << "передано неверное значение типа параметра";
        break;

    }

    //пишем по одномк регистру
    writeCom[4]=0x00; //hi regs
    writeCom[5]=0x1;//low regs
    writeCom[6]=0x2;// байт на отправку
    writeCom[7]=0;
    writeCom[8]=value; //значение на отправку

    uint16_t crcToSend;
    crcToSend= Crc16((uint16_t)9, writeCom);  //длинна захардкожена //Возможно будет неправильно считать
    writeCom[9]=LO(crcToSend);//lo CRC
    writeCom[10]=HI(crcToSend);//hi CRC


    qDebug()<<QByteArray::number(writeCom[0], 16)<< "adr";
    qDebug()<<QByteArray::number(writeCom[1], 16)<< "comand";
    qDebug()<<QByteArray::number(writeCom[2], 16)<< "adr reg HI";
    qDebug()<<QByteArray::number(writeCom[3], 16)<< "adr reg LO";
    qDebug()<<QByteArray::number(writeCom[4], 16)<< "num reg HI";
    qDebug()<<QByteArray::number(writeCom[5], 16)<< "num reg Lo";
    qDebug()<<QByteArray::number(writeCom[6], 16)<< "num reg bytes";
    qDebug()<<QByteArray::number(writeCom[7], 16)<< "num reg HI data";
    qDebug()<<QByteArray::number(writeCom[8], 16)<< "num reg LO data";
    qDebug()<<QByteArray::number(writeCom[9], 16)<< " LO CRC ";
    qDebug()<<QByteArray::number(writeCom[10], 16)<< "CRC HI";

    serial->open(QIODevice::ReadWrite);
    serial->write(writeCom);
    serial->waitForReadyRead(READY_FOR_READ_INT);


    QByteArray rec;
    rec = serial->readAll();

    qDebug()<<rec.toHex();

    serial->close();


    return 1;
}

bool writeSens(QSerialPort *serial, uint16_t adr, float value)
{
    QByteArray writeCom;
    writeCom.resize(11);
    writeCom[0]=adr;
    writeCom[1]=0x10;  // comand
    writeCom[2]=0x1b;//hi addr 7004
    writeCom[3]=0x5c; //low addr 7004
    writeCom[4]=0x00; //hi regs
    writeCom[5]=0x2;//low regs
    writeCom[6]=0x4;// байт на отправку //а не 2=)

    usfloat res;
    res.fl=value;

    writeCom[7]=res.ch[3]&0xFF;				// Собираю флоат
    writeCom[8]=res.ch[2]&0xFF;
    writeCom[9]=res.ch[1]&0xFF;
    writeCom[10]=res.ch[0]&0xFF;

    uint16_t crcToSend;
    crcToSend= Crc16((uint16_t)11, writeCom);  //длинна захардкожена //Возможно будет неправильно считать
    writeCom[11]=(LO(crcToSend)&0xFF);//lo CRC
    writeCom[12]=(HI(crcToSend)&0xFF);//hi CRC

    qDebug()<<writeCom.toHex();  // с этой шляпой всё работает

    qDebug()<<QByteArray::number(writeCom[0], 16)<< "adr";
    qDebug()<<QByteArray::number(writeCom[1], 16)<< "comand";
    qDebug()<<QByteArray::number(writeCom[2], 16)<< "reg HI";
    qDebug()<<QByteArray::number(writeCom[3], 16)<< "adr reg LO";
    qDebug()<<QByteArray::number(writeCom[4], 16)<< "num reg HI";
    qDebug()<<QByteArray::number(writeCom[5], 16)<< "num reg Lo";
    qDebug()<<QByteArray::number(writeCom[6], 16)<< "num reg bytes";
    qDebug()<<QByteArray::number(writeCom[7], 16)<< "HI data";
    qDebug()<<QByteArray::number(writeCom[8], 16)<< "LO data";
    qDebug()<<QByteArray::number(writeCom[9], 16)<< "HI data";
    qDebug()<<QByteArray::number(writeCom[10], 16)<< "LO data";
    qDebug()<<QByteArray::number(writeCom[11], 16)<< " LO CRC ";
    qDebug()<<QByteArray::number(writeCom[12], 16)<< "CRC HI";



    serial->open(QIODevice::ReadWrite);
    serial->write(writeCom);
    serial->waitForReadyRead(READY_FOR_READ_INT);

    QByteArray rec;
    rec = serial->readAll();



    qDebug()<<rec.toHex();

    serial->close();

    return 1;

}


bool writeConSet(QSerialPort *serial, uint16_t adrCurrent,
                 uint16_t adrNew, uint32_t new_speed, Parity parity)
{
    QByteArray writeCom;
    writeCom.resize(11);
    writeCom[0]=adrCurrent;
    writeCom[1]=0x10;  // comand
    writeCom[2]=0xf;//hi addr 4001
    writeCom[3]=0xa1; //low addr 4001
    writeCom[4]=0x00; //hi regs
    writeCom[5]=0x3;//low regs
    writeCom[6]=0x6;// байт на отправку

    writeCom[7]=0x0;
    writeCom[8]=adrNew;   //новый адрес

    writeCom[9]=0x0;

    switch (new_speed) {
    case 4800:
    writeCom[10]=0x0; //скорость
        break;
    case 7200:
    writeCom[10]=0x1; //скорость
        break;
    case 9600:
    writeCom[10]=0x2; //скорость
        break;
    case 14400:
    writeCom[10]=0x3; //скорость
        break;
    case 19200:
    writeCom[10]=0x4; //скорость
        break;
    case 38400:
    writeCom[10]=0x5; //скорость
        break;
    case 57600:
    writeCom[10]=0x6; //скорость
        break;
    case 115200:
    writeCom[10]=0x7; //скорость
        break;
    case 128000:
    writeCom[10]=0x8; //скорость
        break;
    case 230400:
    writeCom[10]=0x9; //скорость
        break;
    default:
        qDebug()<<"Со скоростью беда";
        break;
    }
    writeCom[11]=0x0;
    switch (parity) {
    case UART_PARITY_NONE:
     writeCom[12]=0x0;
        break;
    case UART_PARITY_ODD:
     writeCom[12]=0x1;
        break;
    case UART_PARITY_EVEN:
     writeCom[12]=0x2;
        break;
    }
     //бит четности


    uint16_t crcToSend;
    crcToSend= Crc16((uint16_t)13, writeCom);  //длинна захардкожена //Возможно будет неправильно считать
    writeCom[13]=(LO(crcToSend)&0xFF);//lo CRC
    writeCom[14]=(HI(crcToSend)&0xFF);//hi CRC


    qDebug()<<writeCom.toHex();  // с этой шляпой всё работает

    qDebug()<<QByteArray::number(writeCom[0], 16)<< "adr";
    qDebug()<<QByteArray::number(writeCom[1], 16)<< "comand";
    qDebug()<<QByteArray::number(writeCom[2], 16)<< "reg HI";
    qDebug()<<QByteArray::number(writeCom[3], 16)<< "adr reg LO";
    qDebug()<<QByteArray::number(writeCom[4], 16)<< "num reg HI";
    qDebug()<<QByteArray::number(writeCom[5], 16)<< "num reg Lo";
    qDebug()<<QByteArray::number(writeCom[6], 16)<< "num reg bytes";
    qDebug()<<QByteArray::number(writeCom[7], 16)<< "HI data";
    qDebug()<<QByteArray::number(writeCom[8], 16)<< "LO data";
    qDebug()<<QByteArray::number(writeCom[9], 16)<< "HI data";
    qDebug()<<QByteArray::number(writeCom[10], 16)<< "LO data";
    qDebug()<<QByteArray::number(writeCom[11], 16)<< "HI data";
    qDebug()<<QByteArray::number(writeCom[12], 16)<< "LO data";
    qDebug()<<QByteArray::number(writeCom[13], 16)<< " LO CRC ";
    qDebug()<<QByteArray::number(writeCom[14], 16)<< "CRC HI";


    serial->open(QIODevice::ReadWrite);
    serial->write(writeCom);
    serial->waitForReadyRead(READY_FOR_READ_INT);
    QByteArray rec;
    rec = serial->readAll();

    qDebug()<<rec.toHex();

    serial->close();
    if(((rec[0]&0xFF)==adrCurrent) && ((rec[1]&0xFF)==0x10)) return NO_ERROR;
    else return ERROR;

}


sensStruct readSensTest(QSerialPort *serial, uint16_t adr)
{


     sensStruct result;
        usfloat res;
        res.ch[0] =0;
        res.ch[1] =0;
        res.ch[2] =0;
        res.ch[3] =0;
        //структура на отправку
        uint16_t toSend[8]={0,};
        uint16_t recived[25]={0,};
        toSend[0]=adr;
        toSend[1]=0x3;  // comand

        //Если мы хотим читать 7502 - то нужно увеличить размер
        //toSend[2]=0x1d;//hi addr 7502
        //toSend[3]=0x4e; //low addr 7502

        toSend[2]=0x1b;//hi addr 7004
        toSend[3]=0x5c; //low addr 7004

        toSend[4]=0x00; //hi regs
        toSend[5]=0x02;//low regs
        uint16_t crc = Crc16(6, toSend);
        toSend[6]=LO(crc);//lo CRC
        toSend[7]=HI(crc);//hi CRC

        QByteArray readCom;
        readCom.resize(8);
       // uint16_t crc = Crc16(5);
        readCom[0]=toSend[0];
        readCom[1]=toSend[1];
        readCom[2]=toSend[2];  //hi addr 5001
        readCom[3]=toSend[3];     //low addr
        readCom[4]=toSend[4];  //hi regs
        readCom[5]=toSend[5];  //low regs
        readCom[6]=toSend[6];  //lo CRC
        readCom[7]=toSend[7];  //hi CRC

        serial->open(QIODevice::ReadWrite); // открыли порт на запись и чтение
        serial->write(readCom);
        serial->waitForReadyRead(READY_FOR_READ_INT);

        QByteArray rec;
        rec.resize(PACKET_SENS_SIZE);
        rec = serial->readAll();
        serial->close();



        for(int i=0; i<PACKET_SENS_SIZE;i++){
        recived[i]=rec.constData()[i];
        }

        int indNachalaCrc = recived[2]+3; //todo: проверить
        uint16_t crcRecived = Crc16(indNachalaCrc, recived);  // в функции используют больше или меньше
    //        qDebug()<<QString("Начало CRC в пакете %1").arg(indNachalaCrc);
    //        qDebug()<<QString("ожидаемая CRC %1%2").arg(LO(crcRecived), 0, 16).arg(HI(crcRecived), 0, 16);
    //        qDebug()<<QString("Прибывшая CRC %1%2").arg(recived[indNachalaCrc], 0, 16).arg(recived[indNachalaCrc+1], 0, 16);

        //если CRC Норм ставим зеленый
        if((recived[indNachalaCrc]&0xFF)==LO(crcRecived)&&(recived[indNachalaCrc+1]&0xFF)==HI(crcRecived)){ //todo внимание костыль
            result.crcOk =true;
            qDebug()<<"Чтение чувуствительности CRC Ок";
        }else{
            qDebug()<<"Чтение чувуствительности CRC не катит";
           result.crcOk =false;
        }


        res.ch[3]=recived[3];				// Собираю флоат
        res.ch[2]=recived[4];
        res.ch[1]=recived[5];
        res.ch[0]=recived[6];

        qDebug()<<(float)res.fl;
        result.sens =res.fl;
        return result;
}