Младший и старший байт и запись 16 битных чисел на ардуино

Serial2.begin(9600,SERIAL_8N2)

#ifndef APPFRAME_H
#define APPFRAME_H
 
#define RDTYPE                                  (164)
#define WRTYPE                                  (134)
#define ERR_OK                  (0)     //执行成功
#define ERR_ERROR               (1)     //执行错误
#define ERR_TIMEOUT             (2)     //通讯超时
#define ERR_INVALIED_PARAM                      (3)     //非法参数
 
//AIJ仪表通讯协议请求帧帧格式
typedef struct tagREQ_FRM_T
{
        quint8  u8DevAddr1;     //设备地址
        quint8  u8DevAddr2;     //设备地址
        quint8  u8ReqType;      //请求类型
        quint8  u8DevPara;      //设备参数
        quint8  u8LoParam;      //参数数据-低字节
        quint8  u8HiParam;      //参数数据-高字节
        quint8  u8LoSumCheck;           //累加和校验码-低字节
        quint8  u8HiSumCheck;           //累加和校验码-高字节
}REQ_FRM_T;
 
 
//AIJ仪表通讯协议应答帧帧格式
typedef struct tagANS_FRM_T
{
        quint8  u8LoPV;         //应答PV值的低字节
        quint8  u8HiPV;         //应答PV值的高字节
        quint8  u8LoSV;         //应答SV值的低字节
        quint8  u8HiSV;         //应答SV值的高字节
        quint8  u8LoMV;         //应答MV值
        quint8  u8HiMV;     //应答报警状态
        quint8  u8ALm;      //参数数据-低字节
        quint8  u8LoParam;      //参数数据-高字节
        quint8  u8HiParam;           //累加和校验码-低字节
        quint8  u8SumCheck;           //累加和校验码-高字节
}ANS_FRM_T;
 
 
 
#endif // APPFRAME_H

#include<QTime>
#include <QDebug>
#include "AppFrame.h"
#include "qcomprotocol.h"
 
static quint8 u8ResBuff[]= {3,2,2,2,2,2,2,2,2,3,2,2,3,2,3,2,2,2};
static quint8 u8InputStandard = 0;
 
QComProtocol::QComProtocol()
{
    m_MyComPort = NULL;
}
 
QComProtocol::~QComProtocol()
{
    if(m_MyComPort != NULL)
    {
        m_MyComPort->close();
        delete m_MyComPort;
    }
}
 
//向串口读取数据
qint64 QComProtocol::ReadData(char *pcReadBuff, qint64 nReadLenth)
{
    qint64 nTempReadLenth = 0;
 
    if((m_MyComPort != NULL) && (m_MyComPort->isOpen()))
    {
        nTempReadLenth = m_MyComPort->read(pcReadBuff, nReadLenth);
    }
    return nTempReadLenth;
}
 
 
//向串口写入数据
qint64 QComProtocol::WriteData(const char *pcWriteBuff, qint64 nWriteLenth)
{
    qint64 nTempWriteLenth=0;
    if((m_MyComPort != NULL) && (m_MyComPort->isOpen()))
    {
        nTempWriteLenth = m_MyComPort->write(pcWriteBuff, nWriteLenth);
    }
 
    return nTempWriteLenth;
}
 
 
//发送帧接口
bool QComProtocol::SendFrame(const char *pcFrameBuff, qint64 nFrameSize, int nTimeOut)
{
 
    QTime time;
    time.start();
 
    while((time.elapsed() < nTimeOut) && (nFrameSize > 0))
    {
        qint64 nWriteBytes = WriteData(pcFrameBuff, nFrameSize);
        pcFrameBuff += nWriteBytes;
        nFrameSize -= nWriteBytes;
    }
 
    return (nFrameSize==0);
}
 
 
//接收数据，接收完成返回true
bool QComProtocol::ReceiveFrame(char *pcFrameBuff, qint64 nFrameSize, int nTimeOut)
{
 
    QTime Time;
    Time.start();
    qint64 nReadCurCount = 0;
 
    while((Time.elapsed()< nTimeOut) && (nReadCurCount < nFrameSize))
    {
        qint64 nReadBytes = ReadData(pcFrameBuff, nFrameSize);
        pcFrameBuff += nReadBytes;
        nReadCurCount += nReadBytes;
    }
 
    return(nReadCurCount == nFrameSize);
}
 
 
 
bool QComProtocol::myComPortOpen(QSerialParameter &myComPortPara)
{
    //先判断串口是否存在，如果存在则删除重新创建
    if(m_MyComPort != NULL)
    {
        delete m_MyComPort;
        m_MyComPort = NULL;
    }
 
    m_MyComPort = new Win_QextSerialPort(myComPortPara.m_UartId,QextSerialBase::Polling);
    if( m_MyComPort->open(QIODevice::ReadWrite))
    {
        m_MyComPort->setBaudRate((BaudRateType)myComPortPara.m_UartBaud.toInt());
        m_MyComPort->setDataBits((DataBitsType)myComPortPara.m_UartDataBit.toInt());
        m_MyComPort->setStopBits((StopBitsType)myComPortPara.m_UartStopBit.toInt());
        m_MyComPort->setParity((ParityType)myComPortPara.m_UartParity.toInt());
        m_MyComPort->setFlowControl(FLOW_OFF);
        myComPortPara.isOpen = true;
        return true;
    }
    return false;
 
}
 
bool QComProtocol::isOpen()
{
    if((m_MyComPort != NULL) && (m_MyComPort->isOpen()))
    {
        return true;
    }
 
    return false;
}
 
qint16 QComProtocol::Get2Byte(quint8 u8LoByte, quint8 u8HiByte)
{
    qint16 nsValue = 0;
 
    nsValue |= (u8HiByte << 8);
    nsValue &= 0xFF00;
    nsValue |= u8LoByte;
 
    return nsValue;
}
 
//封装读参数接口;
int QComProtocol::ReadParam(quint8 u8DevAddr, quint16 u16DevPara, ANS_FRM_T &stAnsFrm)
{
 
    REQ_FRM_T stReqFrm;
    qint32 n32CheckSum = 0;
    quint8 u8Temp = 0;
    int nErrCnt = 0;
    int nError = ERR_ERROR;
    u8Temp = u16DevPara % 256;
 
    stReqFrm.u8DevAddr1 = 0x80 + u8DevAddr;
    stReqFrm.u8DevAddr2 = 0x80 + u8DevAddr;
    stReqFrm.u8ReqType = RDTYPE + (u16DevPara >> 8);
    stReqFrm.u8DevPara = u8Temp;
    stReqFrm.u8LoParam = 0;
    stReqFrm.u8HiParam = 0;
    n32CheckSum = u8DevAddr + (stReqFrm.u8DevPara << 8) + stReqFrm.u8ReqType;
    stReqFrm.u8LoSumCheck = n32CheckSum & 0xff;
    stReqFrm.u8HiSumCheck =( n32CheckSum >> 8) & 0xff;
 
    while(nErrCnt < 6)
    {
        //发送请求帧
        if(SendFrame((const char *)&stReqFrm, sizeof(REQ_FRM_T), 200))
        {
            //接收应答帧
            if(ReceiveFrame((char *)&stAnsFrm, sizeof(ANS_FRM_T), 200))
            {
                //对数据进行校验
                if(QComProtocol::GetSumCheck(stAnsFrm))
                {
                    if(u16DevPara == 0x16)
                    {
                        u8InputStandard = stAnsFrm.u8LoParam;
                    }
                    nErrCnt = 10;
                    nError = ERR_OK;
                }
            }
        }
        nErrCnt++;
    }
 
    return nError;
}
 
//封装写参数接口
int QComProtocol::WriteParam(quint8 u8DevAddr, quint16 u16DevPara, quint8 u8LoParam, quint8 u8HiParam, ANS_FRM_T &stAnsFrm)
{
    REQ_FRM_T stReqFrm;
    qint32 n32CheckSum = 0;
    quint8 u8Temp = 0;
    int nErrCnt = 0;
    int nError = ERR_ERROR;
    u8Temp = u16DevPara % 256;
 
    stReqFrm.u8DevAddr1 = 0x80 + u8DevAddr;
    stReqFrm.u8DevAddr2 = 0x80 + u8DevAddr;
    stReqFrm.u8ReqType = WRTYPE + (u16DevPara >> 8);
    stReqFrm.u8DevPara = u8Temp;
    stReqFrm.u8LoParam = u8LoParam;
    stReqFrm.u8HiParam = u8HiParam;
    n32CheckSum = u8DevAddr + (stReqFrm.u8DevPara << 8) + stReqFrm.u8ReqType;
    stReqFrm.u8LoSumCheck = n32CheckSum & 0xff;
    stReqFrm.u8HiSumCheck =( n32CheckSum >> 8) & 0xff;
 
    while(nErrCnt < 6)
    {
        //发送请求帧
        if(SendFrame((const char *)&stReqFrm, sizeof(REQ_FRM_T), 200))
        {
            //接收应答帧
            if(ReceiveFrame((char *)&stAnsFrm, sizeof(ANS_FRM_T), 200))
            {
                //对数据进行校验
                if(QComProtocol::GetSumCheck(stAnsFrm))
                {
                    if(u16DevPara == 0x16)
                    {
                        u8InputStandard = stAnsFrm.u8LoParam;
                    }
 
                    nErrCnt = 10;
                    nError = ERR_OK;
                }
            }
        }
        nErrCnt++;
    }
 
    return nError;
}
 
int QComProtocol::WriteParam(quint8 u8DevAddr, quint16 u16DevPara, quint8 u8LoParam, quint8 u8HiParam)
{
    int nError = ERR_OK;
 
    ANS_FRM_T stAnsFrm;
 
    nError = WriteParam(u8DevAddr, u16DevPara, u8LoParam, u8HiParam, stAnsFrm);
 
    return nError;
}
 
bool QComProtocol::GetSumCheck(ANS_FRM_T stAnsFrm)
{
    quint8  u8CrcVal = 0;
    quint8  u8CalCrcVal = 0;
    quint8  u8TempCheck;
    bool bResult = false;
 
    u8TempCheck = stAnsFrm.u8SumCheck % 16;
    u8CrcVal = ((stAnsFrm.u8HiPV + stAnsFrm.u8LoPV + stAnsFrm.u8HiSV + stAnsFrm.u8LoSV +
                 stAnsFrm.u8LoMV + stAnsFrm.u8HiMV + stAnsFrm.u8HiParam + stAnsFrm.u8LoParam +
                 stAnsFrm.u8ALm + u8TempCheck) % 256) / 16;
 
    u8CalCrcVal = stAnsFrm.u8SumCheck / 16;
 
    if(u8CrcVal == u8CalCrcVal)
    {
        bResult = true;
    }
 
    return bResult;
}
 
//读单个参数
bool QComProtocol::ReadParam(quint8 u8DevAddr, quint16 u16DevPara, float & fParaValue)
{
    ANS_FRM_T stAnsFrm;
    if(QComProtocol::ReadParam(u8DevAddr, u16DevPara, stAnsFrm) == ERR_OK)
    {
        int nTempVal = 0;
        nTempVal = QComProtocol::Get2Byte(stAnsFrm.u8LoParam, stAnsFrm.u8HiParam);
        fParaValue = (float)GetSinglePara(nTempVal, u16DevPara);
 
        if(u16DevPara == 0x16)
        {
            u8InputStandard = stAnsFrm.u8LoParam;
        }
        return true;
    }
 
    return false;
}
 
bool QComProtocol::WriteParam(quint8 u8DevAddr, quint16 u16DevPara, float fParaValue)
{
    ANS_FRM_T stAnsFrm;
    int nParaValue = 0;
 
    nParaValue = QComProtocol::GetInputValue(u16DevPara, fParaValue);
 
 
    if(QComProtocol::WriteParam(
                u8DevAddr, u16DevPara,
                (nParaValue & 0xFF), ((nParaValue >> 8) & 0xFF),
                stAnsFrm) == ERR_OK)
    {
        if(u16DevPara == 0x16)
        {
            u8InputStandard = stAnsFrm.u8LoParam;
        }
        return true;
    }
 
    return false;
}
 
int QComProtocol::GetInputValue(quint16 u16DevPara, float fParaValue)
{
    int nRetPara = 1;
    int nTempValue = 0;
 
    switch(u16DevPara)
    {
    case 0:
        nRetPara = fParaValue * 100;
        break;
 
    case 3:
    case 4:
    case 5:
    case 6:
    case 24:
    case 25:
    case 33:
    case 37:
    case 38:
    case 39:
        nTempValue = fParaValue * QComProtocol::GetFactor(u8ResBuff[u8InputStandard]);
        nRetPara = QComProtocol::FloatToInt(nTempValue);
        break;
 
    case 7:
    case 21:
    case 26:
        nRetPara = fParaValue * QComProtocol::GetFactor(u8ResBuff[u8InputStandard]);
        break;
 
    default:
        if(u16DevPara > 50)
        {
            if(u16DevPara % 2)
            {
                nTempValue = fParaValue * QComProtocol::GetFactor(u8ResBuff[u8InputStandard]);
                nRetPara = QComProtocol::FloatToInt(nTempValue);
            }
            else
            {
                nRetPara = fParaValue * QComProtocol::GetFactor(u8ResBuff[u8InputStandard]);
            }
 
        }
        else
        {
            nRetPara = (int)fParaValue;
        }
 
        break;
    }
 
    return nRetPara;
}
 
int QComProtocol::FloatToInt(qint32 nParaValue)
{
    int nRetVal = 0;
    int nTemp = 1;
 
    if(nParaValue < 0)
    {
        nTemp = -1;
        nParaValue = -nParaValue;
    }
 
    if(nParaValue < 10000)
    {
        nRetVal =  nParaValue;
    }
    else if(nParaValue < 100000)
    {
        nRetVal = (nParaValue / 10) + 9000;
    }
    else if(nParaValue < 1000000)
    {
        nRetVal = (nParaValue / 100) + 18000;
    }
    else
    {
        nRetVal = (nParaValue / 1000) + 27000;
    }
 
    return nRetVal * nTemp;
}
 
int QComProtocol::GetFactor(qint8 u8Dpts)
{
    int nRetFactor = 1;
 
    if(u8Dpts == 2) nRetFactor = 100;
    if(u8Dpts == 3) nRetFactor = 1000;
 
    return nRetFactor;
}
 
int QComProtocol::IntToFloat(qint32 n32Value, quint8 u8Value)
{
    int nRetVal = 0;
    int nTemp = 1;
 
    if(n32Value < 0)
    {
        nTemp = -1;
        n32Value = -n32Value;
    }
 
    if(n32Value < 10000)
    {
        nRetVal = n32Value;
    }
    else if(n32Value < 19000)
    {
        nRetVal = (n32Value - 9000) * 10 + u8Value;
    }
    else if(n32Value <28000)
    {
        nRetVal = ((n32Value - 18000) * 10 + u8Value) * 10;
    }
    else
    {
        nRetVal = ((n32Value - 27000) * 10 + u8Value) * 100 ;
    }
 
    return nRetVal * nTemp;
}
 
int QComProtocol::GetSinglePara(qint32 n32Value, quint16 u16DevPara)
{
    int nRetPara = 0;
    int nTempVal = 0;
    int nFactor = 0;
 
    nFactor = QComProtocol::GetFactor(u8ResBuff[u8InputStandard]);
 
    switch(u16DevPara)
    {
    case 0:
        nRetPara = n32Value / 100;
        break;
 
    case 3:
    case 4:
    case 5:
    case 6:
    case 24:
    case 25:
    case 33:
    case 37:
    case 38:
    case 39:
        nTempVal = QComProtocol::IntToFloat(n32Value, 0);
        nRetPara = nTempVal / nFactor;
        break;
 
    case 7:
    case 21:
    case 26:
        nRetPara = n32Value / nFactor;
        break;
 
    default:
        if(u16DevPara > 50)
        {
            if(u16DevPara % 2)
            {
                nTempVal = QComProtocol::IntToFloat(n32Value, 0);
                nRetPara = nTempVal / nFactor;
            }
            else
            {
                nRetPara = nTempVal / 10;
            }
        }
        else
        {
            nRetPara = n32Value;
        }
 
        break;
    }
 
    return nRetPara;
}
 
float QComProtocol::GetPvSv(qint32 n32Value)
{
    float fTemPvSv = 0.0;
    fTemPvSv =  (float)n32Value / QComProtocol::GetFactor(u8ResBuff[u8InputStandard]);
    return fTemPvSv;
 
}

#ifndef QCOMPROTOCOL_H
#define QCOMPROTOCOL_H
#include "win_qextserialport.h"
#include "qserialpara.h"
#include "AppFrame.h"
 
 
 
class QComProtocol
{
public:
    QComProtocol();
    ~QComProtocol();
 
    bool myComPortOpen(QSerialParameter &myComPortPara);
 
    bool isOpen();
 
    qint64 ReadData(char *pcReadBuff, qint64 nReadLenth);
    qint64 WriteData(const char *pcWriteBuff, qint64 nWriteLenth);
 
    bool SendFrame(const char *pcFrameBuff, qint64 nFrameSize, int nTimeOut);
    bool ReceiveFrame(char *pcFrameBuff, qint64 nFrameSize, int nTimeOut);
 
    static qint16 Get2Byte(quint8 u8LoByte, quint8 u8HiByte);
 
    //读参数命令接口
    int ReadParam(
            quint8 u8DevAddr,
            quint16 u16DevPara,
            ANS_FRM_T & stAnsFrm);
 
    //写参数命令接口
    int WriteParam(
            quint8 u8DevAddr,
            quint16 u16DevPara,
            quint8 u8LoParam,
            quint8 u8HiParam,
            ANS_FRM_T & stAnsFrm);
 
    int WriteParam(
            quint8 u8DevAddr,
            quint16 u16DevPara,
            quint8 u8LoParam,
            quint8 u8HiParam);
 
    static bool GetSumCheck(ANS_FRM_T stAnsFrm);
    static int GetInputValue(quint16  u16DevPara, float nParaValue);
    static int FloatToInt(qint32 nParaValue);
    static int GetFactor(qint8 u8Dpts);
    static int IntToFloat(qint32 n32Value, quint8 u8Value);
    static float GetPvSv(qint32 n32Value);
 
    int GetSinglePara(qint32 n32Value, quint16 u16DevPara);
 
    bool ReadParam(quint8 u8DevAddr, quint16 u16DevPara, float & fParaValue);
    bool WriteParam(quint8 u8DevAddr, quint16 u16DevPara, float fParaValue);
 
 
private:
 
    Win_QextSerialPort *m_MyComPort;
 
};
 
#endif // QCOMPROTOCOL_H

bool ReceiveFrame(Stream &p_Serial, char *pcFrameBuff, uint64_t nFrameSize, int nTimeOut)
{
 
  /* QTime Time;
     Time.start();
     qint64 nReadCurCount = 0;
 
     while((Time.elapsed()< nTimeOut) && (nReadCurCount < nFrameSize))
     {
         qint64 nReadBytes = ReadData(pcFrameBuff, nFrameSize);
         pcFrameBuff += nReadBytes;
         nReadCurCount += nReadBytes;
     }
 
     return(nReadCurCount == nFrameSize);
  */
  uint64_t nReadCurCount = 0;
  Serial.println("14");
  MsTimer2::set(1, to_Timer); // Здесь задаем период 1 м.секунда
  MsTimer2::start();//Стартуем, теперь таймер запущен
 
  while ((totalSek  < nTimeOut) && (nReadCurCount < nFrameSize))
  { Serial.println("15");
    uint64_t nReadBytes = ReadData(p_Serial, pcFrameBuff, nFrameSize);
    pcFrameBuff += nReadBytes;
    nReadCurCount += nReadBytes;
  }
  totalSek = 0;
  Serial.println("16");
  return (nReadCurCount == nFrameSize);
}

....
MsTimer2::set(1, to_Timer); // Здесь задаем период 1 м.секунда
totalSek = 0;
MsTimer2::start();//Стартуем, теперь таймер запущен
....
MsTimer2::stop();
Serial.println("16");
return (nReadCurCount == nFrameSize);

bool ReceiveFrame(Stream &p_Serial, byte *pcFrameBuff, uint64_t nFrameSize, int nTimeOut)
{
 
  /* QTime Time;
     Time.start();
     qint64 nReadCurCount = 0;
 
     while((Time.elapsed()< nTimeOut) && (nReadCurCount < nFrameSize))
     {
         qint64 nReadBytes = ReadData(pcFrameBuff, nFrameSize);
         pcFrameBuff += nReadBytes;
         nReadCurCount += nReadBytes;
     }
 
     return(nReadCurCount == nFrameSize);
  */
 
  uint64_t nReadCurCount = 0;
  Serial.println("14");
  MsTimer2::set(1, to_Timer); // Здесь задаем период 1 м.секунда
  //totalSek = 0;
  MsTimer2::start();//Стартуем, теперь таймер запущен
 
  while ((totalSek  < nTimeOut) && (nReadCurCount < nFrameSize))
  {
    Serial.println(totalSek);
    uint64_t nReadBytes = ReadData(p_Serial, pcFrameBuff, nFrameSize);
    pcFrameBuff += nReadBytes;
    nReadCurCount += nReadBytes;
  }
  MsTimer2::stop();
  totalSek = 0;
  Serial.println("16");
  return (nReadCurCount == nFrameSize);
}

volatile uint16_t totalSec = 0;

bool GetSumCheck(struct tagANS_FRM_T stAnsFrm)
{
  uint8_t  u8CrcVal = 0;
  uint8_t u8CalCrcVal = 0;
  uint8_t u8TempCheck;
  bool bResult = false;
  Serial.println("20");
  u8TempCheck = stAnsFrm.u8SumCheck % 16;
  u8CrcVal = ((stAnsFrm.u8HiPV + stAnsFrm.u8LoPV + stAnsFrm.u8HiSV + stAnsFrm.u8LoSV +
               stAnsFrm.u8LoMV + stAnsFrm.u8HiMV + stAnsFrm.u8HiParam + stAnsFrm.u8LoParam +
               stAnsFrm.u8ALm + u8TempCheck) % 256) / 16;
               
 
  u8CalCrcVal = stAnsFrm.u8SumCheck / 16;
 
  if (u8CrcVal == u8CalCrcVal)
  {
    Serial.println("21");
    bResult = true;
  }
  Serial.println("22");
  return bResult;
}

struct tagANS_FRM_T
{
  uint8_t  u8LoPV;
  uint8_t  u8HiPV;
  uint8_t  u8LoSV;
  uint8_t  u8HiSV;
  uint8_t  u8MV;
  uint8_t  u8ALm;
  uint8_t  u8LoParam;
  uint8_t  u8HiParam;
  uint8_t  u8LoSumCheck;
  uint8_t  u8HiSumCheck;
};

#include <SoftwareSerial.h>
#include <OneWire.h>
 
 
#define DIR 4 // переключатель прием\передача
#define ON 1 // вкл. клапан
#define OFF 0 // вкл. клапан
#define PUMP 5 // вкл. клапан
 
 
OneWire ds(10);
 
struct packet_arduino_pomp //пакет Arduino nano
{
  byte start_byte_one;//в коротком пакете равен 212
  byte start_byte_two;//в коротком пакете равен 211
  byte temp_pomp;//температура охлаждения
  byte on_of_pomp;//on-off насоса (1 или 0)
  byte tmp;//пока не трогаем
  byte CRC8;//контрольная сумма
  /*упаковать*/
  void pask()
  {
    CRC8 = (start_byte_one + start_byte_two + temp_pomp + on_of_pomp + tmp) / 10;
  }
  /*проверка упаковки*/
  bool test_pask()
  {
    if (CRC8 == (start_byte_one + start_byte_two + temp_pomp + on_of_pomp + tmp) / 10) return 0; //ОК
    return -1; // ошибка
  }
};
 
 
static packet_arduino_pomp one = {212, 211, 0, 0, 0, 0}; //пакет с данными
byte temp_pomp = 0;//переменная для хранения температуры
 
SoftwareSerial RS485 (2, 3); // RX, TX
 
void setup()
{
  Serial.begin(9600);
  RS485.begin(9600); // SoftwareSerial
 
  pinMode(DIR, OUTPUT);
  pinMode(PUMP, OUTPUT);
}
 
void loop()
{
 
  byte* ptr28 = (byte* )&one;
  digitalWrite(DIR, LOW); // включаем прием
  byte data[2];
  ds.reset();
  ds.write(0xCC);
  ds.write(0x44);
 
  delay(150);
 
  if (RS485.available() >= sizeof(packet_arduino_pomp))
  {
 
    Serial.println("1");
    byte buf_pump = 0;
    for (size_t i = 0; i < sizeof(packet_arduino_pomp); i++)
    {
      Serial.println("2");
      if (i == 0 && (buf_pump = RS485.read()) != 212)
      {
        Serial.println("3");
        i = 0;
        continue;
      }
      if (i == 1 && (buf_pump = RS485.read()) != 211)
      {
        Serial.println("4");
        i = 0;
        continue;
      }
      if (i >= 2)
      {
        Serial.println("5");
        ptr28[i] = RS485.read();
        if (i == sizeof(packet_arduino_pomp) - 1)
        {
          Serial.println("6");
          if (one.test_pask()) //проверяем контрольную сумму
          {
            i = 0;
            continue;
          }
        }
 
      }
    }
    Serial.println("ON");
    for (size_t i = 0; i < sizeof(packet_arduino_pomp); i++)
    {
      Serial.println(ptr28[i]);
    }
    Serial.println("END");
    if (one.on_of_pomp == ON) // включим клапан
    {
      digitalWrite(PUMP, HIGH); //  включим клапан
    }
    else if (one.on_of_pomp == OFF)
      digitalWrite(PUMP, LOW);
  }
  //  delay(50);
  ds.reset();
  ds.write(0xCC);
  ds.write(0xBE);
  data[0] = ds.read();
  data[1] = ds.read();
  int Temp = (data[1] << 8) + data[0];
  Temp = Temp >> 4;
  one.temp_pomp = Temp;//записываем значение температуры охлаждения в пакет на отправку
  one.pask();//формируем контрольную сумму
  digitalWrite(DIR, HIGH); // включаем передачу
  //delay(100);
  RS485.write(ptr28, sizeof(packet_arduino_pomp));
}

#include <SoftwareSerial.h>
 
#define DIR 8 // переключатель прием\передача
#define BUT 49
 
bool read_package_nano(Stream &, byte*);
bool read_package_pc(Stream &, byte*);
 
struct packet_big //пакет PC
{
    byte start_byte_one;//в длинном пакете равен 254
    byte start_byte_two;//в длинном пакете равен 232
    byte temp_pomp;//температура охлаждения
    byte on_of_pomp;//on-off насоса (1 или 0)
    byte ex_temp_reactor;//текущая температура в реакторе
    byte current_temp_reactor;//выставленная температура в реакторе
    byte timer_ex;//таймер
    byte tmp;//пока не трогаем
    byte CRC8;//пока не трогаем
    void pask()
    {
        CRC8 = (start_byte_one + start_byte_two + temp_pomp + on_of_pomp + ex_temp_reactor + current_temp_reactor + timer_ex + tmp) / 10;
    }
    /*проверка упаковки*/
    bool test_pask()
    {
        if (CRC8 == ((start_byte_one + start_byte_two + temp_pomp + on_of_pomp + ex_temp_reactor + current_temp_reactor + timer_ex + tmp)) / 10) return 0; //ОК
        return -1; // ошибка
    }
};
 
struct packet_arduino_pomp //пакет Arduino nano
{
 
    byte start_byte_one;//в коротком пакете равен 212
    byte start_byte_two;//в коротком пакете равен 211
    byte temp_pomp;//температура охлаждения
    byte on_of_pomp;//on-off насоса (1 или 0)
    byte tmp;//пока не трогаем
    byte CRC8;//пока не трогаем
    /*упаковать*/
    void pask()
    {
        CRC8 = (start_byte_one + start_byte_two + temp_pomp + on_of_pomp + tmp) / 10;
    }
    /*проверка упаковки*/
    bool test_pask()
    {
        if (CRC8 == (start_byte_one + start_byte_two + temp_pomp + on_of_pomp + tmp) / 10) return 0; //ОК
        return -1; // ошибка
    }
};
 
packet_big one = {254, 232, 0, 0, 0, 0, 0, 0, 0};
packet_arduino_pomp one_pomp = {212, 211, 0, 0, 0, 0};
 
 
byte buttonState = 0;
 
void setup()
{
    Serial.begin(9600);//на PC
    Serial2.begin(9600); // SoftwareSerial на Arduino nano
    pinMode(BUT, INPUT);
    pinMode(DIR, OUTPUT);
}
 
void loop()
{
    digitalWrite(DIR, HIGH); // включаем передачу
    buttonState = digitalRead(BUT); //кнопка
    byte* ptr28 = (byte* )&one;
    byte *ptr_pomp = (byte*)&one_pomp;
    read_package_pc(Serial, ptr28);
    if (buttonState == HIGH) //вкл/выкл от кнопки
    {
        if (one.on_of_pomp == 0) //если выключен , то перезаписываем в пакете (включаем)
            one.on_of_pomp = 1;
        else if (one.on_of_pomp == 1) //если включен, то перезаписываем в пакете (выключаем)
            one.on_of_pomp = 0;
    }
 
    one_pomp.on_of_pomp = one.on_of_pomp;
    one.temp_pomp=one_pomp.temp_pomp;
    one.pask();
    Serial.write(ptr28,sizeof(packet_big)); //передаем на PC
    one_pomp.pask();
    Serial2.write(ptr_pomp, sizeof(packet_arduino_pomp)); //передаем на Arduino nano
    delay(50);
 
    digitalWrite(DIR, LOW); // включаем прием
    //прием с PC данных всех команд, включая информацию о температуре с реактора
 
    //возможно нужно повторно записать стартовый бит.
    //прием с ардуино nano данных о вкл/ вкл насоса и температуры охлаждения
    delay(50);
 
    if (read_package_nano(Serial2, ptr_pomp))
    {
       /*Serial.println("ON");
        for (size_t i = 0; i < sizeof(packet_arduino_pomp); i++)
        {
            Serial.println( ptr_pomp[i]);
        }
        Serial.println("END");*/
    }
}
 
 
 
 
bool read_package_nano(Stream &p_Serial, byte* fptr)
{
    if (p_Serial.available() >= sizeof(packet_arduino_pomp))
    {
 
        byte buf_pump = 0;
        for (size_t i = 0; i < sizeof(packet_arduino_pomp); i++)
        {
            if (i == 0 && (buf_pump = p_Serial.read()) != 212)
            {
                i = 0;
                continue;
            }
            if (i == 1 && (buf_pump = p_Serial.read()) != 211)
            {
                i = 0;
                continue;
            }
            if (i >= 2)
            {
                buf_pump = p_Serial.read();
                fptr[i] = buf_pump;
                if (i == sizeof(packet_arduino_pomp) - 1)
                {
                    if (one_pomp.test_pask()) //проверяем контрольную сумму
                    {
                        i = 0;
                        return 0;
                    }
                    return 1;
                }
 
            }
        }
    }
}
 
 
 
bool read_package_pc(Stream &p_Serial, byte* fptr)
{
    if (p_Serial.available() >= sizeof(packet_big))
    {
 
        byte buf_pump = 0;
        for (size_t i = 0; i < sizeof(packet_big); i++)
        {
            if (i == 0 && (buf_pump = p_Serial.read()) != 254)
            {
                i = 0;
                continue;
            }
            if (i == 1 && (buf_pump = p_Serial.read()) != 232)
            {
                i = 0;
                continue;
            }
            if (i >= 2)
            {
                buf_pump = p_Serial.read();
                fptr[i] = buf_pump;
                if (i == sizeof(packet_big) - 1)
                {
                    if (one.test_pask()) //проверяем контрольную сумму
                    {
                        i = 0;
                        return 0;
                    }
                    return 1;
                }
 
            }
        }
    }
}

#include <SoftwareSerial.h>
#include <FlexiTimer2.h>
 
#define DIR2 8 // переключатель прием\передача
#define DIR3 9 // переключатель прием\передача
#define BUT 49
#define RDTYPE                                  (82)
#define WRTYPE                                  (67)
#define ERR_OK          (0)
#define ERR_ERROR       (1)
#define ERR_TIMEOUT       (2)
#define ERR_INVALIED_PARAM                      (3)
 
volatile int totalSec = 0;
uint16_t Val = 0; //значение для записи
void to_Timer() {
  totalSec ++;//каждую мл.сек увеличиваем totalSek
}
static uint8_t u8ResBuff[] = {3, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 3, 2, 3, 2, 2, 2};
static uint8_t u8InputStandard = 0;
 
bool read_package_nano(Stream &, byte*);
bool read_package_pc(Stream &, byte*);
int sensorValue = 0;
 
struct tag_METERDATA_T
{
  float fAijPV;
  float fAijSV;
  float fAijMv;
  float fAijParam;
  uint8_t u8Alm;
};
 
 
struct tagREQ_FRM_T
{
  uint8_t  u8DevAddr1;
  uint8_t  u8DevAddr2;
  uint8_t  u8ReqType;
  uint8_t  u8DevPara;
  uint8_t  u8LoParam;
  uint8_t u8HiParam;
  uint8_t  u8LoSumCheck;
  uint8_t  u8HiSumCheck;
} ;
struct tagANS_FRM_T
{
  uint8_t  u8LoPV;
  uint8_t  u8HiPV;
  uint8_t  u8LoSV;
  uint8_t  u8HiSV;
  uint8_t  u8MV;
  uint8_t  u8ALm;
  uint8_t  u8LoParam;
  uint8_t  u8HiParam;
  uint8_t  u8LoSumCheck;
  uint8_t  u8HiSumCheck;
};
 
struct packet_big //пакет PC
{
  byte start_byte_one;//в длинном пакете равен 254
  byte start_byte_two;//в длинном пакете равен 232
  byte temp_pomp;//температура охлаждения
  byte on_of_pomp;//on-off насоса (1 или 0)
  byte ex_temp_reactor;//текущая температура в реакторе
  byte current_temp_reactor;//выставленная температура в реакторе
  byte timer_ex;//таймер
  byte tmp;//пока не трогаем
  byte CRC8;//пока не трогаем
  void pask()
  {
    CRC8 = (start_byte_one + start_byte_two + temp_pomp + on_of_pomp + ex_temp_reactor + current_temp_reactor + timer_ex + tmp) / 10;
  }
  /*проверка упаковки*/
  bool test_pask()
  {
    if (CRC8 == ((start_byte_one + start_byte_two + temp_pomp + on_of_pomp + ex_temp_reactor + current_temp_reactor + timer_ex + tmp)) / 10) return 0; //ОК
    return -1; // ошибка
  }
};
 
struct packet_arduino_pomp //пакет Arduino nano
{
 
  byte start_byte_one;//в коротком пакете равен 212
  byte start_byte_two;//в коротком пакете равен 211
  byte temp_pomp;//температура охлаждения
  byte on_of_pomp;//on-off насоса (1 или 0)
  byte tmp;//пока не трогаем
  byte CRC8;//пока не трогаем
  /*упаковать*/
  void pask()
  {
    CRC8 = (start_byte_one + start_byte_two + temp_pomp + on_of_pomp + tmp) / 10;
  }
  /*проверка упаковки*/
  bool test_pask()
  {
    if (CRC8 == (start_byte_one + start_byte_two + temp_pomp + on_of_pomp + tmp) / 10) return 0; //ОК
    return -1; // ошибка
  }
};
 
packet_big one = {254, 232, 0, 0, 0, 0, 0, 0, 0};
packet_arduino_pomp one_pomp = {212, 211, 0, 0, 0, 0};
 
 
byte buttonState = 0;
 
void setup()
{
  Serial.begin(9600);//на PC
  Serial2.begin(9600); // SoftwareSerial на Arduino nano
  Serial3.begin(9600, SERIAL_8N2);
  pinMode(BUT, INPUT);
  pinMode(DIR2, OUTPUT);
  pinMode(DIR3, OUTPUT);
  pinMode (A1, INPUT);
}
 
void loop()
{
  tagANS_FRM_T stAnsFrm = {0};
  uint16_t u16ParamAddr = 0;
  int nTempVal = 0;
  int nTempPv = 0;
  int nTempSv = 0;
  uint8_t u8Alm = 0;
  int Val = 0;//значение для записи
  uint8_t loVal = 0; //младший байт для записи
  uint8_t hiVal = 0; //старший байт для записи
 
  sensorValue = analogRead (1);
  
  
  buttonState = digitalRead(BUT); //кнопка
  
  byte* ptr28 = (byte* )&one;//приводим структуру у массиву байт
  byte *ptr_pomp = (byte*)&one_pomp;
 
 
  if (ReadParam(Serial3, 1, u16ParamAddr, stAnsFrm) == ERR_OK)
  {
    nTempVal = Get2Byte(stAnsFrm.u8LoPV, stAnsFrm.u8HiPV);
    nTempPv = IntToFloat(nTempVal, 0);
    u8Alm = Get2Byte(stAnsFrm.u8LoSumCheck, stAnsFrm.u8LoSumCheck) % 16; // stAnsFrm.u8SumCheck % 16;
    nTempVal = Get2Byte(stAnsFrm.u8LoSV, stAnsFrm.u8HiSV);
    nTempSv = IntToFloat(nTempVal, u8Alm);
  }
  delay (10);
 
  read_package_pc(Serial, ptr28);//читаем с COM порта
 
  if ((int)nTempSv / 10 != (int)one.current_temp_reactor) {
    Val = one.current_temp_reactor;
    Val = Val * 10;
    loVal = Val & 0xff;
    hiVal = ( Val >> 8) & 0xff;
 
    WriteParam(Serial3, 1, 0, loVal, hiVal, stAnsFrm);
  }
 
  if (sensorValue >= 739 && sensorValue < 800) //вкл/выкл от кнопки
  {
    if (one.on_of_pomp == 0) //если выключен , то перезаписываем в пакете (включаем)
      one.on_of_pomp = 1;
    else if (one.on_of_pomp == 1) //если включен, то перезаписываем в пакете (выключаем)
      one.on_of_pomp = 0;
  }
 
  one.temp_pomp = one_pomp.temp_pomp;
  one.ex_temp_reactor = (int)nTempPv / 10;
 
  one.pask();
  Serial.write(ptr28, sizeof(packet_big)); //передаем на PC
  one_pomp.pask();
  digitalWrite(DIR2, HIGH); // включаем передачу
  Serial2.write(ptr_pomp, sizeof(packet_arduino_pomp)); //передаем на Arduino nano
  delay(50);
    
  digitalWrite(DIR2, LOW); // включаем прием
  //прием с PC данных всех команд, включая информацию о температуре с реактора
 
  //возможно нужно повторно записать стартовый бит.
  //прием с ардуино nano данных о вкл/ вкл насоса и температуры охлаждения
  read_package_nano(Serial2, ptr_pomp);
}
 
 
 
 
bool read_package_nano(Stream &p_Serial, byte* fptr)
{
  if (p_Serial.available() >= sizeof(packet_arduino_pomp))
  {
 
    byte buf_pump = 0;
    for (size_t i = 0; i < sizeof(packet_arduino_pomp); i++)
    {
      if (i == 0 && (buf_pump = p_Serial.read()) != 212)
      {
        i = 0;
        continue;
      }
      if (i == 1 && (buf_pump = p_Serial.read()) != 211)
      {
        i = 0;
        continue;
      }
      if (i >= 2)
      {
        buf_pump = p_Serial.read();
        fptr[i] = buf_pump;
        if (i == sizeof(packet_arduino_pomp) - 1)
        {
          if (one_pomp.test_pask()) //проверяем контрольную сумму
          {
            i = 0;
            return 0;
          }
          return 1;
        }
 
      }
    }
  }
}
 
 
 
bool read_package_pc(Stream &p_Serial, byte* fptr)
{
  if (p_Serial.available() >= sizeof(packet_big))
  {
 
    byte buf_pump = 0;
    for (size_t i = 0; i < sizeof(packet_big); i++)
    {
      if (i == 0 && (buf_pump = p_Serial.read()) != 254)
      {
        i = 0;
        continue;
      }
      if (i == 1 && (buf_pump = p_Serial.read()) != 232)
      {
        i = 0;
        continue;
      }
      if (i >= 2)
      {
        buf_pump = p_Serial.read();
        fptr[i] = buf_pump;
        if (i == sizeof(packet_big) - 1)
        {
          if (one.test_pask()) //проверяем контрольную сумму
          {
            i = 0;
            return 0;
          }
          return 1;
        }
 
      }
    }
  }
}
 
 
 
//Коннект к контроллеру
 
 
int WriteParam(Stream &p_Serial, uint8_t u8DevAddr, uint16_t u16DevPara, uint8_t u8LoParam, uint8_t u8HiParam, struct tagANS_FRM_T &stAnsFrm)
{
  struct tagREQ_FRM_T stReqFrm;
  uint32_t n32CheckSum = 0;
  uint8_t u8Temp = 0;
  int nErrCnt = 0;
  int nError = ERR_ERROR;
  u8Temp = u16DevPara % 256;
 
  stReqFrm.u8DevAddr1 = 0x80 + u8DevAddr;
  stReqFrm.u8DevAddr2 = 0x80 + u8DevAddr;
  stReqFrm.u8ReqType = WRTYPE;
  stReqFrm.u8DevPara = u8Temp;
  stReqFrm.u8LoParam = u8LoParam;
  stReqFrm.u8HiParam = u8HiParam;
  n32CheckSum = u8DevAddr + (stReqFrm.u8DevPara << 8) + stReqFrm.u8ReqType + Get2Byte(stReqFrm.u8LoParam , stReqFrm.u8HiParam);
  //Parameter code to be written  ?256 + 67+ parameter to be written + ADDR
  stReqFrm.u8LoSumCheck = n32CheckSum & 0xff;
  stReqFrm.u8HiSumCheck = ( n32CheckSum >> 8) & 0xff;
 
  while (nErrCnt < 6)
  {
    if (SendFrame(p_Serial, (const byte *)&stReqFrm, sizeof(struct tagREQ_FRM_T), 200))
    {
      if (ReceiveFrame(p_Serial, (byte *)&stAnsFrm, sizeof(struct tagANS_FRM_T), 200))
      {
        if (GetSumCheck(stAnsFrm))
        {
          if (u16DevPara == 0x16)
          {
            u8InputStandard = stAnsFrm.u8LoParam;
          }
 
          nErrCnt = 10;
          nError = ERR_OK;
        }
      }
    }
    nErrCnt++;
  }
 
  return nError;
}
 
int ReadParam(Stream &p_Serial, uint8_t u8DevAddr, uint16_t u16DevPara, struct tagANS_FRM_T &stAnsFrm)
{
  struct tagREQ_FRM_T stReqFrm;
  uint32_t n32CheckSum = 0;
  uint8_t u8Temp = 0;
  int nErrCnt = 0;
  int nError = ERR_ERROR;
  u8Temp = u16DevPara % 256;//подозрения
 
  stReqFrm.u8DevAddr1 = 0x80 + u8DevAddr;
  stReqFrm.u8DevAddr2 = 0x80 + u8DevAddr;
  stReqFrm.u8ReqType = RDTYPE;
  stReqFrm.u8DevPara = 0;
  stReqFrm.u8LoParam = 0;
  stReqFrm.u8HiParam = 0;
  n32CheckSum = u8DevAddr + (stReqFrm.u8DevPara << 8) + stReqFrm.u8ReqType;
  stReqFrm.u8LoSumCheck = n32CheckSum & 0xff;
  stReqFrm.u8HiSumCheck = ( n32CheckSum >> 8) & 0xff;
 
  while (nErrCnt < 6)
  {
    if (SendFrame(p_Serial, (const byte *)&stReqFrm, sizeof(tagREQ_FRM_T), 200))
    {
      if (ReceiveFrame(p_Serial, (byte *)&stAnsFrm, sizeof(tagANS_FRM_T), 200))
      {
        if (GetSumCheck(stAnsFrm))
        {
          if (u16DevPara == 0x16)
          {
            u8InputStandard = stAnsFrm.u8LoParam;//????что это
          }
          nErrCnt = 10;
          nError = ERR_OK;
        }
      }
    }
    nErrCnt++;
  }
 
  return nError;
}
 
 
bool ReadParam(Stream &p_Serial, uint8_t u8DevAddr, uint16_t u16DevPara, float & fParaValue)//как я понимаю основная функция которой пользуемся
{
  struct tagANS_FRM_T stAnsFrm;
  if (ReadParam(p_Serial, u8DevAddr, u16DevPara, stAnsFrm) == ERR_OK)
  {
    int nTempVal = 0;
    nTempVal = Get2Byte(stAnsFrm.u8LoParam, stAnsFrm.u8HiParam);
    fParaValue = (float)GetSinglePara(nTempVal, u16DevPara);
 
    if (u16DevPara == 0x16)
    {
      u8InputStandard = stAnsFrm.u8LoParam;
    }
    return true;
  }
 
  return false;
}
 
uint16_t Get2Byte(uint8_t u8LoByte, uint8_t u8HiByte)
{
  uint16_t nsValue = 0;
 
  nsValue |= (u8HiByte << 8);
  nsValue &= 0xFF00;
  nsValue |= u8LoByte;
 
  return nsValue;
}
 
int GetSinglePara(uint32_t n32Value, uint16_t u16DevPara)
{
  int nRetPara = 0;
  int nTempVal = 0;
  int nFactor = 0;
 
  nFactor = GetFactor(u8ResBuff[u8InputStandard]);//вот тут
 
  switch (u16DevPara)
  {
    case 0:
      nRetPara = n32Value / 100;
      break;
 
    case 3:
    case 4:
    case 5:
    case 6:
    case 24:
    case 25:
    case 33:
    case 37:
    case 38:
    case 39:
      nTempVal = IntToFloat(n32Value, 0);
      nRetPara = nTempVal / nFactor;
      break;
 
    case 7:
    case 21:
    case 26:
      nRetPara = n32Value / nFactor;
      break;
 
    default:
      if (u16DevPara > 50)
      {
        if (u16DevPara % 2)
        {
          nTempVal = IntToFloat(n32Value, 0);
          nRetPara = nTempVal / nFactor;
        }
        else
        {
          nRetPara = nTempVal / 10;
        }
      }
      else
      {
        nRetPara = n32Value;
      }
 
      break;
  }
 
  return nRetPara;
}
 
int IntToFloat(uint32_t n32Value, uint8_t u8Value)
{
  int nRetVal = 0;
  int nTemp = 1;
 
  if (n32Value < 0)
  {
    nTemp = -1;
    n32Value = -n32Value;
  }
 
  if (n32Value < 10000)
  {
    nRetVal = n32Value;
  }
  else if (n32Value < 19000)
  {
    nRetVal = (n32Value - 9000) * 10 + u8Value;
  }
  else if (n32Value < 28000)
  {
    nRetVal = ((n32Value - 18000) * 10 + u8Value) * 10;
  }
  else
  {
    nRetVal = ((n32Value - 27000) * 10 + u8Value) * 100 ;
  }
 
  return nRetVal * nTemp;
}
 
 
bool GetSumCheck(struct tagANS_FRM_T stAnsFrm)
{
  uint8_t  u8CrcVal = 0;
  uint8_t u8CalCrcVal = 0;
  uint8_t u8TempCheck;
  bool bResult = false;
  u8TempCheck = Get2Byte(stAnsFrm.u8LoSumCheck, stAnsFrm.u8LoSumCheck); //stAnsFrm.u8SumCheck % 16;
  u8CrcVal =         Get2Byte(stAnsFrm.u8LoPV, stAnsFrm.u8HiPV) + Get2Byte(stAnsFrm.u8LoSV, stAnsFrm.u8HiSV) +
                     (stAnsFrm.u8ALm * 256 + stAnsFrm.u8MV) + Get2Byte(stAnsFrm.u8LoParam, stAnsFrm.u8HiParam) + 1;
  u8CalCrcVal = Get2Byte(stAnsFrm.u8LoSumCheck, stAnsFrm.u8LoSumCheck); // stAnsFrm.u8SumCheck / 16;
 
  if (u8CrcVal == u8CalCrcVal)
  {
    bResult = true;
  }
  return bResult;
}
 
 
bool SendFrame(Stream &p_Serial, const byte *pcFrameBuff, uint64_t nFrameSize, int nTimeOut)
{
  FlexiTimer2::set(1, 1000, to_Timer); // Здесь задаем период 1 м.секунда
  totalSec = 0;
  FlexiTimer2::start();//Стартуем, теперь таймер запущен
  while ((totalSec < nTimeOut) && (nFrameSize > 0))
  {
    uint64_t nWriteBytes = WriteData(p_Serial, pcFrameBuff, nFrameSize);
    pcFrameBuff += nWriteBytes;
    nFrameSize -= nWriteBytes;
  }
  totalSec = 0;
  FlexiTimer2::stop();
  return (nFrameSize == 0);
}
 
 
bool ReceiveFrame(Stream &p_Serial, byte *pcFrameBuff, uint64_t nFrameSize, int nTimeOut)
{
  uint64_t nReadCurCount = 0;
  FlexiTimer2::set(1, 1000, to_Timer); // Здесь задаем период 1 м.секунда
  totalSec = 0;
  FlexiTimer2::start();//Стартуем, теперь таймер запущен
 
  while ((totalSec  < nTimeOut) && (nReadCurCount < nFrameSize))
  {
    uint64_t nReadBytes = ReadData(p_Serial, pcFrameBuff, nFrameSize);
    pcFrameBuff += nReadBytes;
    nReadCurCount += nReadBytes;
  }
  totalSec = 0;
  FlexiTimer2::stop();
  return (nReadCurCount == nFrameSize);
}
 
uint64_t WriteData(Stream &p_Serial, const byte *pcWriteBuff, uint64_t nWriteLenth)//нужно переписать
{
  digitalWrite(DIR3, HIGH); // включаем передачу
  uint64_t nTempWriteLenth = nWriteLenth;
  delay(20);
  p_Serial.write(pcWriteBuff, nWriteLenth);
  // }
 
  delay(50);
 
  return nTempWriteLenth;
}
 
 
uint64_t ReadData(Stream &p_Serial, byte *pcReadBuff, uint64_t nReadLenth)//вот эту нужно переписать
{
  digitalWrite(DIR3, LOW);//включить прием
  uint64_t nTempReadLenth = 0;
  delay(50);
  if (p_Serial.available() > 0) {
    for (nTempReadLenth = 0; nTempReadLenth < nReadLenth; nTempReadLenth++) {
      pcReadBuff[nTempReadLenth] = p_Serial.read();
    }
  }
  delay(30);
  return nTempReadLenth;
}
 
int WriteParam(Stream &p_Serial, uint8_t u8DevAddr, uint16_t u16DevPara, uint8_t u8LoParam, uint8_t u8HiParam)
{
  int nError = ERR_OK;
 
  struct tagANS_FRM_T stAnsFrm;
 
  nError = WriteParam(p_Serial, u8DevAddr, u16DevPara, u8LoParam, u8HiParam, stAnsFrm);
 
  return nError;
}
 
bool WriteParam(Stream &p_Serial, uint8_t u8DevAddr, uint16_t u16DevPara, float fParaValue)//как я понимаю основная функция которой пользуемся
{
  struct tagANS_FRM_T stAnsFrm;
  int nParaValue = 0;
 
  nParaValue = GetInputValue(u16DevPara, fParaValue);
 
 
  if (WriteParam(p_Serial,
                 u8DevAddr, u16DevPara,
                 (nParaValue & 0xFF), ((nParaValue >> 8) & 0xFF),
                 stAnsFrm) == ERR_OK)
  {
    if (u16DevPara == 0x16)
    {
      u8InputStandard = stAnsFrm.u8LoParam;
    }
    return true;
  }
 
  return false;
}
 
int GetInputValue(uint16_t u16DevPara, float fParaValue)
{
  int nRetPara = 1;
  int nTempValue = 0;
 
  switch (u16DevPara)
  {
    case 0:
      nRetPara = fParaValue * 100;
      break;
 
    case 3:
    case 4:
    case 5:
    case 6:
    case 24:
    case 25:
    case 33:
    case 37:
    case 38:
    case 39:
      nTempValue = fParaValue * GetFactor(u8ResBuff[u8InputStandard]);
      nRetPara = FloatToInt(nTempValue);
      break;
 
    case 7:
    case 21:
    case 26:
      nRetPara = fParaValue * GetFactor(u8ResBuff[u8InputStandard]);
      break;
 
    default:
      if (u16DevPara > 50)
      {
        if (u16DevPara % 2)
        {
          nTempValue = fParaValue * GetFactor(u8ResBuff[u8InputStandard]);
          nRetPara = FloatToInt(nTempValue);
        }
        else
        {
          nRetPara = fParaValue * GetFactor(u8ResBuff[u8InputStandard]);
        }
 
      }
      else
      {
        nRetPara = (int)fParaValue;
      }
 
      break;
  }
 
  return nRetPara;
}
 
int GetFactor(uint8_t u8Dpts)
{
  int nRetFactor = 1;
 
  if (u8Dpts == 2) nRetFactor = 100;
  if (u8Dpts == 3) nRetFactor = 1000;
 
  return nRetFactor;
}
 
 
int FloatToInt(uint32_t nParaValue)
{
  int nRetVal = 0;
  int nTemp = 1;
 
  if (nParaValue < 0)
  {
    nTemp = -1;
    nParaValue = -nParaValue;
  }
 
  if (nParaValue < 10000)
  {
    nRetVal =  nParaValue;
  }
  else if (nParaValue < 100000)
  {
    nRetVal = (nParaValue / 10) + 9000;
  }
  else if (nParaValue < 1000000)
  {
    nRetVal = (nParaValue / 100) + 18000;
  }
  else
  {
    nRetVal = (nParaValue / 1000) + 27000;
  }
 
  return nRetVal * nTemp;
}
 
float GetPvSv(uint32_t n32Value)
{
  float fTemPvSv = 0.0;
  fTemPvSv =  (float)n32Value / GetFactor(u8ResBuff[u8InputStandard]);
  return fTemPvSv;
 
}

buttonState = digitalRead(BUT); //кнопка

u8Temp = u16DevPara;

struct tagANS_FRM_T
{
  uint8_t  u8LoPV;
  uint8_t  u8HiPV;
  uint8_t  u8LoSV;
  uint8_t  u8HiSV;
  uint8_t  u8MV;
  uint8_t  u8ALm;
  uint8_t  u8LoParam;
  uint8_t  u8HiParam;
  uint8_t  u8LoSumCheck;
  uint8_t  u8HiSumCheck;
};

  /*проверка упаковки*/
  bool test_pask()
  {
    if (CRC8 == ((start_byte_one + start_byte_two + temp_pomp + on_of_pomp + ex_temp_reactor + current_temp_reactor + timer_ex + tmp)) / 10) return 0; //ОК
    return -1; // ошибка
  }

if (one_pomp.test_pask()) //проверяем контрольную сумму
          {
            return 0;
          }
          return 1;

  byte start_byte_one;//в длинном пакете равен 254
  byte start_byte_two;//в длинном пакете равен 232
  byte temp_pomp;//температура охлаждения
  byte on_of_pomp;//on-off насоса (1 или 0)
  byte ex_temp_reactor1;//текущая температура в реакторе
  byte ex_temp_reactor2;//текущая температура в реакторе
  byte ex_temp_reactor3;//текущая температура в реакторе
  byte ex_temp_reactor4;//текущая температура в реакторе
  byte ex_temp_reactor5;//текущая температура в реакторе
  byte ex_temp_reactor6;//текущая температура в реакторе
  byte ex_temp_reactor7;//текущая температура в реакторе
  byte ex_temp_reactor8;//текущая температура в реакторе
  byte current_temp_reactor;//выставленная температура в реакторе
  byte timer_ex;//таймер
  byte tmp;//пока не трогаем
  byte CRC8;//пока не трогаем

byte start_byte_one;//в длинном пакете равен 254
  byte start_byte_two;//в длинном пакете равен 232
  byte temp_pomp;//температура охлаждения
  byte on_of_pomp;//on-off насоса (1 или 0)
  double  ex_temp_reactor;//текущая температура в реакторе
  byte current_temp_reactor;//выставленная температура в реакторе
  byte timer_ex;//таймер
  byte tmp;//пока не трогаем
  byte CRC8;//пока не трогаем