Arduino 101 BLE connection stop responding

I have problems getting my Blynk project robust. The Blynk part of the project consist of a Arduino 101 with a quite simple task, receive information from the Blynk app through BLE and pass it along via a SoftwareSerial output. However the number of values it has to pass along have become quite extensive.

Unfortunately the device seems to stop responding after letting it run for a while. The Blynk app disconnects and the device name disappears from the list of available devices. The device dosen’t need to be connected to the app either. Just leaving it for a while makes the device name disappear. That makes me believe that it might not be caused by a specific event. However, stressing a button extensively sometimes makes it stop responding right away.

I have tried debugging by placing serial outputs throughout the code. The weird thing is that does not stop responding as long as the Arduino IDE is connected to the COM.

//-----( Blynk )-----

#define BLYNK_PRINT Serial

#include <BlynkSimpleCurieBLE.h>
#include <CurieBLE.h>

char auth[] = "censored";

BLEPeripheral  blePeripheral;


//-----( Libraries )-----

#include <SoftwareSerial.h>
#include <EEPROM.h>


//-----( Constants and Pins )-----
//--( Pins )--
#define pRX 12 //RO
#define pTX 11 //DI
#define pComActive 13
//virtual pins
#define pStarterBatVoltage V0
#define pAuxBatVoltage V1
#define pAuxBatOn V2
#define pAuxBatMode V3
#define pAuxBatLimit V4
#define pStartWarn V5
#define pStartWarnLimit V6
#define pAuxWarn V7
#define pAuxWarnLimit V8 
#define pAuxFault V9
#define pStartBatLow V10
#define pAuxBatLow V11
#define pFridgeOn V12
#define pFridgeLow V13
#define pFridgeMode V14
#define pFridgeTemp V15
#define pFridgeLimit V16
#define pFridgeWarn V17
#define pFridgeTempLowerLimit V18
#define pFridgeTempUpperLimit V19
#define pFridgeTempLow V28
#define pFridgeTempHigh V29
#define pOutdoorTemp V56
#define pIndoorTemp V57
#define pUsbOn V60
#define pUsbLow V61
#define pUsbMode V62
#define pUsbLimit V63
#define pInverterOn V64
#define pInverterLow V65
#define pInverterMode V66
#define pInverterLimit V67
#define pAudioOn V68
#define pAudioLow V69
#define pAudioMode V70
#define pAudioLimit V71
#define pAppRefresh V49
#define pTerminal V50
#define pSaveRom V51
#define pReadRom V52
#define pReqUpdate V53
#define pSendUpdate V54
#define pRestoreLow V55

#define pRadioOn V38
#define pIgnitionOn V39

#define pRelay1State V20
#define pRelay2State V21
#define pRelay3State V22
#define pRelay4State V23
#define pRelay5State V24
#define pRelay6State V25
#define pRelay7State V26
#define pRelay8State V27
#define pRelay1Forced V30
#define pRelay2Forced V31
#define pRelay3Forced V32
#define pRelay4Forced V33
#define pRelay5Forced V34
#define pRelay6Forced V35
#define pRelay7Forced V36
#define pRelay8Forced V37
#define pRelay1ForcedState V40
#define pRelay2ForcedState V41
#define pRelay3ForcedState V42
#define pRelay4ForcedState V43
#define pRelay5ForcedState V44
#define pRelay6ForcedState V45
#define pRelay7ForcedState V46
#define pRelay8ForcedState V47

//--( Constants )--
//com
#define RS485Transmit    HIGH
#define RS485Receive     LOW

const char idCommunicator = '1';
const char idRelayBox1 = '2';

const String high = "h";
const String low = "l";

const char strt = '(';
const char stp = ')';
const char cRecieve = ':';
const char cRestoreLow = '-';

const char cLED = '.';
const char cStarterBatVoltage = 'a';
const char cAuxBatVoltage = 'b';
const char cAuxBatOn = 'c';
const char cAuxBatMode = 'd';
const char cAuxBatLimit = 'e';
const char cStartWarn = 'f';
const char cStartWarnLimit = 'g';
const char cAuxWarn = 'h';
const char cAuxWarnLimit = 'i';
const char cAuxFault = 'j';
const char cStartBatLow = 'k';
const char cAuxBatLow = 'l';
const char cFridgeOn = 'm';
const char cFridgeLow = 'n';
const char cFridgeMode = 'o';
const char cFridgeTemp = 'p';
const char cFridgeLimit = 'q';
const char cFridgeWarn = 'r';
const char cFridgeTempLowerLimit = 's';
const char cFridgeTempUpperLimit = 't';
const char cFridgeTempLow = 'u';
const char cFridgeTempHigh = 'v';
const char cOutdoorTemp = 'P';
const char cIndoorTemp = 'Q';
const char cUsbOn = 'A';
const char cUsbLow = 'B';
const char cUsbMode = 'C';
const char cUsbLimit = 'D';
const char cInverterOn = 'E';
const char cInverterLow = 'F';
const char cInverterMode = 'G';
const char cInverterLimit = 'H';
const char cAudioOn = 'I';
const char cAudioLow = 'J';
const char cAudioMode = 'K';
const char cAudioLimit = 'L';
const char cRadioOn = 'M';
const char cIgnitionOn = 'N';
const char cRefresh = 'O';

const char cRelay1State = '1';
const char cRelay2State = '2';
const char cRelay3State = '3';
const char cRelay4State = '4';
const char cRelay5State = '5';
const char cRelay6State = '6';
const char cRelay7State = '7';
const char cRelay8State = '8';
const char cRelay1Forced = '!';
const char cRelay2Forced = '"';
const char cRelay3Forced = '#';
const char cRelay4Forced = '¤';
const char cRelay5Forced = '%';
const char cRelay6Forced = '&';
const char cRelay7Forced = '/';
const char cRelay8Forced = '=';
const char cRelay1ForcedState = '@';
const char cRelay2ForcedState = '£';
const char cRelay3ForcedState = '$';
const char cRelay4ForcedState = '{';
const char cRelay5ForcedState = '[';
const char cRelay6ForcedState = ']';
const char cRelay7ForcedState = '}';
const char cRelay8ForcedState = '+';

//EEPROM Start Index
#define rAuxBatMode             0
#define rAuxBatLimit            1   //4 byte
#define rStartWarn              5
#define rStartWarnLimit         6   //4 byte
#define rAuxWarn                10
#define rAuxWarnLimit           11  //4 byte
#define rFridgeMode             15
#define rFridgeLimit            16  //4 byte
#define rFridgeWarn             20
#define rFridgeTempLowerLimit   21  //4 byte
#define rFridgeTempUpperLimit   25  //4 byte
#define rUSBMode                26
#define rUSBLimit               27  //4 byte
#define rInverterMode           31
#define rInverterLimit          32  //4 dyte
#define rAudioMode              36
#define rAudioLimit             37  //4 byte

//misc
const int comSendBufferSize = 10;

//-----( Objects )-----
SoftwareSerial com (pRX,pTX);

//-----( Variables )-----
//--( Control variables )--
//battery
int auxBatMode = 3;
double auxBatLimit = 0;
int startWarn = 0;
double startWarnLimit = 0;
int auxWarn = 0;
double auxWarnLimit = 0;

//fridge
int fridgeMode = 3;
double fridgeLimit = 0;
int fridgeWarn = 0;
double fridgeTempLowerLimit = 0;
double fridgeTempUpperLimit = 0;

//usb
int usbMode = 3;
double usbLimit = 0;

//inverter
int inverterMode = 3;
double inverterLimit = 0;

//audio
int audioMode = 7;
double audioLimit = 0;


//--( State variables )--
//battery
double starterBatVoltage = 0;
double auxBatVoltage = 0;
int auxBatOn = 0;
int auxFault = 0;
int startBatLow = 0;
int auxBatLow = 0;
int radioOn = 0;
int ignitionOn = 0;
int auxPrevious = 0;
int auxChangeState = 0;
long auxChangeStateTimer = 0;

//fridge
double fridgeTemp = 0;
int fridgeOn = 0;
int fridgeLow = 0;
int fridgeTempLow = 0;
int fridgeTempHigh = 0;

//Ambient temp
double outdoorTemp = 0;
double indoorTemp = 0;

//usb
int usbOn = 0;
int usbLow = 0;

//inverter
int inverterOn = 0;
int inverterLow = 0;

//audio
int audioOn = 0;
int audioLow = 0;

//com
char readout =' ';
char prefix = ' ';
char id = ' ';
String val = "";
int valCount = 0;
boolean idOK = false;
boolean messageOK = false;
boolean prefixOK = false;
boolean valueOK = false;
int recieve = 0;
char deviceIDBuffer[comSendBufferSize];
char prefixBuffer[comSendBufferSize];
String messageBuffer[comSendBufferSize];
int bufferValues = 0;

//relays
int relay1State = 0;
int relay2State = 0;
int relay3State = 0;
int relay4State = 0;
int relay5State = 0;
int relay6State = 0;
int relay7State = 0;
int relay8State = 0;
int relay1Forced = 0;
int relay2Forced = 0;
int relay3Forced = 0;
int relay4Forced = 0;
int relay5Forced = 0;
int relay6Forced = 0;
int relay7Forced = 0;
int relay8Forced = 0;
int relay1ForcedState = 0;
int relay2ForcedState = 0;
int relay3ForcedState = 0;
int relay4ForcedState = 0;
int relay5ForcedState = 0;
int relay6ForcedState = 0;
int relay7ForcedState = 0;
int relay8ForcedState = 0;

//misc
boolean appRefreshPressed = false;
boolean reqUpdatePressed = false;
boolean sndUpdatePressed = false;
boolean restoreLowPressed = false;
boolean readRomPressed = false;
boolean saveRomPressed = false;
boolean calGyroPressed = false;

void setup()
{
  com.begin(9600);

  pinMode(pComActive, OUTPUT);
  digitalWrite(pComActive, RS485Receive); 

  //Blynk
  blePeripheral.setLocalName("LCBle");
  blePeripheral.setDeviceName("LCBle");
  blePeripheral.setAppearance(384);
  Blynk.begin(blePeripheral, auth);
  blePeripheral.begin();
}


void loop()
{
  blePeripheral.poll();
  Blynk.run();
  
  //read com
  while (com.available() > 0) readCom();
  
  //send buffer
  checkBuffer();
}

//-----( Update )-----
void requestUpdate()
{
  sendCom(idRelayBox1, cRefresh, high);
  Blynk.virtualWrite(pTerminal, "Update requested" + String('\r'));
}
void updateRecived()
{
  Blynk.virtualWrite(pTerminal, "Update recived" + String('\r'));
  //updateRom();
  appUpdate();
}

void sendUpdate()
{
  sendCom(idRelayBox1, cRecieve, high);
  sendCom(idRelayBox1, cAuxBatMode, String(auxBatMode));
  sendCom(idRelayBox1, cAuxBatLimit, String(auxBatLimit));
  sendCom(idRelayBox1, cStartWarn, String(startWarn));
  sendCom(idRelayBox1, cStartWarnLimit, String(startWarnLimit));
  sendCom(idRelayBox1, cAuxWarn, String(auxWarn));
  sendCom(idRelayBox1, cAuxWarnLimit, String(auxWarnLimit));
  sendCom(idRelayBox1, cFridgeMode, String(fridgeMode));
  sendCom(idRelayBox1, cFridgeLimit, String(fridgeLimit));
  sendCom(idRelayBox1, cFridgeWarn, String(fridgeWarn));
  sendCom(idRelayBox1, cFridgeTempLowerLimit, String(fridgeTempLowerLimit));
  sendCom(idRelayBox1, cFridgeTempUpperLimit, String(fridgeTempUpperLimit));
  sendCom(idRelayBox1, cUsbMode, String(usbMode));
  sendCom(idRelayBox1, cUsbLimit, String(usbLimit));
  sendCom(idRelayBox1, cInverterMode, String(inverterMode));
  sendCom(idRelayBox1, cInverterLimit, String(inverterLimit));
  sendCom(idRelayBox1, cAudioMode, String(audioMode));
  sendCom(idRelayBox1, cAudioLimit, String(audioLimit));
  sendCom(idRelayBox1, cRecieve, low);
  Blynk.virtualWrite(pTerminal, "Update sent" + String('\r'));
}

//-----( Serial Read/Write )-----
void sendCom(char sDeviceID, char sPrefix, String sMessage)
{ 
  if(recieve)
  {
    if(bufferValues < comSendBufferSize)
    {
      deviceIDBuffer[bufferValues] = sDeviceID;
      prefixBuffer[bufferValues] = sPrefix;
      messageBuffer[bufferValues] = sMessage;
      bufferValues++;

      Blynk.virtualWrite(pTerminal, "Message saved to buffer - Count: " + String(bufferValues) + String('\r'));
    }
    else Blynk.virtualWrite(pTerminal, "Message buffer full" + String('\r'));
  }
  else
  {
    digitalWrite(pComActive, RS485Transmit);  // Enable RS485 Transmit
    com.write(strt);
    com.write(sDeviceID); 
    com.write(sPrefix);
    com.print(sMessage);
    com.write(stp);
    digitalWrite(pComActive, RS485Receive);  // Disable RS485 Transmit
  }
  
}
void checkBuffer()
{
  if(!recieve)
  {
    if(bufferValues > 0) sendCom(idRelayBox1, cRecieve, high);
    while(bufferValues > 0)
    {
      //Serial.println("Buffer send");
      sendCom(deviceIDBuffer[bufferValues - 1], prefixBuffer[bufferValues - 1], messageBuffer[bufferValues - 1]);
      bufferValues--;

      if(bufferValues == 0) 
      {
        sendCom(idRelayBox1, cRecieve, low);
        Blynk.virtualWrite(pTerminal, "Buffer message sent - Cleared" + String('\r'));    
      }
      else Blynk.virtualWrite(pTerminal, "Buffer message sent - Values left: " + String(bufferValues) + String('\r'));
    }
  }
}
void readCom()
{ 
  // --( Read )--
  readout = char(com.read());
  //Serial.print(readout);
  
  //Message - Part 4
  if(prefixOK)
  {
    if(readout != stp)
    {
      val = val + String(readout);
      valCount++;
    }
    else
    {
      prefixOK = false;
      valueOK = true;
    }

    if(valCount > 10)
    {
      prefixOK = false;
      valueOK = false;
      Blynk.virtualWrite(pTerminal, "Read message Error" + String('\r'));
    }
  }

  //Message - Part 3
  if(idOK)
  {
    prefix = readout;
    idOK = false;
    prefixOK = true;
  }
  
  //Message - Part 2
  if(messageOK)
  {
    id = readout;
    messageOK = false;
    idOK = true;
  }
  
  //Message - Part 1
  if(readout == strt)
  {
    messageOK = true;
    val = "";
    valCount = 0;
  }

  // --( Interpret message )--
  if(valueOK)
  {
    interpretMessage();
    valueOK = false;
  }
}

void interpretMessage()
{
   //----( Forward )----
   if(prefix == cStarterBatVoltage)
    {
      starterBatVoltage = val.toFloat();
      Blynk.virtualWrite(pStarterBatVoltage, String(starterBatVoltage, 1));
    }
    if(prefix == cAuxBatVoltage)
    {
      auxBatVoltage = val.toFloat();
      Blynk.virtualWrite(pAuxBatVoltage, String(auxBatVoltage, 1));
    }
    if(prefix == cAuxBatOn)
    {
      auxBatOn = val.toInt();
      Blynk.virtualWrite(pAuxBatOn, auxBatOn*1000);
    }
    if(prefix == cAuxFault)
    {
      auxFault = val.toInt();
      Blynk.virtualWrite(pAuxFault, auxFault*1000);
    }
    if(prefix == cStartBatLow)
    {
      startBatLow = val.toInt();
      Blynk.virtualWrite(pStartBatLow, startBatLow*1000);
    }
    if(prefix == cAuxBatLow)
    {
      auxBatLow = val.toInt();
      Blynk.virtualWrite(pAuxBatLow, auxBatLow*1000);
    }
    if(prefix == cFridgeOn)
    {
      fridgeOn = val.toInt();
      Blynk.virtualWrite(pFridgeOn, fridgeOn*1000);
    }
    if(prefix == cFridgeLow)
    {
      fridgeLow = val.toInt();
      Blynk.virtualWrite(pFridgeLow, fridgeLow*1000);
    }
    if(prefix == cFridgeTemp)
    {
      fridgeTemp = val.toFloat();
      Blynk.virtualWrite(pFridgeTemp, String(fridgeTemp, 1));
    }
    if(prefix == cFridgeTempLow)
    {
      fridgeTempLow = val.toInt();
      Blynk.virtualWrite(pFridgeTempLow, fridgeTempLow*1000);
    }
    if(prefix == cFridgeTempHigh)
    {
      fridgeTempHigh = val.toInt();
      Blynk.virtualWrite(pFridgeTempHigh, fridgeTempHigh*1000);
    }
    if(prefix == cOutdoorTemp)
    {
      outdoorTemp = val.toFloat();
      Blynk.virtualWrite(pOutdoorTemp, String(outdoorTemp, 1));
    }
    if(prefix == cIndoorTemp)
    {
      indoorTemp = val.toFloat();
      Blynk.virtualWrite(pIndoorTemp, String(indoorTemp, 1));
    }
    if(prefix == cUsbOn)
    {
      usbOn = val.toInt();
      Blynk.virtualWrite(pUsbOn, usbOn*1000);
    }
    if(prefix == cUsbLow)
    {
      usbLow = val.toInt();
      Blynk.virtualWrite(pUsbLow, usbLow*1000);
    }
    if(prefix == cInverterOn)
    {
      inverterOn = val.toInt();
      Blynk.virtualWrite(pInverterOn, inverterOn*1000);
    }
    if(prefix == cInverterLow)
    {
      inverterLow = val.toInt();
      Blynk.virtualWrite(pInverterLow, inverterLow*1000);
    }
    if(prefix == cAudioOn)
    {
      audioOn = val.toInt();
      Blynk.virtualWrite(pAudioOn, audioOn*1000);
    }
    if(prefix == cFridgeLow)
    {
      audioLow = val.toInt();
      Blynk.virtualWrite(pAudioLow, audioLow*1000);
    }
    if(prefix == cRadioOn)
    {
      radioOn = val.toInt();
      Blynk.virtualWrite(pRadioOn, radioOn*1000);
    }
    if(prefix == cIgnitionOn)
    {
      ignitionOn = val.toInt();
      Blynk.virtualWrite(pIgnitionOn, ignitionOn*1000);
    }

    
    if(prefix == cRelay1State)
    {
      relay1State = val.toInt();
      Blynk.virtualWrite(pRelay1State, relay1State*1000);
    }
    if(prefix == cRelay2State)
    {
      relay2State = val.toInt();
      Blynk.virtualWrite(pRelay2State, relay2State*1000);
    }
    if(prefix == cRelay3State)
    {
      relay3State = val.toInt();
      Blynk.virtualWrite(pRelay3State, relay3State*1000);
    }
    if(prefix == cRelay4State)
    {
      relay4State = val.toInt();
      Blynk.virtualWrite(pRelay4State, relay4State*1000);
    }
    if(prefix == cRelay5State)
    {
      relay5State = val.toInt();
      Blynk.virtualWrite(pRelay5State, relay5State*1000);
    }
    if(prefix == cRelay6State)
    {
      relay6State = val.toInt();
      Blynk.virtualWrite(pRelay6State, relay6State*1000);
    }
    if(prefix == cRelay7State)
    {
      relay7State = val.toInt();
      Blynk.virtualWrite(pRelay7State, relay7State*1000);
    }
    if(prefix == cRelay8State)
    {
      relay8State = val.toInt();
      Blynk.virtualWrite(pRelay8State, relay8State*1000);
    }

    //----( Control )----
    if(prefix == cRefresh)
    {
      if(val == high) sendUpdate();
      if(val == low) updateRecived();
    }
    if(prefix == cRecieve)
    {
      if(val == high) recieve = 1;
      if(val == low)
      {
        recieve = 0;
      }
    }

    if(prefix == cAuxBatMode) auxBatMode = val.toInt();
    if(prefix == cAuxBatLimit) auxBatLimit = val.toFloat();
    if(prefix == cStartWarn) startWarn = val.toInt();
    if(prefix == cStartWarnLimit)  startWarnLimit = val.toFloat();
    if(prefix == cAuxWarn)  auxWarn = val.toInt();
    if(prefix == cAuxWarnLimit) auxWarnLimit = val.toFloat();
    if(prefix == cFridgeMode) fridgeMode = val.toInt();
    if(prefix == cFridgeLimit) fridgeLimit = val.toFloat();
    if(prefix == cFridgeWarn)  fridgeWarn = val.toInt();
    if(prefix == cFridgeTempLowerLimit) fridgeTempLowerLimit = val.toFloat();
    if(prefix == cFridgeTempUpperLimit) fridgeTempUpperLimit = val.toFloat();
    if(prefix == cUsbMode) usbMode = val.toInt();
    if(prefix == cUsbLimit)  usbLimit = val.toFloat();
    if(prefix == cInverterMode) inverterMode = val.toInt();
    if(prefix == cInverterLimit) inverterLimit = val.toFloat();
    if(prefix == cAudioMode) audioMode = val.toInt();
    if(prefix == cAudioLimit) audioLimit = val.toFloat();
}

//-----( ROM )-----
void saveRom()
{
  writeRomInt(rAuxBatMode, auxBatMode);
  writeRomDouble(rAuxBatLimit, auxBatLimit);
  writeRomInt(rStartWarn, startWarn);
  writeRomDouble(rStartWarnLimit, startWarnLimit);
  writeRomInt(rAuxWarn, auxWarn);
  writeRomDouble(rAuxWarnLimit, auxWarnLimit);
  writeRomInt(rFridgeMode, fridgeMode);
  writeRomDouble(rFridgeLimit, fridgeLimit);
  writeRomInt(rFridgeWarn, fridgeWarn);
  writeRomDouble(rFridgeTempLowerLimit, fridgeTempLowerLimit);
  writeRomDouble(rFridgeTempUpperLimit, fridgeTempUpperLimit);
  writeRomInt(rUSBMode, usbMode);
  writeRomDouble(rUSBLimit, usbLimit);
  writeRomInt(rInverterMode, inverterMode);
  writeRomDouble(rInverterLimit, inverterLimit);
  writeRomInt(rAudioMode, audioMode);
  writeRomDouble(rUSBLimit, audioLimit);
  
  Blynk.virtualWrite(pTerminal, "ROM saved" + String('\r'));
}
void updateRom()
{
  updateRomInt(rAuxBatMode, auxBatMode);
  updateRomDouble(rAuxBatLimit, auxBatLimit);
  updateRomInt(rStartWarn, startWarn);
  updateRomDouble(rStartWarnLimit, startWarnLimit);
  updateRomInt(rAuxWarn, auxWarn);
  updateRomDouble(rAuxWarnLimit, auxWarnLimit);
  updateRomInt(rFridgeMode, fridgeMode);
  updateRomDouble(rFridgeLimit, fridgeLimit);
  updateRomInt(rFridgeWarn, fridgeWarn);
  updateRomDouble(rFridgeTempLowerLimit, fridgeTempLowerLimit);
  updateRomDouble(rFridgeTempUpperLimit, fridgeTempUpperLimit);
  updateRomInt(rUSBMode, usbMode);
  updateRomDouble(rUSBLimit, usbLimit);
  updateRomInt(rInverterMode, inverterMode);
  updateRomDouble(rInverterLimit, inverterLimit);
  updateRomInt(rAudioMode, audioMode);
  updateRomDouble(rUSBLimit, audioLimit);

  Blynk.virtualWrite(pTerminal, "ROM updated" + String('\r'));
}
void writeRomInt(int startIndex, int value)
{
  EEPROM.write(startIndex, value);
}
void updateRomInt(int startIndex, int value)
{
  EEPROM.update(startIndex, value);
}
void writeRomDouble(int startIndex, double value)
{
  EEPROM.write(startIndex, doubleToChar(0, value));
  EEPROM.write(startIndex + 1, doubleToChar(1, value));
  EEPROM.write(startIndex + 2, doubleToChar(2, value));
  EEPROM.write(startIndex + 3, doubleToChar(3, value));
}
void updateRomDouble(int startIndex, double value)
{
  EEPROM.update(startIndex, doubleToChar(0, value));
  EEPROM.update(startIndex + 1, doubleToChar(1, value));
  EEPROM.update(startIndex + 2, doubleToChar(2, value));
  EEPROM.update(startIndex + 3, doubleToChar(3, value));
}
char doubleToChar(int index, double value)
{
  //converts to 1 decimal value
  if(value == 0)
  {
    if(index == 0) return '0';
    if(index == 1) return '0';
    if(index == 2) return '.';
    if(index == 3) return '0';
  }
  else if(String(value)[1] == '.')
  {
    if(index == 0) return '0';
    if(index == 1) return String(value)[0];
    if(index == 2) return '.';
    if(index == 3) return String(value)[2];
  }
  else if(String(value)[2] == '.')
  {
    if(index == 0) return String(value)[0];
    if(index == 1) return String(value)[1];
    if(index == 2) return '.';
    if(index == 3) return String(value)[3];
  }
}

void readRom()
{
  auxBatMode = readRomInt(rAuxBatMode);
  auxBatLimit = readRomDouble(rAuxBatLimit);
  startWarn = readRomInt(rStartWarn);
  startWarnLimit = readRomDouble(rStartWarnLimit);
  auxWarn = readRomInt(rAuxWarn);
  auxWarnLimit = readRomDouble(rAuxWarnLimit);
  fridgeMode = readRomInt(rFridgeMode);
  fridgeLimit = readRomDouble(rFridgeLimit);
  fridgeWarn = readRomDouble(rFridgeWarn);
  fridgeTempLowerLimit = readRomDouble(rFridgeTempLowerLimit);
  fridgeTempUpperLimit = readRomDouble(rFridgeTempUpperLimit);
  usbMode = readRomInt(rUSBMode);
  usbLimit = readRomDouble(rUSBLimit);
  inverterMode = readRomInt(rInverterMode);
  inverterLimit = readRomDouble(rInverterLimit);
  audioMode = readRomInt(rAudioMode);
  audioLimit = readRomDouble(rAudioLimit);
  
  Blynk.virtualWrite(pTerminal, "ROM read" + String('\r'));
}
int readRomInt(int startIndex)
{
  return EEPROM.read(startIndex);
}
double readRomDouble(int startIndex)
{
  return (String(char(EEPROM.read(startIndex))) + String(char(EEPROM.read(startIndex + 1))) + String(char(EEPROM.read(startIndex + 2))) + String(char(EEPROM.read(startIndex + 3)))).toFloat();
}


//-----( Blynk Interface )-----
void appUpdate()
{
  Blynk.virtualWrite(pAuxBatMode, auxBatMode);
  Blynk.virtualWrite(pAuxBatLimit, auxBatLimit*10);
  Blynk.virtualWrite(pStartWarn, startWarn);
  Blynk.virtualWrite(pStartWarnLimit, startWarnLimit*10);
  Blynk.virtualWrite(pAuxWarn, auxWarn);
  Blynk.virtualWrite(pAuxWarnLimit, auxWarnLimit*10);
  Blynk.virtualWrite(pFridgeMode, fridgeMode);
  Blynk.virtualWrite(pFridgeLimit, fridgeLimit*10);
  Blynk.virtualWrite(pFridgeWarn, fridgeWarn);
  Blynk.virtualWrite(pFridgeTempLowerLimit, (fridgeTempLowerLimit + 20)*4.25 );
  Blynk.virtualWrite(pFridgeTempUpperLimit, (fridgeTempUpperLimit + 20)*4.25 );
  Blynk.virtualWrite(pUsbMode, usbMode);
  Blynk.virtualWrite(pUsbLimit, usbLimit*10);
  Blynk.virtualWrite(pInverterMode, inverterMode);
  Blynk.virtualWrite(pInverterLimit, inverterLimit*10);
  Blynk.virtualWrite(pAudioMode, audioMode);
  Blynk.virtualWrite(pAudioLimit, audioLimit*10);

  Blynk.virtualWrite(pRelay1Forced, relay1Forced);
  Blynk.virtualWrite(pRelay2Forced, relay2Forced);
  Blynk.virtualWrite(pRelay3Forced, relay3Forced);
  Blynk.virtualWrite(pRelay4Forced, relay4Forced);
  Blynk.virtualWrite(pRelay5Forced, relay5Forced);
  Blynk.virtualWrite(pRelay6Forced, relay6Forced);
  Blynk.virtualWrite(pRelay7Forced, relay7Forced);
  Blynk.virtualWrite(pRelay8Forced, relay8Forced);

  Blynk.virtualWrite(pRelay1ForcedState, relay1ForcedState);
  Blynk.virtualWrite(pRelay2ForcedState, relay2ForcedState);
  Blynk.virtualWrite(pRelay3ForcedState, relay3ForcedState);
  Blynk.virtualWrite(pRelay4ForcedState, relay4ForcedState);
  Blynk.virtualWrite(pRelay5ForcedState, relay5ForcedState);
  Blynk.virtualWrite(pRelay6ForcedState, relay6ForcedState);
  Blynk.virtualWrite(pRelay7ForcedState, relay7ForcedState);
  Blynk.virtualWrite(pRelay8ForcedState, relay8ForcedState);

  Blynk.virtualWrite(pTerminal, "App updated" + String('\r'));
}

//-----( Blynk Virtual Pin Inputs )-----
BLYNK_WRITE(pAuxBatMode)
{
  auxBatMode = param.asInt();
  Blynk.virtualWrite(pTerminal, "Aux Battery Connection Mode: " + String(auxBatMode) + String('\r'));
  sendCom(idRelayBox1, cAuxBatMode, String(auxBatMode));
}
BLYNK_WRITE(pAuxBatLimit)
{
  auxBatLimit = param.asDouble() / 10;
  Blynk.virtualWrite(pTerminal, "Aux Battery Connection Limit: " + String(auxBatLimit) + String('\r'));
  sendCom(idRelayBox1, cAuxBatLimit, String(auxBatLimit));
}
BLYNK_WRITE(pStartWarn)
{
  startWarn = param.asInt();
  if(startWarn) Blynk.virtualWrite(pTerminal, "Start Battery Warning On" + String('\r'));
  else Blynk.virtualWrite(pTerminal, "Start Battery Warning Off" + String('\r'));
  sendCom(idRelayBox1, cStartWarn, String(startWarn));
}
BLYNK_WRITE(pStartWarnLimit)
{
  startWarnLimit = param.asDouble() / 10;
  Blynk.virtualWrite(pTerminal, "Starter Battery Warning Limit: " + String(startWarnLimit) + String('\r'));
  sendCom(idRelayBox1, cStartWarnLimit, String(startWarnLimit));
}
BLYNK_WRITE(pAuxWarn)
{
  auxWarn = param.asInt();
  if(auxWarn) Blynk.virtualWrite(pTerminal, "Aux Battery Warning On" + String('\r'));
  else Blynk.virtualWrite(pTerminal, "Aux Battery Warning Off" + String('\r'));
  sendCom(idRelayBox1, cAuxWarn, String(auxWarn));
}
BLYNK_WRITE(pAuxWarnLimit)
{
  auxWarnLimit = param.asDouble() / 10;
  Blynk.virtualWrite(pTerminal, "Aux Battery Warning Limit: " + String(auxWarnLimit) + String('\r'));
  sendCom(idRelayBox1, cAuxWarnLimit, String(auxWarnLimit));
}
BLYNK_WRITE(pFridgeMode)
{
  fridgeMode = param.asInt();
  Blynk.virtualWrite(pTerminal, "Fridge Control Mode: " + String(fridgeMode) + String('\r'));
  sendCom(idRelayBox1, cFridgeMode, String(fridgeMode));
}
BLYNK_WRITE(pFridgeLimit)
{
  fridgeLimit = param.asDouble() / 10;
  Blynk.virtualWrite(pTerminal, "Fridge Control Limit: " + String(fridgeLimit) + String('\r'));
  sendCom(idRelayBox1, cFridgeLimit, String(fridgeLimit));
}
BLYNK_WRITE(pFridgeWarn)
{
  fridgeWarn = param.asInt();
  if(fridgeWarn) Blynk.virtualWrite(pTerminal, "Fridge Temperature Warning On" + String('\r'));
  else Blynk.virtualWrite(pTerminal, "Fridge Temperature Warning Off" + String('\r'));
  sendCom(idRelayBox1, cFridgeWarn, String(fridgeWarn));
}
BLYNK_WRITE(pFridgeTempLowerLimit)
{
  fridgeTempLowerLimit = param.asDouble()/4.25 - 20;
  Blynk.virtualWrite(pTerminal, "Fridge Temp Lower Limit: " + String(fridgeTempLowerLimit) + String('\r'));
  sendCom(idRelayBox1, cFridgeTempLowerLimit, String(fridgeTempLowerLimit));
}
BLYNK_WRITE(pFridgeTempUpperLimit)
{
  fridgeTempUpperLimit = param.asDouble()/4.25 - 20;
  Blynk.virtualWrite(pTerminal, "Fridge Temp Upper Limit: " + String(fridgeTempUpperLimit) + String('\r'));
  sendCom(idRelayBox1, cFridgeTempUpperLimit, String(fridgeTempUpperLimit));
}
BLYNK_WRITE(pUsbMode)
{
  usbMode = param.asInt();
  Blynk.virtualWrite(pTerminal, "USB Control Mode: " + String(usbMode) + String('\r'));
  sendCom(idRelayBox1, cUsbMode, String(usbMode));
}
BLYNK_WRITE(pUsbLimit)
{
  usbLimit = param.asDouble() / 10;
  Blynk.virtualWrite(pTerminal, "USB Control Limit: " + String(usbLimit) + String('\r'));
  sendCom(idRelayBox1, cUsbLimit, String(usbLimit));
}
BLYNK_WRITE(pInverterMode)
{
  inverterMode = param.asInt();
  Blynk.virtualWrite(pTerminal, "Inverter Control Mode: " + String(inverterMode) + String('\r'));
  sendCom(idRelayBox1, cInverterMode, String(inverterMode));
}
BLYNK_WRITE(pInverterLimit)
{
  inverterLimit = param.asDouble() / 10;
  Blynk.virtualWrite(pTerminal, "Inverter Control Limit: " + String(inverterLimit) + String('\r'));
  sendCom(idRelayBox1, cInverterLimit, String(inverterLimit));
}
BLYNK_WRITE(pAudioMode)
{
  audioMode = param.asInt();
  Blynk.virtualWrite(pTerminal, "Audio Control Mode: " + String(audioMode) + String('\r'));
  sendCom(idRelayBox1, cAudioMode, String(audioMode));
}
BLYNK_WRITE(pAudioLimit)
{
  audioLimit = param.asDouble() / 10;
  Blynk.virtualWrite(pTerminal, "Audio Control Limit: " + String(audioLimit) + String('\r'));
  sendCom(idRelayBox1, cAudioLimit, String(audioLimit));
}
BLYNK_WRITE(pReqUpdate)
{
  if(param.asInt())
  {
    if(!reqUpdatePressed)
    {
      Blynk.virtualWrite(pTerminal, "Request update pressed" + String('\r'));
      requestUpdate();
      reqUpdatePressed = true;
    }
  }
  else  reqUpdatePressed = false;
}
BLYNK_WRITE(pSendUpdate)
{
  if(param.asInt())
  {
    if(!sndUpdatePressed)
    {
      Blynk.virtualWrite(pTerminal, "Send update pressed" + String('\r'));
      sendUpdate();
      updateRom();
      sndUpdatePressed = true;
    }
  }
  else sndUpdatePressed = false;
}
BLYNK_WRITE(pAppRefresh)
{
  if(param.asInt())
  {
    if(!appRefreshPressed)
    {
      Blynk.virtualWrite(pTerminal, "Refresh App pressed" + String('\r'));
      appUpdate();
      appRefreshPressed = true;
    }
  }
  else  appRefreshPressed = false;
}
BLYNK_WRITE(pRestoreLow)
{
  if(param.asInt())
  {
    if(!restoreLowPressed)
    {
      Blynk.virtualWrite(pTerminal, "Low restore pressed" + String('\r'));
      sendCom(idRelayBox1, cRestoreLow, high);
      restoreLowPressed = true;
    }
  }
  else  restoreLowPressed = false;
}
BLYNK_WRITE(pSaveRom)
{
  if(param.asInt())
  {
    if(!saveRomPressed) 
    {
      Blynk.virtualWrite(pTerminal, "ROM save requested" + String('\r'));
      saveRom();
      saveRomPressed = true;
    }
  }
  else saveRomPressed = false;
}
BLYNK_WRITE(pReadRom)
{
  if(param.asInt())
  {
    if(!readRomPressed) 
    {
      Blynk.virtualWrite(pTerminal, "ROM read requested" + String('\r'));
      readRom();
      appUpdate();
      sendUpdate();
      readRomPressed = true;
    }
  }
  else readRomPressed = false;
}


//------ force relays
BLYNK_WRITE(pRelay1Forced)
{
  relay1Forced = param.asInt();
  sendCom(idRelayBox1, cRelay1Forced, String(relay1Forced));
}
BLYNK_WRITE(pRelay2Forced)
{
  relay2Forced = param.asInt();
  sendCom(idRelayBox1, cRelay2Forced, String(relay2Forced));
}
BLYNK_WRITE(pRelay3Forced)
{
  relay3Forced = param.asInt();
  sendCom(idRelayBox1, cRelay3Forced, String(relay3Forced));
}
BLYNK_WRITE(pRelay4Forced)
{
  relay4Forced = param.asInt();
  sendCom(idRelayBox1, cRelay4Forced, String(relay4Forced));
}
BLYNK_WRITE(pRelay5Forced)
{
  relay5Forced = param.asInt();
  sendCom(idRelayBox1, cRelay5Forced, String(relay5Forced));
}
BLYNK_WRITE(pRelay6Forced)
{
  relay6Forced = param.asInt();
  sendCom(idRelayBox1, cRelay6Forced, String(relay6Forced));
}
BLYNK_WRITE(pRelay7Forced)
{
  relay7Forced = param.asInt();
  sendCom(idRelayBox1, cRelay7Forced, String(relay7Forced));
}
BLYNK_WRITE(pRelay8Forced)
{
  relay8Forced = param.asInt();
  sendCom(idRelayBox1, cRelay8Forced, String(relay8Forced));
}

BLYNK_WRITE(pRelay1ForcedState)
{
  relay1ForcedState = param.asInt();
  sendCom(idRelayBox1, cRelay1ForcedState, String(relay1ForcedState));
}
BLYNK_WRITE(pRelay2ForcedState)
{
  relay2ForcedState = param.asInt();
  sendCom(idRelayBox1, cRelay2ForcedState, String(relay2ForcedState));
}
BLYNK_WRITE(pRelay3ForcedState)
{
  relay3ForcedState = param.asInt();
  sendCom(idRelayBox1, cRelay3ForcedState, String(relay3ForcedState));
}
BLYNK_WRITE(pRelay4ForcedState)
{
  relay4ForcedState = param.asInt();
  sendCom(idRelayBox1, cRelay4ForcedState, String(relay4ForcedState));
}
BLYNK_WRITE(pRelay5ForcedState)
{
  relay5ForcedState = param.asInt();
  sendCom(idRelayBox1, cRelay5ForcedState, String(relay5ForcedState));
}
BLYNK_WRITE(pRelay6ForcedState)
{
  relay6ForcedState = param.asInt();
  sendCom(idRelayBox1, cRelay6ForcedState, String(relay6ForcedState));
}
BLYNK_WRITE(pRelay7ForcedState)
{
  relay7ForcedState = param.asInt();
  sendCom(idRelayBox1, cRelay7ForcedState, String(relay7ForcedState));
}
BLYNK_WRITE(pRelay8ForcedState)
{
  relay8ForcedState = param.asInt();
  sendCom(idRelayBox1, cRelay8ForcedState, String(relay8ForcedState));
}

Anyone have an idea what the problem might be?

Thanks in advance.

How long is a piece of string?

Explain in detail what you mean by this?

Interesting. Before you built the project did you do any testing of a basic BLE sketch without connection to the COM? That’s where I would check and then you know if your code is the problem or your system.

The time it takes varies. Usually I let it run over night or when I’m at work. It has never passed 8 hours without stop responding.

With stressing a button I mean that, in the Blynk app, I repeatedly press a button, triggering the app and device to send updates very frequently.

Just tried removing all the code, keeping only the Blynk setup and the Blynk.run() and blePeripheral.poll() in the loop. Now, 12 hours later it actually is still alive. Confirmed the connection with pin 13.

Not bad for Bluetooth.

Not a good practise, add confirmation timeouts if you think users are going to treat your app like a game of Space Invaders.

So Bluetooth does work and you need to debug your code. Use BLYNK_DEBUG and Serial.print() calls to try to identify the problem. Also try adding bits of your code to the working template, test, add a bit more, test etc.