assertion "heap != NULL && "free() target pointer is outside heap areas" in workd Bluetooth BLE

Board

Chip is ESP32-D0WD (revision 1) Features: WiFi, BT, Dual Core, 240MHz, VRef calibration in efuse, Coding Scheme None

Device Description

other

Hardware Configuration

GPIO 18&& 19 in I2C

Version

other

IDE Name

Arduino IDE

Operating System

Windows 10

Flash frequency

PSRAM enabled

Upload speed

115200

Description

in connect BLE assertion "heap != NULL && "free() target pointer is outside heap areas"

Sketch

#include <Wire.h>
#include "SparkFunHTU21D.h"
#include "MAX30105.h"           // Библиотека пульсометра

#include <GyverOLED.h>          // Библиотека экрана
#include <Rtc_Pcf8563.h>        // Библиотека часов реального времени
#include "MPU6050.h"            // Библиотека гироскоп
#include "heartRate.h"
#include "spo2_algorithm.h"  
#include <FS.h>                // Доступ к файловой системе
#include <SPIFFS.h>

// bluetooth
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>
//----------------bitmap--------------------------
#include "Still.h"
#include "batt.h"
#include "Bluetooth.h"
#include "daw_x.h"
#include "heart.h"
#include "mist_two.h"
#include "vibr.h"

HTU21D myHumidity;
GyverOLED<SSH1106_128x64> oled;
Rtc_Pcf8563 rtc;
File Data_array_file;
SemaphoreHandle_t btnSemaphore;
MAX30105 PARTICLE_SENSOR;
MPU6050 mpu;
BLEServer *pServer = NULL;

BLECharacteristic *pTxCharacteristic;
BLECharacteristic *pTxTimeCharacteristic;
BLECharacteristic *pTxminTempParCharacteristic;

bool deviceConnected = false;
bool oldDeviceConnected = false;

const int RES = 27;
/* -------clock---------=*/
String hm,dm;
String Time;
byte century =0;
byte day = 15;
byte week = 4;
byte month=7;
byte year = 21;
byte hour = 0;
byte minute = 0;
byte second = 0;
bool flagTime = 0;

// MPU6050
int16_t ax, ay, az;
int16_t gx, gy, gz;
long ACC = 0;
long GYR = 0;
long maxACC = 0;
long maxGYR = 0;

byte flagDisplay = 0;
unsigned long previousMillis = 0;
unsigned long interval = 25000;

String SizeF;
String vrem;

float previousTemperature = -100.0;
float temperature = 0;
float CPU = 0;
float humidity= 0;

uint32_t irBuffer[100];                             //  32-битный массив данных от сенсора со значениями от ИК-светодиода
uint32_t redBuffer[100];                            //  32-битный массив данных от сенсора со значениями от красного светодиода
int32_t bufferLength;                               //  длина буфера данных
int32_t spo2;                                       //  значение SpO2 (насыщенности крови кислородом)
//int8_t  validSPO2;                                  //  флаг валидности значений сенсора по SpO2
int32_t heartRate = 0;                                  //  значение ЧСС
//int8_t  validHeartRate;                             //  флаг валидности значений сенсора по ЧСС
const char * Data_arrayPath = "/data.txt";
String VR  ;
int temper ;
byte VL,pulse, metka  ;
uint32_t currentMillisAcc = 0 ;
int t = 100;
const long time_press = 1000;
unsigned long Button2_previousMillis = 0; 
int bounceTime_B2 = 10;                             // задержка для подавления дребезга
int doubleTime_B2 = 500;                            // время, в течение которого нажатия можно считать двойным
int i = 0;
long onTime_B2 = 0;                                 // переменная обработки временного интервала
long lastSwitchTime_B2 = 0;                         // переменная времени предыдущего переключения состояния
long onTime_B3 = 0;                                 // переменная обработки временного интервала
int bounceTime_B3 = 10;                             // задержка для подавления дребезга
int holdTime_B3 = 500;                              // время, в течение которого нажатие можно считать удержанием кнопки
int doubleTime_B3 = 500;                            // время, в течение которого нажатия можно считать двойным
int holdTimeSum_B3 = 0;  
int j = 0;
long lastSwitchTime_B3 = 0;                         // переменная времени предыдущего переключения состояния

int max_heartRate = 150;
int max_time = 150000;
int max_temp = 120;
int deltaTemp = 20;
int int_Par = 15000;
int minTempPar = 80;
byte disp = 2;
uint32_t intervalWriteFlash = 600000;
uint32_t currentMilliisFLash = 0;

/*    flags    */
byte flagACC=0;                                   //  флаг срабатывания акселерометра
byte otlDisp = 0;                                 //  флаг обновления дисплея
int8_t  validSPO2;                                  //  флаг валидности значений сенсора по SpO2
int8_t  validHeartRate;                             //  флаг валидности значений сенсора по ЧСС
bool action_Button1 = LOW;
bool state_BT = LOW;
bool Button2_pressed = LOW;
bool Button2_released = LOW; 
bool double_press = LOW;            
boolean lastReading = false;                      // флаг предыдущего состояния кнопки
boolean button_2_Single = false;                  // флаг состояния "краткое нажатие"
boolean button_2_Multi = false;                   // флаг состояния "двойное нажатие"
boolean last_Button2_pressed = false;             // флаг предыдущего состояния кнопки
boolean last_Button3_pressed = false;             // флаг предыдущего состояния кнопки
boolean button_3_Single = false;                  // флаг состояния "краткое нажатие"
boolean button_3_Multi = false;                   // флаг состояния "двойное нажатие"
boolean button_3_Hold = false;                    // флаг состояния "долгое нажатие"
bool state_BT3 = LOW;
bool action_Button4 = LOW;
bool Button3_pressed = LOW;
bool Button3_released = LOW;
bool flagPar = 0;
bool flagUpdatePar = 0;                           //флаг обновления значка парилки
bool flagButt2 = 0;                               //флаг для отображения параметров
bool flageState = 0;                              //флаг текущего измерения
bool flageSinxr = 0;
bool flagConn = 0;

#define INTERVAL_ACC 300000
#define TM_BUTTON 100                            // Минимальный таймаут между событиями нажатия кнопки
#define PIN_BUTTON1 34
#define PIN_BUTTON2 27
#define PIN_BUTTON3 12
#define PIN_BUTTON4 19
#define PIN_INPUT 35
#define PIN_OUTPUT 11

#define SERVICE_UUID                 "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHARACTERISTIC_TIME_RX_UUID  "beb5483e-36e1-4688-b7f5-ea07361b26a8"
#define CHARACTERISTIC_TP_RX_UUID  "acd787aa-08f2-4e4f-9078-b97194585906"

#define CHARACTERISTIC_TIME_TX_UUID  "60171725-f8a0-41b9-809d-c2044db71d8f"
#define CHARACTERISTIC_TEMP_TX_UUID  "bcdea365-b767-48a9-aa06-57c19859c502"
#define CHARACTERISTIC_TP_TX_UUID  "669115d4-2f37-4678-8012-fe22376b8a49"

extern "C" {
uint8_t temprature_sens_read();
}

class MyServerCallbacks: public BLEServerCallbacks {
    void onConnect(BLEServer* pServer) {
      deviceConnected = true;
    };

    void onDisconnect(BLEServer* pServer) {
      deviceConnected = false;
    }
};

class MyCallbacks: public BLECharacteristicCallbacks {
    void onWrite(BLECharacteristic *pCharacteristic) {
      std::string rxValue = pCharacteristic->getValue();

      if (rxValue.length() > 0) {
        Serial.println("*********");
        Serial.print("Received Value: ");
        for (int i = 0; i < rxValue.length(); i++)
          Serial.print(rxValue[i]);

        Serial.println();
        Serial.println("*********");
        Serial.println(rxValue.length());
        Serial.println("*********");
        if (rxValue.length() == 14){
          Time = rxValue.c_str();
          day = Time.substring(0,2).toInt();
          week = Time[2] - '0';
          month = Time.substring(3,5).toInt();
          century = Time[5] - '0';
          year = Time.substring(6,8).toInt();
          hour = Time.substring(8,10).toInt();
          minute = Time.substring(10,12).toInt();
          second = Time.substring(12,14).toInt();
          Serial.print("day: ");
          Serial.println(day);
          Serial.println("Week: ");
          Serial.println(week);
          flagTime = 1;
        }
        if (flagTime == 1)
        {
          rtc.setDate(day, week, month, century, year);
          rtc.setTime(hour, minute, second);
          flagTime =0;
        }
      }
    }
};

class MyCallbacksTempPar: public BLECharacteristicCallbacks {
   void onWrite(BLECharacteristic *pCharacteristic) {
     std::string rx1Value = pCharacteristic->getValue();

//     if (rx1Value.length() > 0) {
//       Serial.println("*********");
//       Serial.print("Received Value: ");
//       for (int i = 0; i < rx1Value.length(); i++)
//         Serial.print(rx1Value[i]);
//
//       Serial.println();
//       Serial.println("*********");
//       Serial.println(rx1Value.length());
//       Serial.println("*********");
//       vrem =rx1Value.c_str();
//       minTempPar =vrem.toInt();

//     }
   }
};
// Display 128X64 

int NamePict[8][6] = {
                     {104, 0, 23, 10,BITMAP_NORMAL, BUF_REPLACE},              // battery      ind = 0     
                     {90, 0, 12, 10,BITMAP_NORMAL, BUF_REPLACE},                // heart       ind = 1
                     {70, 0, 12, 10,BITMAP_NORMAL, BUF_REPLACE},                // bt       ind = 2
                     {45, 0, 23, 15, BITMAP_NORMAL, BUF_REPLACE},               // Mist       ind = 3
                     {30, 0, 12, 10,BITMAP_NORMAL, BUF_REPLACE},                // bt        ind = 4
                     {10,0, 12, 10,BITMAP_NORMAL, BUF_REPLACE},                 // Vibrstion ind  =5
                     {48,20,32,32, BITMAP_NORMAL, BUF_REPLACE},                  // Still  = 6
                     {20,30,107,43, BITMAP_NORMAL, BUF_REPLACE}                   // Text = 7
                     };   

void setup() {
  Serial.begin(115200);
  initBLE();
  oled.init();
  oled.clear();
  drawPictogr(batt_fifty_23x10,0);
  drawPictogr(heart_on_12x10,1);
  drawPictogr(Daw_12x10,2);
  drawPictogr(mist_two_23x15,3);
  drawPictogr(Bluetooth_12x10,4);
  drawPictogr(Vibr_12x10,5);
  drawPictogr(Still_one_32x32,6);
  delay(250);
  drawPictogr(Still_two_32x32,6);

  // initializing the gyroscope
  mpu.initialize();
  mpu.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);
    for (int i = 0; i < 30; i++) 
      {
        mpu.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);
        ACC = abs(ax) + abs(ay) + abs(az); GYR = abs(gx) + abs(gy) + abs(gz);
        if (ACC > maxACC) maxACC = ACC;
        if (GYR > maxGYR) maxGYR = GYR;
      }
  delay(250);
  drawPictogr(Still_three_32x32,6);
  delay(250);
  drawPictogr(Still_four_32x32,6);
  // initializing HTU21D
  myHumidity.begin();
  delay(250);
  drawPictogr(Still_fie_32x32,6);
  delay(250);
  drawPictogr(Still_sixe_32x32,6);
  /*----------Initializate clock---------*/
  rtc.initClock();
  rtc.setDate(day, week, month, century, year);
  rtc.setTime(hour, minute, second);
  dm = rtc.formatDate();
  hm = rtc.formatTime(RTCC_TIME_HM);
  delay(250);
  drawPictogr(Still_seven_32x32,6);
  delay(250);
  drawPictogr(Still_eight_32x32 ,6);
  // initializate MAX30105
  if (! PARTICLE_SENSOR.begin(Wire, I2C_SPEED_FAST))                  //  We initiate work with the module. If initialization failed, то
      {                    
        Serial.println("MAX30105 was not found");                       //  hen we output a message about this to the serial port monitor
        while (1);                                                      //  and stop further execution of the sketch
       } 
    byte ledBrightness = 0x50; //Options: 0=Off to 255=50mA
    byte sampleAverage = 1; //Options: 1, 2, 4, 8, 16, 32
    byte ledMode = 2; //Options: 1 = Red only, 2 = Red + IR, 3 = Red + IR + Green
    //Options: 1 = IR only, 2 = Red + IR on MH-ET LIVE MAX30102 board
    int sampleRate = 100; //Options: 50, 100, 200, 400, 800, 1000, 1600, 3200
    int pulseWidth = 411; //Options: 69, 118, 215, 411
    int adcRange = 8192; //Options: 2048, 4096, 8192, 16384
    // Set up the wanted parameters
    PARTICLE_SENSOR.setup(ledBrightness, sampleAverage, ledMode, sampleRate, pulseWidth, adcRange); //Configure sensor with these settings

  delay(250);
  drawPictogr(Still_nine_32x32 ,6);
  delay(250);
  drawPictogr(Still_ten_32x32,6);
  // initializate bittom and flash
  pinMode (PIN_BUTTON1, INPUT);
  pinMode (PIN_BUTTON2, INPUT);
  pinMode (PIN_BUTTON3, INPUT);
  pinMode (PIN_BUTTON4, INPUT);
   pinMode(PIN_OUTPUT, OUTPUT);
  xTaskCreateUniversal(taskButtons, "buttons", 4096, NULL, 2, NULL,1);                     // The task of working with the button is started 
  //ReadFILE_FLASH ();
  delay(250);
  drawPictogr(Still_eleven_32x32 ,6);
  delay(250);
  drawPictogr(Still_twelve_32x32,6);
  delay(250);
  oled.clear();
}

void loop() {
  humidity = myHumidity.readHumidity();
  temperature = myHumidity.readTemperature();
  CPU = (temprature_sens_read() - 32) / 1.8;
  unsigned long currentMillis = millis();

  if (deviceConnected) {
    String val = dm +" "+ hm;
    unsigned char* buf = new unsigned char[20];

    val.getBytes(buf, 20, 0);
    const char *str2 = (const char*)buf;
    pTxCharacteristic->setValue(str2);
    pTxCharacteristic->notify();

    char x[1];                                                   //
      dtostrf(temperature, 5/*Полная_длина_строки*/, 1/*Количество_символов_после_запятой*/,x);
    pTxTimeCharacteristic ->setValue(x);
    pTxTimeCharacteristic ->notify();

  char ax[1];                                                   //
//    dtostrf(minTempPar, 5/*Полная_длина_строки*/,1/*Количество_символов_после_запятой*/,ax);
   sprintf(ax, "%d", minTempPar);
   pTxminTempParCharacteristic ->setValue(ax);
   pTxminTempParCharacteristic ->notify();

        delay(10); // bluetooth stack will go into congestion, if too many packets are sent
    }

    // disconnecting
  if (!deviceConnected && oldDeviceConnected) {
    delay(500); // give the bluetooth stack the chance to get things ready
    pServer->startAdvertising(); // restart advertising
    Serial.println("start advertising");
    oldDeviceConnected = deviceConnected;
  }
    // connecting
  if (deviceConnected && !oldDeviceConnected) {
        // do stuff here on connecting
    oldDeviceConnected = deviceConnected;
  }

  //currentMillis = millis();
  mpu.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);
  acseler();

  if (( millis() - currentMilliisFLash > intervalWriteFlash) and (flagPar == 1))
      {
        currentMilliisFLash = millis();
        //ADDin_FLASH (dm+hm, int(temperature), byte(humidity), byte(heartRate),metka);
        metka = 0;

      }
    if ( flagPar == 1 and flagUpdatePar == 0) 
      {
         drawPictogr(mist_two_23x15, 2);
         flagUpdatePar = 1;
         interval = 10000;
      }
    else
      {
         if (flagPar == 0 and flagUpdatePar == 1)
          {
            drawPictogr(mist_two_23x15, 2);
            flagUpdatePar = 0;
            interval = 30000;
          }
      }
    if (flagACC == 1)
      {
        otlDisp = 0;
        oled.setPower(1);
        printTest(temperature, humidity);
        currentMilliisFLash = millis();
        if (currentMillis - previousMillis >= interval) 
          {
//              mean_hrb();
              humidity = myHumidity.readHumidity();
              previousTemperature = temperature;
              temperature =myHumidity.readTemperature();
              dm = rtc.formatDate();
              hm = rtc.formatTime(RTCC_TIME_HM);
           }
        if (heartRate > 0 )
          {
            disp = 3;
          }
        else
          {
            disp = 2;
          }

        if ((abs(temperature -previousTemperature) > deltaTemp) and (temperature > minTempPar) )
            {
              flagPar= 1;
            }
        else 
          {
            if (temperature < minTempPar )  flagPar = 0;
          }

        //printTemperatureToSerial(); 
        if (currentMillis - previousMillis >= interval) 
          {
            if (flagPar == 1 and flagButt2 == 0)//
              {
                 flagDisplay++;
                 if (flagDisplay > disp) flagDisplay = 0;
                 printTest(temperature, humidity);
              }
            else
              {
                // flagDisplay++;
                //  if (flagDisplay > disp) flagDisplay = 0;
                // previousMillis = currentMillis;
                printTest(temperature, humidity);
              }
          }
      }
     else
      {
        if (otlDisp ==0) 
          {
            // drawStill(clear_display, sizeof(clear_display));
            otlDisp = 1;
          }
       }
    //  Button 1  processing
if (action_Button1)
  {
    if (state_BT == LOW)
       {
         //drawPictogr(vibr, 3);
         //Size_and_ReadFILE_FLASH ();               //ВРЕМЕННО ДЛЯ ПРОВЕРКИ ЧТЕНИЯ С FLASH  
         //Serial.println(SizeF);
         flagDisplay++;
         if (flagDisplay > disp) flagDisplay = 0;
         printTest(temperature, humidity);

       }   
    if  (state_BT == HIGH)
       {
         //drawPictogr(vibr_off, 3);
       }   
    state_BT = !state_BT;
    action_Button1 = LOW;
  }
if (Button2_released)
  {
    if (double_press == HIGH)
      {
       //Serial.println("Double 1");                       // автоматическое отображение параметров в цикле
       flagButt2 = 0;
       Button2_released = LOW;
       double_press = LOW;
      }

  }
else if (Button2_pressed && !last_Button2_pressed)
  {
    Button2_released = LOW;
    double_press = LOW;
    onTime_B2 = millis();
  }
if (!Button2_pressed && last_Button2_pressed)
  {
    Button2_released = LOW;
    double_press = LOW;
    if (((millis() - onTime_B2) > bounceTime_B2))
      {
        if ((millis() - lastSwitchTime_B2) >= doubleTime_B2)
          {
           lastSwitchTime_B2 = millis();
           button_2_Single = true;
           i=1;
          } 
        else 
          {
           i++;
           lastSwitchTime_B2 = millis();
           button_2_Single = false;
           button_2_Multi = true;
          }
     }
  }
last_Button2_pressed = Button2_pressed; 

if (button_2_Single && (millis() - lastSwitchTime_B2) > doubleTime_B2)
   {
    isButton2Single();
   }
if (button_2_Multi && (millis() - lastSwitchTime_B2) > doubleTime_B2)
   {
    isButton2Multi(i);
   }

//  Button 3  processing  
if (Button3_pressed && !last_Button3_pressed)
  {
   // Button3_released = LOW;
   // Button3_pressed = LOW;
    onTime_B3 = millis();
  }
if (Button3_pressed && last_Button3_pressed)         //анализ долгого нажатия
  {
   // Button3_released = LOW;
    //Button3_pressed = LOW;
    if ((millis() - onTime_B3) > holdTime_B3)
      {
       holdTimeSum_B3 = (millis() - onTime_B3);
       button_3_Hold = true;
      }
  }
if (!Button3_pressed && last_Button3_pressed)
  {
   //Button3_released = LOW;
   //Button3_pressed = LOW;
   if (((millis() - onTime_B3) > bounceTime_B3) && !button_3_Hold)
     {
      if ((millis() - lastSwitchTime_B3) >= doubleTime_B3)
        {
         lastSwitchTime_B3 = millis();
         button_3_Single = true;
         j=1;
        } 
      else 
        {
         j++;
         lastSwitchTime_B3 = millis();
         button_3_Single = false;
         button_3_Multi = true;
        }
     }
     if (button_3_Hold)
       {
        isButton_3_Hold( holdTimeSum_B3 );
       }
  }
last_Button3_pressed = Button3_pressed;

if (button_3_Single && (millis() - lastSwitchTime_B3) > doubleTime_B3)
  {
    isButton_3_Single();
  }
if (button_3_Multi && (millis() - lastSwitchTime_B3) > doubleTime_B3)
  {
    isButton_3_Multi(i);
  }

//  Button 4  processing
if (action_Button4)
  {
    isButton_4();
  }
}

void isButton2Single()                    // processing functions of the second button
   {                                      //1 press
      button_2_Multi = false;
      button_2_Single = false;
      Serial.println(2);
     //Write_FLASH (VR, temper, VL, pulse, metka);           // ВРЕМЕННО ДЛЯ ПРОВЕРКИ FLASH
     flagButt2 = 1;
     if (flagDisplay > disp) flagDisplay = 0;
     printTest(temperature, humidity);
     flagDisplay++;
   }

void isButton2Multi( int count )          // processing functions of the second button
   {                                      //2 press
      button_2_Single = false;
      button_2_Multi = false;
        if (count == 2)
          {
            Serial.println("Double 2"); 
            flagButt2 = 0;
          }
   }

void isButton_3_Single()                  //processing functions of the third button
  {
      button_3_Multi = false;
      button_3_Single = false;
      Serial.println("Single B3");
      //Erase_FLASH ();                    //ВРЕМЕННО ПРОВЕРКА СТИРАНИЯ FLASH
      metka = 1;
      //drawPictogr(daw, 5);
  }
void isButton_3_Multi( int count_B3 )     //processing functions of the third button
  {
      button_3_Single = false;
      button_3_Multi = false;
      if (count_B3 == 2)
        {
          Serial.println("Double B3");
        }
  }

void isButton_3_Hold( int count_B3 )      //processing functions of the third button
  {
      button_3_Hold = false;
      button_3_Multi = false;
      Button3_released = LOW;
      if (state_BT3 == LOW)
        {
          //drawPictogr(bt, 4);
        }   
       if (state_BT3 == HIGH)
        {
          //drawPictogr(bt_off, 4);
        }   
      state_BT3 = !state_BT3;
      Serial.println("Hold B3");
  }

  void isButton_4()                     //processing functions of the fourth button
  {
    Serial.println("Bad Value");
    action_Button4 = LOW;
    //ADDin_FLASH (VR, temper, VL, pulse, metka);                        //ВРЕМЕННО ДЛЯ ПРОВЕРКИ ДОБАВКИ FLASH 
  }

void printTest(const float& t,const float& hu ) {
  unsigned int x = NamePict[7][0];
  unsigned int y = NamePict[7][1];
  unsigned int h = NamePict[7][2];
  unsigned int w = NamePict[7][3];
  oled.setScale(2); 
  //oled.drawBitmap(x,y,Pictogr,h,w,  NamePict[ind][4],  NamePict[ind][5]);
  oled.update(25,20,127,60);
  oled.setCursorXY( x, y);
  switch (flagDisplay)
      {
        case 0:
          {

            oled.print(hm);
            oled.update();
            break;
          }
        case 1:
          {
            char data[] = "Temp: ";
            oled.print(t);
            oled.println(" C");
            oled.update();
            break;
          }
        case 2:
          {
            char data[] = "Humi: ";
            //oled.print(data);
            oled.print(hu);
            oled.println(" %");
            oled.update();
            break;
          }
        case 3:
          {
            String strbeatAvg = String(heartRate,0);
            //oled.print("AVG= ");
            oled.println(strbeatAvg);
            oled.update();
            break;
          }
      }
 }

void drawPictogr(const unsigned char *Pictogr, unsigned int ind)
{
    unsigned int x = NamePict[ind][0];
    unsigned int y = NamePict[ind][1];
    unsigned int h = NamePict[ind][2];
    unsigned int w = NamePict[ind][3];
    oled.drawBitmap(x,y,Pictogr,h,w,  NamePict[ind][4],  NamePict[ind][5]);
    oled.update();

}

void IRAM_ATTR ISR_btn()
  {
     xSemaphoreGiveFromISR( btnSemaphore, NULL );        // Прерывание по кнопке, отпускаем семафор
  }

void taskButtons( void *pvParameters )
  {
    bool isISR     = true;
    bool state_btn1 = true, state_btn2 = true, state_btn3 = true, state_btn4 = true;
    btnSemaphore = xSemaphoreCreateBinary();              // Создаем семафор 
    xSemaphoreTake( btnSemaphore, 100 );                  // Сразу "берем" семафор чтобы не было первого ложного срабатывания кнопки 
    attachInterrupt(PIN_BUTTON1, ISR_btn, FALLING);       // Запускаем обработчик прерывания (кнопка замыкает GPIO на землю) на все кнопки
    attachInterrupt(PIN_BUTTON2, ISR_btn, FALLING);   
    attachInterrupt(PIN_BUTTON3, ISR_btn, FALLING);
    attachInterrupt(PIN_BUTTON4, ISR_btn, FALLING);
    while(true)
      {
        // Обработчик прерывания выключен, функция ждет окончания действия с кнопкой     
        if( isISR )
          {

            xSemaphoreTake( btnSemaphore, portMAX_DELAY );         // Ждем "отпускание" семафора
            detachInterrupt(PIN_BUTTON1);                          // Отключаем прерывания по всем кнопкам
            detachInterrupt(PIN_BUTTON2);
            detachInterrupt(PIN_BUTTON3);
            detachInterrupt(PIN_BUTTON4);
            isISR = false;                                              // переводим задачу в цикл обработки кнопки
           }
        else 
          {
            bool st1 = digitalRead(PIN_BUTTON1);
            bool st2 = digitalRead(PIN_BUTTON2);
            bool st3 = digitalRead(PIN_BUTTON3);
            bool st4 = digitalRead(PIN_BUTTON4);
            if( st1 != state_btn1 )                                      // Проверка изменения состояния кнопки1 
             {
                state_btn1 = st1;
                if( st1 == LOW )
                  { 
                    Serial.println("Button1 pressed"); 
                  }
                else 
                  { 
                    action_Button1 = HIGH;
                    Serial.println("Button1 released"); 
                  }
              }        
            if( st2 != state_btn2 )                                           // Проверка изменения состояния кнопки2
              {  
                state_btn2 = st2;
                if( st2 == LOW )
                  {
                    Button2_pressed = HIGH; 
                    Serial.println("Button2 pressed"); 
                  }
                else 
                  {
                    Button2_pressed = LOW;
                    if (Button2_released == HIGH)
                      {
                        double_press = HIGH;
                      }
                    Button2_released = HIGH;
                    Serial.println("Button2 released"); 
                  }
              }        
           if( st3 != state_btn3 )// Проверка изменения состояния кнопки3
              {
                state_btn3 = st3;
                if( st3 == LOW )
                  { 
                    Button3_pressed = HIGH;
                    Serial.println("Button3 pressed"); 
                   }
                else 
                  { 
                    Button3_pressed = LOW;
                    Button3_released = HIGH;
                    Serial.println("Button3 released"); 
                  }
                } 
             if( st4 != state_btn4 )// Проверка изменения состояния кнопки4
               {
                  state_btn4 = st4;
                  if( st4 == LOW )
                    { 
                      Serial.println("Button4 pressed"); 
                     // digitalWrite(PIN_OUTPUT, LOW);
                    }
                  else 
                    { 
                      Serial.println("Button4 released");
                      action_Button4 = HIGH; 
                     // digitalWrite(PIN_OUTPUT, HIGH);
                    }
                }                
// Проверка что все четыре кнопки отработали
             if( st1 == HIGH && st2 == HIGH && st3 == HIGH && st4 == HIGH )
                { 
                  attachInterrupt(PIN_BUTTON1, ISR_btn, FALLING);   
                  attachInterrupt(PIN_BUTTON2, ISR_btn, FALLING);   
                  attachInterrupt(PIN_BUTTON3, ISR_btn, FALLING);
                  attachInterrupt(PIN_BUTTON4, ISR_btn, FALLING);
                  isISR = true;
                  }
              vTaskDelay(100);
          }
      }
  }

//void ReadFILE_FLASH ()
//  {
//    // Инициализация SPIFFS
//    if(!SPIFFS.begin(true))
//      {
//        Serial.println("Error while mounting SPIFFS");
//        return;
//      } 
//    // Прочитать содержимое файла
//    Data_array_file = SPIFFS.open(Data_arrayPath, FILE_READ);
//    //Serial.print("File content: \"");
////    while(Data_array_file.available()) 
////      {
////        Serial.write(Data_array_file.read());
////      }
////    Serial.println("\"");   
//    // Проверить размер файла
////    Serial.print("File size: ");
////    //Serial.println(Data_array_file.size());
// SizeF = Data_array_file.size();
//    Data_array_file.close();
//  }

void initBLE()
  {
    // Create the BLE Device
    BLEDevice::init("UART Service");

    // Create the BLE Server
    pServer = BLEDevice::createServer();
    pServer->setCallbacks(new MyServerCallbacks());

    // Create the BLE Service
    BLEService *pService = pServer->createService(SERVICE_UUID);

    // Create a BLE Characteristic
    pTxCharacteristic = pService->createCharacteristic(
                CHARACTERISTIC_TIME_TX_UUID,
                BLECharacteristic::PROPERTY_NOTIFY
                );

    pTxCharacteristic->addDescriptor(new BLE2902());

    pTxTimeCharacteristic = pService->createCharacteristic(
                CHARACTERISTIC_TEMP_TX_UUID,
                BLECharacteristic::PROPERTY_NOTIFY
                );
    pTxTimeCharacteristic->addDescriptor(new BLE2902());

   pTxminTempParCharacteristic= pService->createCharacteristic(
                                        CHARACTERISTIC_TP_TX_UUID,
                                        BLECharacteristic::PROPERTY_NOTIFY
                                    );
   pTxminTempParCharacteristic->addDescriptor(new BLE2902());

    BLECharacteristic * pRxCharacteristic = pService->createCharacteristic(
                CHARACTERISTIC_TIME_RX_UUID,
                BLECharacteristic::PROPERTY_WRITE
                );

    pRxCharacteristic->setCallbacks(new MyCallbacks());

   BLECharacteristic * pRxTCharacteristic = pService->createCharacteristic(
                                            CHARACTERISTIC_TP_RX_UUID,
                                            BLECharacteristic::PROPERTY_WRITE
                                        );

   pRxTCharacteristic->setCallbacks(new MyCallbacksTempPar());

    // Start the service
    pService->start();

    // Start advertising
    pServer->getAdvertising()->start();
    Serial.println("Waiting a client connection to notify...");
  }
void acseler ()
  {

    ACC = abs(ax) + abs(ay) + abs(az);
    GYR = abs(gx) + abs(gy) + abs(gz);
    if (ACC > (maxACC) || GYR > maxGYR) 
      {
        // Serial.print("ACC = ");
        // Serial.println(ACC);
        flagACC = 1;
        currentMillisAcc = millis();
        maxACC = ACC;
        maxGYR = GYR;
        //maxACC
      }
    else 
      {
        if ((millis() - currentMillisAcc) > INTERVAL_ACC)
          {
            flagACC = 0;
            currentMillisAcc = millis();
            maxACC = 0;
            maxGYR = 0;
          }
      }
  }

  void mean_hrb()
  {
    bufferLength = 100;                               //  Устанавливаем длину буфера равным 100 (куда будут записаны пакеты по 25 значений в течении 4 секунд)
                                                      //  считываем первые 100 значений и определяем диапазон значений сигнала:
    if (PARTICLE_SENSOR.getRed()>5000)
      {                                                     
        for (byte i = 0 ; i < bufferLength ; i++)     //  проходим в цикле по буферу и
          {         
            while (PARTICLE_SENSOR.available() == false)      //  отправляем сенсору запрос на получение новых данных
            PARTICLE_SENSOR.check();
            redBuffer[i] = PARTICLE_SENSOR.getIR();           //  Записываем в массив значения сенсора, полученные при работе с КРАСНЫМ светодиодом
            irBuffer[i] = PARTICLE_SENSOR.getRed();           //  Записываем в массив значения сенсора, полученные при работе с ИК      светодиодом
            PARTICLE_SENSOR.nextSample();                     //  Как только в буфер было записано 100 значений - отправляем сенсору команду начать вычислять значения ЧСС и SpO2
          }
        maxim_heart_rate_and_oxygen_saturation(irBuffer, bufferLength, redBuffer, &spo2, &validSPO2, &heartRate, &validHeartRate);
        Serial.print("spo2");
        Serial.println(spo2);
          }
    else
      {
        spo2 = 0;
        heartRate = 0;  
      }
  }

Debug Message

assertion "heap != NULL && "free() target pointer is outside heap areas"" failed: file "/home/runner/work/esp32-arduino-lib-builder/esp32-arduino-lib-builder/esp-idf/components/heap/heap_caps.c", line 267, function: heap_caps_free
abort() was called at PC 0x400dec0b on core 1
ELF file SHA256: 0000000000000000
Backtrace: 0x4008f5bc:0x3ffc7bb0 0x4008f839:0x3ffc7bd0 0x400dec0b:0x3ffc7bf0 0x400821af:0x3ffc7c20 0x40086da5:0x3ffc7c40 0x4000bec7:0x3ffc7c60 0x400dbee7:0x3ffc7c80 0x400dbef5:0x3ffc7ca0 0x400d2dc2:0x3ffc7cc0 0x400dc51c:0x3ffc7d60 0x400908ae:0x3ffc7d80

0x4008f5bc: invoke_abort at /home/runner/work/esp32-arduino-lib-builder/esp32-arduino-lib-builder/esp-idf/components/esp32/panic.c line 715
0x4008f839: abort at /home/runner/work/esp32-arduino-lib-builder/esp32-arduino-lib-builder/esp-idf/components/esp32/panic.c line 715
0x400decab: __assert_func at /Users/ivan/e/newlib_xtensa-2.2.0-bin/newlib_xtensa-2.2.0/xtensa-esp32-elf/newlib/libc/stdlib/../../../.././newlib/libc/stdlib/assert.c line 63 (discriminator 8)
0x400821af: heap_caps_free at /home/runner/work/esp32-arduino-lib-builder/esp32-arduino-lib-builder/esp-idf/components/heap/heap_caps.c line 215
0x40086da5: _free_r at /home/runner/work/esp32-arduino-lib-builder/esp32-arduino-lib-builder/esp-idf/components/newlib/syscalls.c line 42
0x400dbf87: String::invalidate() at C:\Users\alekseev_da.NNIIRT\AppData\Local\Arduino15\packages\esp32\hardware\esp32\1.0.6\cores\esp32/WString.cpp line 859
0x400dbf95: String::~String() at C:\Users\alekseev_da.NNIIRT\AppData\Local\Arduino15\packages\esp32\hardware\esp32\1.0.6\cores\esp32/WString.cpp line 859
0x400d2e62: loop() at D:\work\ESP\clock\clock/clock.ino line 848
0x400dc5bc: loopTask(void*) at C:\Users\alekseev_da.NNIIRT\AppData\Local\Arduino15\packages\esp32\hardware\esp32\1.0.6\cores\esp32/main.cpp line 23
0x400908ae: vPortTaskWrapper at /home/runner/work/esp32-arduino-lib-builder/esp32-arduino-lib-builder/esp-idf/components/freertos/port.c line 355 (discriminator 1)

Other Steps to Reproduce

No response

I have checked existing issues, online documentation and the Troubleshooting Guide

[X] I confirm I have checked existing issues, online documentation and Troubleshooting guide.

espressif / arduino-esp32

assertion "heap != NULL && "free() target pointer is outside heap areas" in workd Bluetooth BLE #6468