Q: esp32 BLE device scan doesn't work second time it loops I am trying to connect to a BLE device, and once the callback is received it sends an ACK to a server and then reconnects the BLE device, the BLE device doesn't want to reconnect the second time round though and just skips over that line. I tried disabling and enabling Wi-Fi but that results in a http error code of -1.
My code:
#include "BLEDevice.h"
#include "WiFi.h"
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include <Arduino_JSON.h>


//WiFi variables
//HTTPClient http;

bool wifiConnect = 0;
bool scanned = 0;

const char* ssid = "SSID";
const char* password = "Password";

char* serverName = "generic server name";
String serverPath;
String httpRequestData;

int Connection = 0;
int httpResponseCode;

String Data = "";
String externalID = "";

//BLE Device
BLEScan* pBLEScan;

float Temp=0;

// The remote service we wish to connect to.
static BLEUUID serviceUUID("0000fff0-0000-1000-8000-00805f9b34fb");
// The characteristic of the remote service we are interested in.
static BLEUUID    charUUID("0000fff1-0000-1000-8000-00805f9b34fb");

static boolean doConnect = false;
static boolean connected = false;
static boolean doScan = false;
static BLERemoteCharacteristic* pRemoteCharacteristic;
static BLEAdvertisedDevice* myDevice;

static void notifyCallback(
  BLERemoteCharacteristic* pBLERemoteCharacteristic,
  uint8_t* pData,
  size_t length,
  bool isNotify) {
  ESP_LOG_BUFFER_HEX("my value", pData, length);//NEW, used to neatly show data
  Serial.println("");
  Serial.print("The ");
  if (pData[3] == 0)
    Serial.print("object ");
  else if (pData[3] == 1)
    Serial.print("body ");
  Serial.print("temperature is: ");
  Temp = (float(pData[4] * 256 + pData[5])) / 10;
  Serial.print(Temp);
  Serial.print("*C");
  Serial.println("");
  Connection = 1;
  scanned = 1;
}

class MyClientCallback : public BLEClientCallbacks {
    void onConnect(BLEClient* pclient) {
    }

    void onDisconnect(BLEClient* pclient) {
      connected = false;
      wifiConnect = 0;
      Serial.println("onDisconnect");
    }
};

bool connectToServer() {
  Serial.print("Forming a connection to ");
  Serial.println(myDevice->getAddress().toString().c_str());

  BLEClient*  pClient  = BLEDevice::createClient();
  Serial.println(" - Created client");

  pClient->setClientCallbacks(new MyClientCallback());

  // Connect to the remove BLE Server.
  pClient->connect(myDevice);  // if you pass BLEAdvertisedDevice instead of address, it will be recognized type of peer device address (public or private)
  Serial.println(" - Connected to server");

  // Obtain a reference to the service we are after in the remote BLE server.
  BLERemoteService* pRemoteService = pClient->getService(serviceUUID);
  if (pRemoteService == nullptr) {
    Serial.print("Failed to find our service UUID: ");
    Serial.println(serviceUUID.toString().c_str());
    pClient->disconnect();
    return false;
  }
  Serial.println(" - Found our service");


  // Obtain a reference to the characteristic in the service of the remote BLE server.
  pRemoteCharacteristic = pRemoteService->getCharacteristic(charUUID);
  if (pRemoteCharacteristic == nullptr) {
    Serial.print("Failed to find our characteristic UUID: ");
    Serial.println(charUUID.toString().c_str());
    pClient->disconnect();
    return false;
  }
  Serial.println(" - Found our characteristic");

  // Read the value of the characteristic.
  if (pRemoteCharacteristic->canRead()) {
    std::string value = pRemoteCharacteristic->readValue();
    Serial.print("The characteristic value was: ");
    Serial.println(value.c_str());
  }

  if (pRemoteCharacteristic->canNotify())
    pRemoteCharacteristic->registerForNotify(notifyCallback);

  connected = true;
  return true;
}
/**
   Scan for BLE servers and find the first one that advertises the service we are looking for.
*/
class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks {
    /**
        Called for each advertising BLE server.
    */
    void onResult(BLEAdvertisedDevice advertisedDevice) {
      Serial.print("BLE Advertised Device found: ");
      Serial.println(advertisedDevice.toString().c_str());

      // We have found a device, let us now see if it contains the service we are looking for.
      if (advertisedDevice.haveServiceUUID() && advertisedDevice.isAdvertisingService(serviceUUID)) {

        BLEDevice::getScan()->stop();
        myDevice = new BLEAdvertisedDevice(advertisedDevice);
        doConnect = true;
        doScan = true;

      } // Found our server
    } // onResult
}; // MyAdvertisedDeviceCallbacks


void setup() {
  Serial.begin(115200);
  Serial.println("Starting Arduino BLE Client application..."); \

  //WiFi setup
  Serial.println();
  Serial.printf("Connecting to %s\n", ssid);
  WiFi.begin(ssid, password);
  //WiFi.config(staticIP, gateway, subnet);

  while (WiFi.status() != WL_CONNECTED)
  {
    Serial.println("Connecting to WiFi...");
    delay(1000);
  }//end while

  Serial.print("Connected, IP address: ");
  Serial.println(WiFi.localIP());
  HTTPClient http;

  serverPath = serverName;
  if (WiFi.status() == WL_CONNECTED) {
    // Your Domain name with URL path or IP address with path
    http.begin(serverPath.c_str());

    // Data to send with HTTP POST
    JSONVar json_test;
    json_test["id"] = WiFi.macAddress();
    httpRequestData = JSON.stringify(json_test);

    // If you need an HTTP request with a content type: application/json, use the following:
    http.addHeader("Content-Type", "application/json");
    httpResponseCode = http.POST(httpRequestData);

    if (httpResponseCode > 0) {
      Serial.print("HTTP Response code: ");
      Serial.println(httpResponseCode);
      Serial.println("This is the response code");
    }
    else {
      Serial.print("Error code: ");
      Serial.println(httpResponseCode);
      Serial.println("This is the setup");
    }
    // Free resources
    Serial.println("IS this done?");
    http.end();
  } else
  {
    Serial.println("WiFi disconnected");
  }
} // End of setup.


// This is the Arduino main loop function.
void loop() {
  if ((!wifiConnect))
  {
    //BLE
    BLEDevice::init("");
    // Retrieve a Scanner and set the callback we want to use to be informed when we
    // have detected a new device.  Specify that we want active scanning and start the
    // scan to run for 5 seconds.
    pBLEScan = BLEDevice::getScan();
    pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
    pBLEScan->setActiveScan(true);
    pBLEScan->start(5, false);
    Serial.println("Done");
    // If the flag "doConnect" is true then we have scanned for and found the desired
    // BLE Server with which we wish to connect.  Now we connect to it.  Once we are
    // connected we set the connected flag to be true.
    if (doConnect == true) {
      if (connectToServer()) {
        Serial.println("We are now connected to the BLE Server.");
      } else {
        Serial.println("We have failed to connect to the server; there is nothin more we will do.");
      }
      doConnect = false;
    }

    // If we are connected to a peer BLE Server, update the characteristic each time we are reached
    // with the current time since boot.
    /* if ((!connected) && (doScan)) {
       BLEDevice::getScan()->start(5);  // this is just eample to start scan after disconnect, most likely there is better way to do it in arduino
      }*/
    if (connected)
    { wifiConnect = 1;
    }
  } else if (scanned)
  {
    scanned=0;
    wifiConnect=0;
    BLEDevice::getScan()->clearResults();
    BLEDevice::deinit(true);
    HTTPClient http;

    serverPath = serverName;
    if (WiFi.status() == WL_CONNECTED) {
      // Your Domain name with URL path or IP address with path
      http.begin(serverPath.c_str());

      // Data to send with HTTP POST
      JSONVar json_test;
      json_test["id"] = WiFi.macAddress();
      httpRequestData = JSON.stringify(json_test);

      // If you need an HTTP request with a content type: application/json, use the following:
      http.addHeader("Content-Type", "application/json");
      httpResponseCode = http.POST(httpRequestData);

      if (httpResponseCode > 0) {
        Serial.print("HTTP Response code: ");
        Serial.println(httpResponseCode);
        Serial.println("This is the response code");
      }
      else {
        Serial.print("Error code: ");
        Serial.println(httpResponseCode);
      }
      // Free resources
      http.end();
    } else
    {
      Serial.println("WiFi disconnected");
    }
     Connection = 0;
     doConnect=0;
     doScan=0;
     connected=0;
  }
  Serial.println(".");
  delay(1000); // Delay a second between loops.
} // End of loop

