#include <SoftwareSerial.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C _lcd1(0x27, 16, 2);
int _dispTempLength1=0;
boolean _isNeedClearDisp1;
SoftwareSerial Serial100(17, 16);
int _modbusMasterDataTable_4_reg_1[2];
int _modbusMasterAddressTable_4_reg_1[2] = {8192, 8193};
int _modbusMasterDataTable_4_reg_2[2];
int _modbusMasterAddressTable_4_reg_2[2] = {8192, 8193};
int _modbusMasterDataTable_4_reg_3[2];
int _modbusMasterAddressTable_4_reg_3[2] = {8192, 8193};
byte _modbusMasterBufferSize = 0;
byte _modbusMasterState = 1;
long _modbusMasterSendTime;
byte _modbusMasterLastRec = 0;
long _modbusMasterStartT35;
byte _modbusMasterBuffer[64];
byte _modbusMasterCurrentReg = 0;
byte _modbusMasterCurrentVariable = 0;
struct _modbusMasterTelegramm 
{
    byte slaveId;
    byte function;
    int startAddres;
    int numbeRegs;
    int valueIndex;
}
;
_modbusMasterTelegramm _modbusTelegramm;
long _startTimeMasterRegs[3];
long _updateTimeMasterRegsArray[] = {1, 1, 1};
byte _readWriteMasterVars[] = {3,3,3,3,3,3};
const unsigned char _modbusMaster_fctsupported[] = {3, 6, 16};
bool sequencer_255792341_isNeedUpdateValues = 1;
const int sequencer_255792341_Out1_ValArr[]  PROGMEM =  {0, 2000, 3500, 4500, 5000, 0};
const int sequencer_255792341_Out2_ValArr[]  PROGMEM =  {0, 5000, 1000, 2000, 3000, 0};
const int sequencer_255792341_Out3_ValArr[]  PROGMEM =  {0, 3000, 2000, 5000, 4000, 0};
const int sequencer_255792341_Out4_ValArr[]  PROGMEM =  {500, 10000, 10000, 10000, 10000, 10000};
bool _gtv1;
int _gtv2;
int _gtv3;
int _gtv4;
int _disp7oldLength = 0;
int _disp5oldLength = 0;
int _disp6oldLength = 0;
int _swi1;
int sequencer_255792341_Out1;
int sequencer_255792341_Out2;
int sequencer_255792341_Out3;
int sequencer_255792341_Out4;
int sequencer_255792341_CSOUT = 1;
unsigned long sequencer_255792341_SST = 0UL;
int _disp3oldLength = 0;
int _disp4oldLength = 0;
int _disp2oldLength = 0;
bool _bounseInputD7S = 0;
bool _bounseInputD7O = 0;
unsigned long _bounseInputD7P = 0UL;
int _disp1oldLength = 0;
int _tempVariable_int;
void setup()
{
    pinMode(7, INPUT_PULLUP);
    Wire.begin();
    delay(10);
    Serial100.begin(9600);
    for(int i=0; i<3; i++) 
    {
        _startTimeMasterRegs[i] =  millis();
    }
    _lcd1.init();
    _lcd1.backlight();
    _bounseInputD7O =  digitalRead(7);
    sequencer_255792341_setStep(0);
    sequencer_255792341_SST = millis();
}
void loop()
{
    if (_isNeedClearDisp1) 
    {
        _lcd1.clear();
        _isNeedClearDisp1= 0;
    }
    bool  _bounceInputTmpD7 =  (digitalRead (7));
    if (_bounseInputD7S)
    {
        if (millis() >= (_bounseInputD7P + 40))
        {
            _bounseInputD7O= _bounceInputTmpD7;
            _bounseInputD7S=0;
        }
    }
    else
    {
        if (_bounceInputTmpD7 != _bounseInputD7O)
        {
            _bounseInputD7S=1;
            _bounseInputD7P = millis();
        }
    }
    //Плата:1
    _gtv1 = !(_bounseInputD7O);
    sequencer_255792341_setOutputValue();
    if (!(_bounseInputD7O)) 
    {
        if (_isTimer(sequencer_255792341_SST, sequencer_255792341_Out4)) 
        {
            sequencer_255792341_setStep(sequencer_255792341_CSOUT + 1);
        }
    }
    else 
    {
        sequencer_255792341_SST = millis();
    }
    if (!(!(_bounseInputD7O))) 
    {
        sequencer_255792341_setStep(0);
    }
    _gtv4 = sequencer_255792341_Out3;
    _tempVariable_int = sequencer_255792341_Out3;
    if (! (_tempVariable_int == (_modbusMasterDataTable_4_reg_3[1]))) 
    {
        _readWriteMasterVars[5] = 6;
    }
    ;
    _modbusMasterDataTable_4_reg_3[1] = _tempVariable_int;
    _gtv3 = sequencer_255792341_Out2;
    _tempVariable_int = sequencer_255792341_Out2;
    if (! (_tempVariable_int == (_modbusMasterDataTable_4_reg_2[1]))) 
    {
        _readWriteMasterVars[3] = 6;
    }
    ;
    _modbusMasterDataTable_4_reg_2[1] = _tempVariable_int;
    _gtv2 = sequencer_255792341_Out1;
    _tempVariable_int = sequencer_255792341_Out1;
    if (! (_tempVariable_int == (_modbusMasterDataTable_4_reg_1[1]))) 
    {
        _readWriteMasterVars[1] = 6;
    }
    ;
    _modbusMasterDataTable_4_reg_1[1] = _tempVariable_int;
    if(_gtv1)
    {
        _swi1=5;
    }
    else
    {
        _swi1=6;
    }
    _tempVariable_int = _swi1;
    if (! (_tempVariable_int == (_modbusMasterDataTable_4_reg_3[0]))) 
    {
        _readWriteMasterVars[4] = 6;
    }
    ;
    _modbusMasterDataTable_4_reg_3[0] = _tempVariable_int;
    _tempVariable_int = _swi1;
    if (! (_tempVariable_int == (_modbusMasterDataTable_4_reg_1[0]))) 
    {
        _readWriteMasterVars[0] = 6;
    }
    ;
    _modbusMasterDataTable_4_reg_1[0] = _tempVariable_int;
    _tempVariable_int = _swi1;
    if (! (_tempVariable_int == (_modbusMasterDataTable_4_reg_2[0]))) 
    {
        _readWriteMasterVars[2] = 6;
    }
    ;
    _modbusMasterDataTable_4_reg_2[0] = _tempVariable_int;
    //Плата:2
    if (!(0)) 
    {
        _dispTempLength1 = (((String((_gtv3)/(100), DEC)))).length();
        if (_disp3oldLength > _dispTempLength1) 
        {
            _isNeedClearDisp1 = 1;
        }
        _disp3oldLength = _dispTempLength1;
        _lcd1.setCursor(8, 1);
        _lcd1.print(((String((_gtv3)/(100), DEC))));
    }
     else 
    {
        if (_disp3oldLength > 0) 
        {
            _isNeedClearDisp1 = 1;
            _disp3oldLength = 0;
        }
    }
    if (1) 
    {
        _dispTempLength1 = (((String((_gtv4)/(100), DEC)))).length();
        if (_disp4oldLength > _dispTempLength1) 
        {
            _isNeedClearDisp1 = 1;
        }
        _disp4oldLength = _dispTempLength1;
        _lcd1.setCursor(12, 1);
        _lcd1.print(((String((_gtv4)/(100), DEC))));
    }
     else 
    {
        if (_disp4oldLength > 0) 
        {
            _isNeedClearDisp1 = 1;
            _disp4oldLength = 0;
        }
    }
    if (1) 
    {
        _dispTempLength1 = (((String((_gtv2)/(100), DEC)))).length();
        if (_disp2oldLength > _dispTempLength1) 
        {
            _isNeedClearDisp1 = 1;
        }
        _disp2oldLength = _dispTempLength1;
        _lcd1.setCursor(4, 1);
        _lcd1.print(((String((_gtv2)/(100), DEC))));
    }
     else 
    {
        if (_disp2oldLength > 0) 
        {
            _isNeedClearDisp1 = 1;
            _disp2oldLength = 0;
        }
    }
    if (!(_gtv1)) 
    {
        _dispTempLength1 = ((String("sh  n1  n2  n3"))).length();
        if (_disp1oldLength > _dispTempLength1) 
        {
            _isNeedClearDisp1 = 1;
        }
        _disp1oldLength = _dispTempLength1;
        _lcd1.setCursor(0, 0);
        _lcd1.print((String("sh  n1  n2  n3")));
    }
     else 
    {
        if (_disp1oldLength > 0) 
        {
            _isNeedClearDisp1 = 1;
            _disp1oldLength = 0;
        }
    }
    if (_gtv1) 
    {
        _dispTempLength1 = ((String("ps  n1  n2  n3  "))).length();
        if (_disp5oldLength > _dispTempLength1) 
        {
            _isNeedClearDisp1 = 1;
        }
        _disp5oldLength = _dispTempLength1;
        _lcd1.setCursor(int((16 - _dispTempLength1)/2), 0);
        _lcd1.print((String("ps  n1  n2  n3  ")));
    }
     else 
    {
        if (_disp5oldLength > 0) 
        {
            _isNeedClearDisp1 = 1;
            _disp5oldLength = 0;
        }
    }
    if (_gtv1) 
    {
        _dispTempLength1 = ((String("H"))).length();
        if (_disp6oldLength > _dispTempLength1) 
        {
            _isNeedClearDisp1 = 1;
        }
        _disp6oldLength = _dispTempLength1;
        _lcd1.setCursor(0, 1);
        _lcd1.print((String("H")));
    }
     else 
    {
        if (_disp6oldLength > 0) 
        {
            _isNeedClearDisp1 = 1;
            _disp6oldLength = 0;
        }
    }
    if (!(_gtv1)) 
    {
        _dispTempLength1 = ((String("H"))).length();
        if (_disp7oldLength > _dispTempLength1) 
        {
            _isNeedClearDisp1 = 1;
        }
        _disp7oldLength = _dispTempLength1;
        _lcd1.setCursor(0, 1);
        _lcd1.print((String("H")));
    }
     else 
    {
        if (_disp7oldLength > 0) 
        {
            _isNeedClearDisp1 = 1;
            _disp7oldLength = 0;
        }
    }
    switch (_modbusMasterState) 
    {
        case 1:
        _nextModbusMasterQuery();
        break;
        case 2:
        pollModbusMaster();
        break;
    }
}
bool _isTimer(unsigned long startTime, unsigned long period)
{
    unsigned long currentTime;
    currentTime = millis();
    if (currentTime>= startTime) 
    {
        return (currentTime>=(startTime + period));
    }
     else 
    {
        return (currentTime >=(4294967295-startTime+period));
    }
}
int modbusCalcCRC(byte length, byte bufferArray[])
{
    unsigned int temp, temp2, flag;
    temp = 0xFFFF;
    for (unsigned char i = 0; i < length; i++) 
    {
        temp = temp ^ bufferArray[i];
        for (unsigned char j = 1; j <= 8; j++) 
        {
            flag = temp & 0x0001;
            temp >>= 1;
            if (flag)   temp ^= 0xA001;
        }
    }
    temp2 = temp >> 8;
    temp = (temp << 8) | temp2;
    temp &= 0xFFFF;
    return temp;
}
void _nextModbusMasterQuery()
{
    _selectNewModbusMasterCurrentReg(_modbusMasterCurrentReg, _modbusMasterCurrentVariable);
    if (_modbusMasterCurrentReg == 0)  return;
    _createMasterTelegramm();
    _modbusMasterSendQuery();
}
void _selectNewModbusMasterCurrentReg(byte oldReg, byte oldVar)
{
    bool isNeeded = 1;
    if (oldReg == 0) 
    {
        _selectNewModbusMasterCurrentReg(1, 0);
        return;
    }
    if (!(_isTimer  ((_startTimeMasterRegs[oldReg - 1]),(_updateTimeMasterRegsArray[oldReg -1])))) 
    {
        isNeeded = 0;
    }
    if(! isNeeded) 
    {
        if(oldReg < 3) 
        {
            _selectNewModbusMasterCurrentReg(oldReg+1, 0);
            return;
        }
         else 
        {
            _modbusMasterCurrentReg = 0;
            _modbusMasterCurrentVariable = 0;
            return;
        }
    }
    if (oldVar == 0) 
    {
        _modbusMasterCurrentReg = oldReg;
        _modbusMasterCurrentVariable = 1;
        return;
    }
    byte temp;
    switch (oldReg) 
    {
        case 1:
        temp = 2;
        break;
        case 2:
        temp = 2;
        break;
        case 3:
        temp = 2;
        break;
    }
    if (oldVar < temp) 
    {
        _modbusMasterCurrentReg = oldReg;
        _modbusMasterCurrentVariable = oldVar +1;
        return;
    }
    _startTimeMasterRegs[oldReg -1] = millis();
    if(oldReg < 3) 
    {
         _selectNewModbusMasterCurrentReg(oldReg+1, 0);
        return;
    }
    _modbusMasterCurrentReg = 0;
    _modbusMasterCurrentVariable = 0;
    return;
}
void _createMasterTelegramm()
{
    switch (_modbusMasterCurrentReg) 
    {
        case 1:
        _modbusTelegramm.slaveId = 1;
        switch (_modbusMasterCurrentVariable) 
        {
            case 1:
            _modbusTelegramm.function = _readWriteMasterVars[0];
            _modbusTelegramm.startAddres = 8192;
            _modbusTelegramm.numbeRegs = 1;
            _modbusTelegramm.valueIndex = 0;
            _readWriteMasterVars[0] = 3;
            break;
            case 2:
            _modbusTelegramm.function = _readWriteMasterVars[1];
            _modbusTelegramm.startAddres = 8193;
            _modbusTelegramm.numbeRegs = 1;
            _modbusTelegramm.valueIndex = 1;
            _readWriteMasterVars[1] = 3;
            break;
        }
        break;
        case 2:
        _modbusTelegramm.slaveId = 2;
        switch (_modbusMasterCurrentVariable) 
        {
            case 1:
            _modbusTelegramm.function = _readWriteMasterVars[2];
            _modbusTelegramm.startAddres = 8192;
            _modbusTelegramm.numbeRegs = 1;
            _modbusTelegramm.valueIndex = 0;
            _readWriteMasterVars[2] = 3;
            break;
            case 2:
            _modbusTelegramm.function = _readWriteMasterVars[3];
            _modbusTelegramm.startAddres = 8193;
            _modbusTelegramm.numbeRegs = 1;
            _modbusTelegramm.valueIndex = 1;
            _readWriteMasterVars[3] = 3;
            break;
        }
        break;
        case 3:
        _modbusTelegramm.slaveId = 3;
        switch (_modbusMasterCurrentVariable) 
        {
            case 1:
            _modbusTelegramm.function = _readWriteMasterVars[4];
            _modbusTelegramm.startAddres = 8192;
            _modbusTelegramm.numbeRegs = 1;
            _modbusTelegramm.valueIndex = 0;
            _readWriteMasterVars[4] = 3;
            break;
            case 2:
            _modbusTelegramm.function = _readWriteMasterVars[5];
            _modbusTelegramm.startAddres = 8193;
            _modbusTelegramm.numbeRegs = 1;
            _modbusTelegramm.valueIndex = 1;
            _readWriteMasterVars[5] = 3;
            break;
        }
        break;
    }
}
void _modbusMasterSendQuery()
{
    int intTemp;
    byte currentIndex = _modbusTelegramm.valueIndex;
    _modbusMasterBuffer[0]  = _modbusTelegramm.slaveId;
    _modbusMasterBuffer[1] = _modbusTelegramm.function;
    _modbusMasterBuffer[2] = highByte(_modbusTelegramm.startAddres);
    _modbusMasterBuffer[3] = lowByte(_modbusTelegramm.startAddres);
    switch (_modbusTelegramm.function) 
    {
        case 3:
        _modbusMasterBuffer[4] = highByte(_modbusTelegramm.numbeRegs);
        _modbusMasterBuffer[5] = lowByte(_modbusTelegramm.numbeRegs);
        _modbusMasterBufferSize = 6;
        break;
        case 6:
        switch (_modbusMasterCurrentReg) 
        {
            case 1 :
            intTemp = _modbusMasterDataTable_4_reg_1[currentIndex];
            break;
            case 2 :
            intTemp = _modbusMasterDataTable_4_reg_2[currentIndex];
            break;
            case 3 :
            intTemp = _modbusMasterDataTable_4_reg_3[currentIndex];
            break;
        }
        _modbusMasterBuffer[4]      = highByte(intTemp);
        _modbusMasterBuffer[5]      = lowByte(intTemp);
        _modbusMasterBufferSize = 6;
        break;
    }
    _modbusMasterSendTxBuffer();
    _modbusMasterState = 2;
}
void _modbusMasterSendTxBuffer()
{
    byte i = 0;
    int crc = modbusCalcCRC(_modbusMasterBufferSize, _modbusMasterBuffer);
    _modbusMasterBuffer[ _modbusMasterBufferSize ] = crc >> 8;
    _modbusMasterBufferSize++;
    _modbusMasterBuffer[ _modbusMasterBufferSize ] = crc & 0x00ff;
    _modbusMasterBufferSize++;
    Serial100.write(_modbusMasterBuffer, _modbusMasterBufferSize);
    Serial100.flush();
    _modbusMasterBufferSize = 0;
    _modbusMasterSendTime = millis();
}
void pollModbusMaster()
{
    if (_modbusTelegramm.slaveId == 0) 
    {
        _modbusMasterState = 1;
        return;
    }
    if (_isTimer(_modbusMasterSendTime, 1000)) 
    {
        _modbusMasterState = 1;
        return;
    }
    byte avalibleBytes = Serial100.available();
    if (avalibleBytes == 0) return;
    if (avalibleBytes != _modbusMasterLastRec) 
    {
        _modbusMasterLastRec = avalibleBytes;
        _modbusMasterStartT35 = millis();
        return;
    }
    if (!(_isTimer(_modbusMasterStartT35, 5))) return;
    _modbusMasterLastRec = 0;
    byte readingBytes = _modbusMasterGetRxBuffer();
    if (readingBytes < 5) 
    {
        _modbusMasterState = 1;
        return ;
    }
    byte exeption = validateAnswer();
    if (exeption != 0) 
    {
        _modbusMasterState = 1;
        return;
    }
    switch (_modbusMasterBuffer[1]) 
    {
        case 3:
        get_FC3(4);
        break;
    }
    _modbusMasterState = 1;
    return;
}
byte _modbusMasterGetRxBuffer()
{
    boolean bBuffOverflow = false;
    _modbusMasterBufferSize = 0;
    while (Serial100.available()) 
    {
        _modbusMasterBuffer[ _modbusMasterBufferSize ] = Serial100.read();
        _modbusMasterBufferSize ++;
        if (_modbusMasterBufferSize >= 64) bBuffOverflow = true;
    }
    if (bBuffOverflow) 
    {
        return -3;
    }
    return _modbusMasterBufferSize;
}
byte validateAnswer()
{
    uint16_t u16MsgCRC =    ((_modbusMasterBuffer[_modbusMasterBufferSize - 2] << 8) | _modbusMasterBuffer[_modbusMasterBufferSize - 1]);
    if (modbusCalcCRC(_modbusMasterBufferSize - 2,_modbusMasterBuffer) != u16MsgCRC) 
    {
         return 255;
    }
    if ((_modbusMasterBuffer[1] & 0x80) != 0) 
    {
        return _modbusMasterBuffer[2] ;
    }
    boolean isSupported = false;
    for (byte i = 0; i < sizeof(_modbusMaster_fctsupported); i++) 
    {
        if (_modbusMaster_fctsupported[i] == _modbusMasterBuffer[1]) 
        {
            isSupported = 1;
            break;
        }
    }
    if (!isSupported) 
    {
        return 1;
    }
    return 0;
}
void get_FC3(byte table)
{
    int currentIndex = _modbusTelegramm.valueIndex;
    byte currentByte = 3;
    int value;
    for (int i = 0; i < _modbusTelegramm.numbeRegs; i++) 
    {
        value = word(_modbusMasterBuffer[ currentByte],   _modbusMasterBuffer[ currentByte + 1 ]);
        switch (_modbusMasterCurrentReg) 
        {
            case 1 :
            if(table == 3) 
            {
            }
             else 
            {
                _modbusMasterDataTable_4_reg_1[currentIndex + i] =value;
            }
            break;
            case 2 :
            if(table == 3) 
            {
            }
             else 
            {
                _modbusMasterDataTable_4_reg_2[currentIndex + i] =value;
            }
            break;
            case 3 :
            if(table == 3) 
            {
            }
             else 
            {
                _modbusMasterDataTable_4_reg_3[currentIndex + i] =value;
            }
            break;
        }
        currentByte += 2;
    }
}
void sequencer_255792341_setStep(int stepValue)
{
    int step = stepValue;
    if(step < 0) 
    {
        return;
    }
    if(step >  5) 
    {
        step = 0;
    }
    if(step ==  sequencer_255792341_CSOUT) 
    {
        return;
    }
    sequencer_255792341_CSOUT  =  step;
    sequencer_255792341_SST = millis();
    sequencer_255792341_isNeedUpdateValues = 1;
}
void sequencer_255792341_setOutputValue()
{
    if (! sequencer_255792341_isNeedUpdateValues) 
    {
        return;
    }
    sequencer_255792341_isNeedUpdateValues = 0;
    int step = sequencer_255792341_CSOUT;
    sequencer_255792341_Out4 = (pgm_read_word(&sequencer_255792341_Out4_ValArr[step]));
    if (! (sequencer_255792341_Out4> 0))
    {
        return;
    }
    sequencer_255792341_Out1 = (pgm_read_word(&sequencer_255792341_Out1_ValArr[step]));
    sequencer_255792341_Out2 = (pgm_read_word(&sequencer_255792341_Out2_ValArr[step]));
    sequencer_255792341_Out3 = (pgm_read_word(&sequencer_255792341_Out3_ValArr[step]));
    sequencer_255792341_Out4 = (pgm_read_word(&sequencer_255792341_Out4_ValArr[step]));
}