Seich
/
Arduino-BLE-MIDI
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Limpieza y estructuracion del codigo. Se han añadido defines al inicio del fichero para que modificar las caracteristicas de seguridad, nombre y parámetros de comunicacion. TODO: No depender del método read(), que salten los callback de manera automática

This commit is contained in:
Roberto 2021-07-03 11:08:22 +02:00
parent b8831e4d3e
commit b830648af4
1 changed files with 392 additions and 281 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

543
src/hardware/BLEMIDI_Client_ESP32.h
View File

@ -1,45 +1,186 @@
#pragma once
/*
#############################################
########### USER DEFINE BEGINING ############
####### Only modify these parameters ########
#############################################
*/
/*
##### BLE DEVICE NAME #####
*/
/**
* Set always the same name independiently of name server
*/
//#define BLEMIDI_CLIENT_FIXED_NAME "BleMidiClient"
#ifndef BLEMIDI_CLIENT_FIXED_NAME //Not modify
/**
* BLE name is composed by the nex way when client try to connect to speccific server:
* BLEMIDI_CLIENT_NAME_PREFIX + <NameServer/addrServer> + BLEMIDI_CLIENT_NAME_SUBFIX
*
* example:
* BLEMIDI_CLIENT_NAME_PREFIX "Client-"
* <NameServer/addrServer> "AX-Edge"
* BLEMIDI_CLIENT_NAME_SUBFIX "-Midi1"
*
* Result: "Client-AX-Edge-Midi1"
*/
#define BLEMIDI_CLIENT_NAME_PREFIX "C-"
#define BLEMIDI_CLIENT_NAME_SUBFIX ""
/**
* BLE name when it tries to connect to first midi server found.
*/
#define BLEMIDI_CLIENT_DEFAULT_NAME "BLEMIDI-CLIENT"
#endif //Not modify
/*
###### SECURITY #####
*/
/** Set the IO capabilities of the device, each option will trigger a different pairing method.
* BLE_HS_IO_KEYBOARD_ONLY - Passkey pairing
* BLE_HS_IO_DISPLAY_YESNO - Numeric comparison pairing
* BLE_HS_IO_NO_INPUT_OUTPUT - DEFAULT setting - just works pairing
*/
#define BLEMIDI_CLIENT_SECURITY_CAP BLE_HS_IO_NO_INPUT_OUTPUT
/** Set security method.
* bonding
* man in the middle protection
* pair. secure connections
*
* More info in nimBLE lib
*
* Uncomment that you need
* These are the default values.
*/
//#define BLEMIDI_CLIENT_BOND
//#define BLEMIDI_CLIENT_MITM
#define BLEMIDI_CLIENT_PAIR
/**
* This callback funtion defines what it must to do when server requieres PassKey.
* Add your custom code here.
*/
static uint32_t userOnPassKeyRequest()
{
//FILL WITH YOUR CUSTOM AUTH METHOD or PASSKEY
//FOR EXAMPLE:
uint32_t passkey = 123456;
//Serial.println("Client Passkey Request");
/** return the passkey to send to the server */
return passkey;
};
/*
###### BLE COMMUNICATION PARAMS ######
*/
/** Set connection parameters:
* If only use one connection, put recomended BLE server param communication (you may scan it ussing "nRF Connect" app or other similar).
*
* If you use more than one connection use, for example, settings like 15ms interval, 0 latency, 120ms timout.
* These settings may be safe for 3 clients to connect reliably, can go faster if you have less
* connections.
*
* Min interval (unit: 1.25ms): 12 * 1.25ms = 15 ms,
* Max interval (unit: 1.25ms): 12 * 1.25ms = 15,
* 0 latency (Number of intervals allowed to skip),
* TimeOut (unit: 10ms) 51 * 10ms = 510ms. Timeout should be minimum 100ms.
*/
#define BLEMIDI_CLIENT_COMM_MIN_INTERVAL 6 // 7.5ms
#define BLEMIDI_CLIENT_COMM_MAX_INTERVAL 35 // 40ms
#define BLEMIDI_CLIENT_COMM_LATENCY 0
#define BLEMIDI_CLIENT_COMM_TIMEOUT 400 //4000ms
/*
#############################################
############ USER DEFINES END ###############
#############################################
*/
// Headers for ESP32 nimBLE
#include <NimBLEDevice.h>
static NimBLEAdvertisedDevice *advDevice;
static bool doConnect = false;
static bool scanDone = false;
BEGIN_BLEMIDI_NAMESPACE
#ifdef BLEMIDI_CLIENT_BOND
#define BLEMIDI_CLIENT_BOND_DUMMY BLE_SM_PAIR_AUTHREQ_BOND
#else
#define BLEMIDI_CLIENT_BOND_DUMMY 0x00
#endif
#ifdef BLEMIDI_CLIENT_MITM
#define BLEMIDI_CLIENT_MITM_DUMMY BLE_SM_PAIR_AUTHREQ_MITM
#else
#define BLEMIDI_CLIENT_MITM_DUMMY 0x00
#endif
#ifdef BLEMIDI_CLIENT_PAIR
#define BLEMIDI_CLIENT_PAIR_DUMMY BLE_SM_PAIR_AUTHREQ_SC
#else
#define BLEMIDI_CLIENT_PAIR_DUMMY 0x00
#endif
/** Set security method.
* bonding
* man in the middle protection
* pair. secure connections
*
* More info in nimBLE lib
*/
#define BLEMIDI_CLIENT_SECURITY_AUTH (BLEMIDI_CLIENT_BOND_DUMMY | BLEMIDI_CLIENT_MITM_DUMMY | BLEMIDI_CLIENT_PAIR_DUMMY)
/** Define a class to handle the callbacks when advertisments are received */
class AdvertisedDeviceCallbacks : public NimBLEAdvertisedDeviceCallbacks
{
public:
int test = 0;
NimBLEAdvertisedDevice advDevice;
bool doConnect = false;
bool scanDone = false;
bool specificTarget = false;
bool enableConnection = false;
std::string nameTarget;
protected:
void onResult(NimBLEAdvertisedDevice *advertisedDevice)
{
test++;
Serial.println(test);
if (enableConnection) //not begin() or end()
{
Serial.print("Advertised Device found: ");
Serial.println(advertisedDevice->toString().c_str());
if (advertisedDevice->isAdvertisingService(NimBLEUUID(SERVICE_UUID)))
{
Serial.println("Found Our Service");
/** stop scan before connecting */
NimBLEDevice::getScan()->stop();
/** Save the device reference in a global for the client to use*/
advDevice = advertisedDevice;
Serial.println("Found MIDI Service");
if (!specificTarget || (advertisedDevice->getName() == nameTarget.c_str() || advertisedDevice->getAddress() == nameTarget))
{
/** Ready to connect now */
doConnect = true;
/** Save the device reference in a global for the client to use*/
advDevice = *advertisedDevice;
/** stop scan before connecting */
NimBLEDevice::getScan()->stop();
}
}
else
{
doConnect = false;
}
}
};
};
/** Define a funtion to handle the callbacks when scan ends */
void scanEndedCB(NimBLEScanResults results);
BEGIN_BLEMIDI_NAMESPACE
/** Define the class that perform Client Midi (nimBLE) */
class BLEMIDI_Client_ESP32
{
private:
@ -47,10 +188,11 @@ private:
BLEAdvertising *_advertising = nullptr;
BLERemoteCharacteristic *_characteristic = nullptr;
BLERemoteService *pSvc = nullptr;
//NimBLERemoteDescriptor *pDsc = nullptr;
BLEMIDI_Transport<class BLEMIDI_Client_ESP32> *_bleMidiTransport = nullptr;
bool specificTarget = false;
friend class AdvertisedDeviceCallbacks;
friend class MyClientCallbacks;
friend class MIDI_NAMESPACE::MidiInterface<BLEMIDI_Transport<BLEMIDI_Client_ESP32>, MySettings>;
@ -67,51 +209,31 @@ public:
bool begin(const char *, BLEMIDI_Transport<class BLEMIDI_Client_ESP32> *);
bool end()
{
myAdvCB.enableConnection = false;
xQueueReset(mRxQueue);
_client->disconnect();
_client = nullptr;
return !_client->isConnected();
}
void write(uint8_t *data, uint8_t length)
{
if (myAdvCB.enableConnection)
_characteristic->writeValue(data, length, true);
myAdvCB.test++;
}
bool available(byte *pvBuffer)
{
if (_client == nullptr || !_client->isConnected())
{
//Serial.println("No Conectado");
if (doConnect)
{
doConnect = false;
Serial.println("intentar conexion");
if (connect())
{
Serial.println("reconnected");
}
else
{
Serial.println("Rescan");
scanDone=false;
NimBLEDevice::getScan()->start(3, scanEndedCB);
}
}
else if (scanDone)
{
scanDone=false;
Serial.println("Rescan 2");
NimBLEDevice::getScan()->start(3, scanEndedCB);
}
}
bool available(byte *pvBuffer);
// return 1 byte from the Queue
return xQueueReceive(mRxQueue, (void *)pvBuffer, 0); // return immediately when the queue is empty
}
void
add(byte value)
void add(byte value)
{
// called from BLE-MIDI, to add it to a buffer here
xQueueSend(mRxQueue, &value, portMAX_DELAY);
}
protected:
void receive(uint8_t *buffer, size_t length)
{
// forward the buffer so it can be parsed
@ -122,10 +244,8 @@ public:
void connected()
{
Serial.println("!!");
if (_bleMidiTransport->_connectedCallback)
{
Serial.println("@");
_bleMidiTransport->_connectedCallback();
}
}
@ -142,6 +262,7 @@ public:
bool connect();
};
/** Define the class that perform interrupts callbacks */
class MyClientCallbacks : public BLEClientCallbacks
{
public:
@ -153,51 +274,51 @@ public:
protected:
BLEMIDI_Client_ESP32 *_bluetoothEsp32 = nullptr;
uint32_t onPassKeyRequest()
{
return userOnPassKeyRequest();
};
void onConnect(BLEClient *pClient)
{
Serial.println("##Connected##");
/** After connection we should change the parameters if we don't need fast response times.
* These settings are 150ms interval, 0 latency, 450ms timout.
* Timeout should be a multiple of the interval, minimum is 100ms.
* I find a multiple of 3-5 * the interval works best for quick response/reconnect.
* Min interval: 120 * 1.25ms = 150, Max interval: 120 * 1.25ms = 150, 0 latency, 60 * 10ms = 600ms timeout
*/
//pClient->updateConnParams
pClient->updateConnParams(6, 32, 0, 40);
//Serial.println("##Connected##");
pClient->updateConnParams(BLEMIDI_CLIENT_COMM_MIN_INTERVAL, BLEMIDI_CLIENT_COMM_MAX_INTERVAL, BLEMIDI_CLIENT_COMM_LATENCY, BLEMIDI_CLIENT_COMM_TIMEOUT);
vTaskDelay(1);
if (_bluetoothEsp32)
{
Serial.println("??");
_bluetoothEsp32->connected();
}
};
void onDisconnect(BLEClient *pClient)
{
Serial.print(pClient->getPeerAddress().toString().c_str());
Serial.println(" Disconnected - Starting scan");
//Serial.print(pClient->getPeerAddress().toString().c_str());
//Serial.println(" Disconnected - Starting scan");
if (_bluetoothEsp32)
{
_bluetoothEsp32->disconnected();
}
//Try reconnection or look for a new one
NimBLEDevice::getScan()->start(3, scanEndedCB);
}
bool onConnParamsUpdateRequest(NimBLEClient *pClient, const ble_gap_upd_params *params)
{
if (params->itvl_min < 24)
if (params->itvl_min < BLEMIDI_CLIENT_COMM_MIN_INTERVAL)
{ /** 1.25ms units */
return false;
}
else if (params->itvl_max > 40)
else if (params->itvl_max > BLEMIDI_CLIENT_COMM_MAX_INTERVAL)
{ /** 1.25ms units */
return false;
}
else if (params->latency > 2)
else if (params->latency > BLEMIDI_CLIENT_COMM_LATENCY)
{ /** Number of intervals allowed to skip */
return false;
}
else if (params->supervision_timeout > 100)
else if (params->supervision_timeout > BLEMIDI_CLIENT_COMM_TIMEOUT + 10)
{ /** 10ms units */
return false;
}
@ -206,18 +327,91 @@ protected:
};
};
/** Notification / Indication receiving handler callback */
/*
##########################################
############# IMPLEMENTATION #############
##########################################
*/
bool BLEMIDI_Client_ESP32::begin(const char *deviceName, BLEMIDI_Transport<class BLEMIDI_Client_ESP32> *bleMidiTransport)
{
_bleMidiTransport = bleMidiTransport;
std::string strDeviceName(deviceName);
if (strDeviceName == "") // Connect to first midi server found
{
myAdvCB.specificTarget = false;
myAdvCB.nameTarget = "";
#ifdef BLEMIDI_CLIENT_FIXED_NAME
strDeviceName = BLEMIDI_CLIENT_FIXED_NAME;
#else
strDeviceName = BLEMIDI_CLIENT_DEFAULT_NAME;
#endif
}
else // Connect to a specific name or addr
{
myAdvCB.specificTarget = true;
myAdvCB.nameTarget = strDeviceName;
#ifdef BLEMIDI_CLIENT_FIXED_NAME
strDeviceName = BLEMIDI_CLIENT_FIXED_NAME;
#else
strDeviceName = BLEMIDI_CLIENT_NAME_PREFIX + strDeviceName + BLEMIDI_CLIENT_NAME_SUBFIX;
#endif
}
Serial.println(strDeviceName.c_str());
NimBLEDevice::init(strDeviceName);
// To communicate between the 2 cores.
// Core_0 runs here, core_1 runs the BLE stack
mRxQueue = xQueueCreate(256, sizeof(uint8_t)); // TODO Settings::MaxBufferSize
NimBLEDevice::setSecurityIOCap(BLEMIDI_CLIENT_SECURITY_CAP); // Attenction, may need passkey
NimBLEDevice::setSecurityAuth(BLEMIDI_CLIENT_SECURITY_AUTH);
/** Optional: set the transmit power, default is 3db */
NimBLEDevice::setPower(ESP_PWR_LVL_P9); /** +9db */
myAdvCB.enableConnection = true;
scan();
return true;
}
bool BLEMIDI_Client_ESP32::available(byte *pvBuffer)
{
if (myAdvCB.enableConnection)
{
if (_client == nullptr || !_client->isConnected()) //Try to connect/reconnect
{
if (myAdvCB.doConnect)
{
myAdvCB.doConnect = false;
if (!connect())
{
scan();
}
}
else if (myAdvCB.scanDone)
{
scan();
}
}
// return 1 byte from the Queue
return xQueueReceive(mRxQueue, (void *)pvBuffer, 0); // return immediately when the queue is empty
}
else
{
return false;
}
}
/** Notification receiving handler callback */
void BLEMIDI_Client_ESP32::notifyCB(NimBLERemoteCharacteristic *pRemoteCharacteristic, uint8_t *pData, size_t length, bool isNotify)
{
// std::string str = (isNotify == true) ? "Notification" : "Indication";
// str += " from ";
// /** NimBLEAddress and NimBLEUUID have std::string operators */
// str += std::string(pRemoteCharacteristic->getRemoteService()->getClient()->getPeerAddress());
// str += ": Service = " + std::string(pRemoteCharacteristic->getRemoteService()->getUUID());
// str += ", Characteristic = " + std::string(pRemoteCharacteristic->getUUID());
// str += ", Value = " + std::string((char *)pData, length);
// Serial.println(str.c_str());
if (uxQueueSpacesAvailable(mRxQueue) >= length) //Don't overflow the queue. If the queue is overflowed, comunication breaks out
receive(pData, length);
}
@ -225,83 +419,79 @@ void BLEMIDI_Client_ESP32::scan()
{
// 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.
// scan to run for 3 seconds.
myAdvCB.scanDone = true;
NimBLEScan *pBLEScan = BLEDevice::getScan();
if (!pBLEScan->isScanning())
{
pBLEScan->setAdvertisedDeviceCallbacks(&myAdvCB);
pBLEScan->setInterval(1500);
pBLEScan->setInterval(600);
pBLEScan->setWindow(500);
pBLEScan->setActiveScan(true);
//doScan = true;
Serial.println("Scanning...");
pBLEScan->start(10, scanEndedCB);
pBLEScan->start(3, scanEndedCB);
}
};
bool BLEMIDI_Client_ESP32::connect()
{
Serial.println("Try Connection...");
using namespace std::placeholders;
/** Check if we have a client we should reuse first **/
if (NimBLEDevice::getClientListSize())
{
/** Special case when we already know this device, we send false as the
* second argument in connect() to prevent refreshing the service database.
using namespace std::placeholders; //<- for bind funtion in callback notification
/** Check if we have a client we should reuse first /
/ Special case when we already know this device
* This saves considerable time and power.
*/
_client = NimBLEDevice::getClientByPeerAddress(advDevice->getAddress());
if (_client)
{
if (!_client->connect(advDevice, false))
if (_client == NimBLEDevice::getClientByPeerAddress(myAdvCB.advDevice.getAddress()))
{
Serial.println("Reconnect failed");
return false;
}
Serial.println("Reconnected client");
_client->setConnectionParams(12, 12, 0, 51);
if (_client->connect(&myAdvCB.advDevice, false))
{
//_client->updateConnParams(BLEMIDI_CLIENT_COMM_MIN_INTERVAL, BLEMIDI_CLIENT_COMM_MAX_INTERVAL, BLEMIDI_CLIENT_COMM_LATENCY, BLEMIDI_CLIENT_COMM_TIMEOUT);
if (_characteristic->canNotify())
{
Serial.println("CAN NOTIFY");
if (!_characteristic->subscribe(true, std::bind(&BLEMIDI_Client_ESP32::notifyCB, this, _1, _2, _3, _4)))
{
Serial.println("error");
Serial.println("Error - Not subscribe");
/** Disconnect if subscribe failed */
_client->disconnect();
return false;
}
}
}
/** We don't already have a client that knows this device,
* we will check for a client that is disconnected that we can use.
*/
else
{
_client = NimBLEDevice::getDisconnectedClient();
return true;
}
}
}
else
{
Serial.println("Error. Reconnect failed");
_client = nullptr;
return false;
}
}
}
/** No client to reuse? Create a new one. */
if (!_client)
{
if (NimBLEDevice::getClientListSize() >= NIMBLE_MAX_CONNECTIONS)
{
Serial.println("Max clients reached - no more connections available");
return false;
}
_client = BLEDevice::createClient();
_client->setClientCallbacks(new MyClientCallbacks(this), false);
/** Set initial connection parameters: These settings are 15ms interval, 0 latency, 120ms timout.
* These settings are safe for 3 clients to connect reliably, can go faster if you have less
* connections. Timeout should be a multiple of the interval, minimum is 100ms.
* Min interval: 12 * 1.25ms = 15, Max interval: 12 * 1.25ms = 15, 0 latency, 51 * 10ms = 510ms timeout
*/
_client->setConnectionParams(12, 12, 0, 51);
_client->setConnectionParams(BLEMIDI_CLIENT_COMM_MIN_INTERVAL, BLEMIDI_CLIENT_COMM_MAX_INTERVAL+10, BLEMIDI_CLIENT_COMM_LATENCY+1, BLEMIDI_CLIENT_COMM_TIMEOUT+10);
/** Set how long we are willing to wait for the connection to complete (seconds), default is 30. */
_client->setConnectTimeout(5);
Serial.println("#Connection");
if (!_client->connect(advDevice))
_client->setConnectTimeout(15);
if (!_client->connect(&myAdvCB.advDevice))
{
/** Created a client but failed to connect, don't need to keep it as it has no data */
NimBLEDevice::deleteClient(_client);
_client = nullptr;
Serial.println("Failed to connect, deleted client");
@ -310,23 +500,23 @@ bool BLEMIDI_Client_ESP32::connect()
vTaskDelay(100);
if (!_client->isConnected())
{
if (!_client->connect(advDevice))
{
Serial.println("Failed to connect");
_client->disconnect();
_client = nullptr;
return false;
}
}
else
{
//_client->updateConnParams(BLEMIDI_CLIENT_COMM_MIN_INTERVAL, BLEMIDI_CLIENT_COMM_MAX_INTERVAL, BLEMIDI_CLIENT_COMM_LATENCY, BLEMIDI_CLIENT_COMM_TIMEOUT);
Serial.print("Connected to: ");
Serial.print(myAdvCB.advDevice.getName().c_str());
Serial.print(" / ");
Serial.println(_client->getPeerAddress().toString().c_str());
Serial.print("RSSI: ");
Serial.println(_client->getRssi());
}
/** Now we can read/write/subscribe the charateristics of the services we are interested in */
/** Now we can read/write/subscribe the charateristics of the services we are interested in */
pSvc = _client->getService(SERVICE_UUID);
if (pSvc)
{ /** make sure it's not null */
@ -334,130 +524,51 @@ bool BLEMIDI_Client_ESP32::connect()
if (_characteristic)
{ /** make sure it's not null */
// if (_characteristic->canRead())
// {
// Serial.print(_characteristic->getUUID().toString().c_str());
// Serial.print(" Value: ");
// Serial.println(_characteristic->readValue().c_str());
// }
/** registerForNotify() has been deprecated and replaced with subscribe() / unsubscribe().
* Subscribe parameter defaults are: notifications=true, notifyCallback=nullptr, response=false.
* Unsubscribe parameter defaults are: response=false.
*/
if (_characteristic->canNotify())
{
Serial.println("CAN NOTIFY");
if (!_characteristic->subscribe(true, std::bind(&BLEMIDI_Client_ESP32::notifyCB, this, _1, _2, _3, _4)))
{
Serial.println("error");
Serial.println("Error - Subcribe error");
/** Disconnect if subscribe failed */
_client->disconnect();
return false;
}
}
// else if (_characteristic->canIndicate())
// {
// /** Send false as first argument to subscribe to indications instead of notifications */
// //if(!pChr->registerForNotify(notifyCB, false)) {
// if (!_characteristic->subscribe(false, std::bind(&BLEMIDI_Client_ESP32::notifyCB, this, _1, _2, _3, _4)))
// {
// /** Disconnect if subscribe failed */
// _client->disconnect();
// return false;
// }
// }
else
{
return false;
}
}
else
{
Serial.println("MIDI service not found.");
return false;
}
}
return true;
};
bool BLEMIDI_Client_ESP32::begin(const char *deviceName, BLEMIDI_Transport<class BLEMIDI_Client_ESP32> *bleMidiTransport)
else
{
_bleMidiTransport = bleMidiTransport;
Serial.println("CreateBLE");
std::string stringDeviceName(deviceName);
NimBLEDevice::init(stringDeviceName);
Serial.println("CREATED");
// To communicate between the 2 cores.
// Core_0 runs here, core_1 runs the BLE stack
mRxQueue = xQueueCreate(64, sizeof(uint8_t)); // TODO Settings::MaxBufferSize
Serial.println("QUEUE");
/** Set the IO capabilities of the device, each option will trigger a different pairing method.
* BLE_HS_IO_KEYBOARD_ONLY - Passkey pairing
* BLE_HS_IO_DISPLAY_YESNO - Numeric comparison pairing
* BLE_HS_IO_NO_INPUT_OUTPUT - DEFAULT setting - just works pairing
*/
//NimBLEDevice::setSecurityIOCap(BLE_HS_IO_KEYBOARD_ONLY); // use passkey
//NimBLEDevice::setSecurityIOCap(BLE_HS_IO_DISPLAY_YESNO); //use numeric comparison
/** 2 different ways to set security - both calls achieve the same result.
* no bonding, no man in the middle protection, secure connections.
*
* These are the default values, only shown here for demonstration.
*/
//NimBLEDevice::setSecurityAuth(false, false, true);
NimBLEDevice::setSecurityAuth(/*BLE_SM_PAIR_AUTHREQ_BOND | BLE_SM_PAIR_AUTHREQ_MITM | */ BLE_SM_PAIR_AUTHREQ_SC);
Serial.println("Security");
/** Optional: set the transmit power, default is 3db */
NimBLEDevice::setPower(ESP_PWR_LVL_P9); /** +9db */
Serial.println("Power");
/** Optional: set any devices you don't want to get advertisments from */
// NimBLEDevice::addIgnored(NimBLEAddress ("aa:bb:cc:dd:ee:ff"));
scan();
vTaskDelay(1000);
//connect();
// while (!doConnect)
// {
// if (!pBLEScan->isScanning())
// {
// Serial.println("RESCAN");
// pBLEScan->start(10, scanEndedCB);
// }
// vTaskDelay(100);
// }
// Serial.println("LOOP OUT");
return true;
Serial.println("Error. MIDI service not found.");
return false;
}
END_BLEMIDI_NAMESPACE
return true;
};
/** Callback to process the results of the last scan or restart it */
void scanEndedCB(NimBLEScanResults results)
{
Serial.println("Scan Ended");
if (!doConnect)
{
scanDone = true;
}
else
{
scanDone = false;
NimBLEDevice::getScan()->start(3, scanEndedCB);
}
// Serial.println("Scan Ended");
}
/*! \brief Create an instance for ESP32 named <DeviceName>
END_BLEMIDI_NAMESPACE
/*! \brief Create an instance for ESP32 named "Prefix + <DeviceName> + Subfix"
It will try to connect to a specific server with equal name or addr than <DeviceName>
*/
#define BLEMIDI_CREATE_INSTANCE(DeviceName, Name) \
BLEMIDI_NAMESPACE::BLEMIDI_Transport<BLEMIDI_NAMESPACE::BLEMIDI_Client_ESP32> BLE##Name(DeviceName); \
MIDI_NAMESPACE::MidiInterface<BLEMIDI_NAMESPACE::BLEMIDI_Transport<BLEMIDI_NAMESPACE::BLEMIDI_Client_ESP32>, BLEMIDI_NAMESPACE::MySettings> Name((BLEMIDI_NAMESPACE::BLEMIDI_Transport<BLEMIDI_NAMESPACE::BLEMIDI_Client_ESP32> &)BLE##Name);
/*! \brief Create a default instance for ESP32 named BLE-MIDI
/*! \brief Create a default instance for ESP32 named BLEMIDI-CLIENT.
It will try to connect to first midi ble server found.
*/
#define BLEMIDI_CREATE_DEFAULT_INSTANCE() \
BLEMIDI_CREATE_INSTANCE("Esp32-NimBLE-MIDI", MIDI)
BLEMIDI_CREATE_INSTANCE("", MIDI)