- Details
- Category: ESP32
The ESP32-CAM is a development board with an ESP32-S chip, an OV2640 camera, microSD card slot and several GPIOs to connect peripherals.
The esp32_camera
component allows you to use ESP32-based camera boards in ESPHome that directly integrate into Home Assistant through the native API.
See here
Other articles
2
3
4
- Details
- Category: ESP32
How to make a dummy Bluetooth Low Engery Heart Rate Emulator for testing purposes
Background to Bluetooth.
There are 2 types of bluetooth
Serial Bluetooth or 'Bluetooth Classic'
BLE or 'Bluetooth Low Energy'
Serial Bluetooth is a continuous data stream of high energy
BLE is a messaged based low energy.
We have a 'Server' that communicates with 1 or more 'Clients'. The Server posts information via a profile which contains Services and each Service has different characteristics.
A standard has been developed for the ID's or UUIDs of these devices. This BLE Specification can be found here
For example a BLE heart rate monitor has a 'Blood Pressure Service' with the 16-Bit Short UUID of 0x1810
In this 'Service' we have the 'Blood Pressure Measurement' Characteristic with a UUID of 0x2A35.
1 Make sure the BLE libraries are installed
In the arduino IDE goto Sketch->Include Library->Manage Libraries. Then search for 'ESP32 BLE Arduinio'
- Details
- Category: ESP32
BLE_client_2characteristics.ino
/**
* A BLE client example that is rich in capabilities.
* There is a lot new capabilities implemented.
* author unknown
* updated by chegewara and MoThunderz
*/
#include "BLEDevice.h"
//#include "BLEScan.h"
// Define UUIDs:
static BLEUUID serviceUUID("4fafc201-1fb5-459e-8fcc-c5c9c331914b");
static BLEUUID charUUID_1("beb5483e-36e1-4688-b7f5-ea07361b26a8");
static BLEUUID charUUID_2("1c95d5e3-d8f7-413a-bf3d-7a2e5d7be87e");
// Some variables to keep track on device connected
static boolean doConnect = false;
static boolean connected = false;
static boolean doScan = false;
// Define pointer for the BLE connection
static BLEAdvertisedDevice* myDevice;
BLERemoteCharacteristic* pRemoteChar_1;
BLERemoteCharacteristic* pRemoteChar_2;
// Callback function for Notify function
static void notifyCallback(BLERemoteCharacteristic* pBLERemoteCharacteristic,
uint8_t* pData,
size_t length,
bool isNotify) {
if(pBLERemoteCharacteristic->getUUID().toString() == charUUID_1.toString()) {
// convert received bytes to integer
uint32_t counter = pData[0];
for(int i = 1; i<length; i++) {
counter = counter | (pData[i] << i*8);
}
// print to Serial
Serial.print("Characteristic 1 (Notify) from server: ");
Serial.println(counter );
}
}
// Callback function that is called whenever a client is connected or disconnected
class MyClientCallback : public BLEClientCallbacks {
void onConnect(BLEClient* pclient) {
}
void onDisconnect(BLEClient* pclient) {
connected = false;
Serial.println("onDisconnect");
}
};
// Function that is run whenever the server is connected
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");
connected = true;
pRemoteChar_1 = pRemoteService->getCharacteristic(charUUID_1);
pRemoteChar_2 = pRemoteService->getCharacteristic(charUUID_2);
if(connectCharacteristic(pRemoteService, pRemoteChar_1) == false)
connected = false;
else if(connectCharacteristic(pRemoteService, pRemoteChar_2) == false)
connected = false;
if(connected == false) {
pClient-> disconnect();
Serial.println("At least one characteristic UUID not found");
return false;
}
return true;
}
// Function to chech Characteristic
bool connectCharacteristic(BLERemoteService* pRemoteService, BLERemoteCharacteristic* l_BLERemoteChar) {
// Obtain a reference to the characteristic in the service of the remote BLE server.
if (l_BLERemoteChar == nullptr) {
Serial.print("Failed to find one of the characteristics");
Serial.print(l_BLERemoteChar->getUUID().toString().c_str());
return false;
}
Serial.println(" - Found characteristic: " + String(l_BLERemoteChar->getUUID().toString().c_str()));
if(l_BLERemoteChar->canNotify())
l_BLERemoteChar->registerForNotify(notifyCallback);
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...");
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.
BLEScan* pBLEScan = BLEDevice::getScan();
pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
pBLEScan->setInterval(1349);
pBLEScan->setWindow(449);
pBLEScan->setActiveScan(true);
pBLEScan->start(5, false);
} // End of setup.
void loop() {
// 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) {
std::string rxValue = pRemoteChar_2->readValue();
Serial.print("Characteristic 2 (readValue): ");
Serial.println(rxValue.c_str());
String txValue = "String with random value from client: " + String(-random(1000));
Serial.println("Characteristic 2 (writeValue): " + txValue);
// Set the characteristic's value to be the array of bytes that is actually a string.
pRemoteChar_2->writeValue(txValue.c_str(), txValue.length());
}else if(doScan){
BLEDevice::getScan()->start(0); // this is just example to start scan after disconnect, most likely there is better way to do it in arduino
}
// In this example "delay" is used to delay with one second. This is of course a very basic
// implementation to keep things simple. I recommend to use millis() for any production code
delay(1000);
}
- Details
- Category: ESP32
BLE_server.ino
/*
Based on Neil Kolban example for IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleNotify.cpp
Ported to Arduino ESP32 by Evandro Copercini
updated by chegewara and MoThunderz
*/
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>
BLEServer* pServer = NULL;
BLECharacteristic* pCharacteristic = NULL;
BLEDescriptor *pDescr;
BLE2902 *pBLE2902;
bool deviceConnected = false;
bool oldDeviceConnected = false;
uint32_t value = 0;
// See the following for generating UUIDs:
// https://www.uuidgenerator.net/
#define SERVICE_UUID "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"
class MyServerCallbacks: public BLEServerCallbacks {
void onConnect(BLEServer* pServer) {
deviceConnected = true;
};
void onDisconnect(BLEServer* pServer) {
deviceConnected = false;
}
};
void setup() {
Serial.begin(115200);
// Create the BLE Device
BLEDevice::init("ESP32");
// 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
pCharacteristic = pService->createCharacteristic(
CHARACTERISTIC_UUID,
BLECharacteristic::PROPERTY_NOTIFY
);
// Create a BLE Descriptor
pDescr = new BLEDescriptor((uint16_t)0x2901);
pDescr->setValue("A very interesting variable");
pCharacteristic->addDescriptor(pDescr);
pBLE2902 = new BLE2902();
pBLE2902->setNotifications(true);
pCharacteristic->addDescriptor(pBLE2902);
// Start the service
pService->start();
// Start advertising
BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
pAdvertising->addServiceUUID(SERVICE_UUID);
pAdvertising->setScanResponse(false);
pAdvertising->setMinPreferred(0x0); // set value to 0x00 to not advertise this parameter
BLEDevice::startAdvertising();
Serial.println("Waiting a client connection to notify...");
}
void loop() {
// notify changed value
if (deviceConnected) {
pCharacteristic->setValue(value);
pCharacteristic->notify();
value++;
delay(1000);
}
// 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;
}
}
- Details
- Category: ESP32
BLE_client_2characteristics.ino
/**
* A BLE client example that is rich in capabilities.
* There is a lot new capabilities implemented.
* author unknown
* updated by chegewara and MoThunderz
*/
#include "BLEDevice.h"
//#include "BLEScan.h"
// Define UUIDs:
static BLEUUID serviceUUID("4fafc201-1fb5-459e-8fcc-c5c9c331914b");
static BLEUUID charUUID_1("beb5483e-36e1-4688-b7f5-ea07361b26a8");
static BLEUUID charUUID_2("1c95d5e3-d8f7-413a-bf3d-7a2e5d7be87e");
// Some variables to keep track on device connected
static boolean doConnect = false;
static boolean connected = false;
static boolean doScan = false;
// Define pointer for the BLE connection
static BLEAdvertisedDevice* myDevice;
BLERemoteCharacteristic* pRemoteChar_1;
BLERemoteCharacteristic* pRemoteChar_2;
// Callback function for Notify function
static void notifyCallback(BLERemoteCharacteristic* pBLERemoteCharacteristic,
uint8_t* pData,
size_t length,
bool isNotify) {
if(pBLERemoteCharacteristic->getUUID().toString() == charUUID_1.toString()) {
// convert received bytes to integer
uint32_t counter = pData[0];
for(int i = 1; i<length; i++) {
counter = counter | (pData[i] << i*8);
}
// print to Serial
Serial.print("Characteristic 1 (Notify) from server: ");
Serial.println(counter );
}
}
// Callback function that is called whenever a client is connected or disconnected
class MyClientCallback : public BLEClientCallbacks {
void onConnect(BLEClient* pclient) {
}
void onDisconnect(BLEClient* pclient) {
connected = false;
Serial.println("onDisconnect");
}
};
// Function that is run whenever the server is connected
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");
connected = true;
pRemoteChar_1 = pRemoteService->getCharacteristic(charUUID_1);
pRemoteChar_2 = pRemoteService->getCharacteristic(charUUID_2);
if(connectCharacteristic(pRemoteService, pRemoteChar_1) == false)
connected = false;
else if(connectCharacteristic(pRemoteService, pRemoteChar_2) == false)
connected = false;
if(connected == false) {
pClient-> disconnect();
Serial.println("At least one characteristic UUID not found");
return false;
}
return true;
}
// Function to chech Characteristic
bool connectCharacteristic(BLERemoteService* pRemoteService, BLERemoteCharacteristic* l_BLERemoteChar) {
// Obtain a reference to the characteristic in the service of the remote BLE server.
if (l_BLERemoteChar == nullptr) {
Serial.print("Failed to find one of the characteristics");
Serial.print(l_BLERemoteChar->getUUID().toString().c_str());
return false;
}
Serial.println(" - Found characteristic: " + String(l_BLERemoteChar->getUUID().toString().c_str()));
if(l_BLERemoteChar->canNotify())
l_BLERemoteChar->registerForNotify(notifyCallback);
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...");
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.
BLEScan* pBLEScan = BLEDevice::getScan();
pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
pBLEScan->setInterval(1349);
pBLEScan->setWindow(449);
pBLEScan->setActiveScan(true);
pBLEScan->start(5, false);
} // End of setup.
void loop() {
// 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) {
std::string rxValue = pRemoteChar_2->readValue();
Serial.print("Characteristic 2 (readValue): ");
Serial.println(rxValue.c_str());
String txValue = "String with random value from client: " + String(-random(1000));
Serial.println("Characteristic 2 (writeValue): " + txValue);
// Set the characteristic's value to be the array of bytes that is actually a string.
pRemoteChar_2->writeValue(txValue.c_str(), txValue.length());
}else if(doScan){
BLEDevice::getScan()->start(0); // this is just example to start scan after disconnect, most likely there is better way to do it in arduino
}
// In this example "delay" is used to delay with one second. This is of course a very basic
// implementation to keep things simple. I recommend to use millis() for any production code
delay(1000);
}
BLE_server_2characteristics.ino
/*
Based on Neil Kolban example for IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleNotify.cpp
Ported to Arduino ESP32 by Evandro Copercini
updated by chegewara and MoThunderz
*/
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>
// Initialize all pointers
BLEServer* pServer = NULL; // Pointer to the server
BLECharacteristic* pCharacteristic_1 = NULL; // Pointer to Characteristic 1
BLECharacteristic* pCharacteristic_2 = NULL; // Pointer to Characteristic 2
BLEDescriptor *pDescr_1; // Pointer to Descriptor of Characteristic 1
BLE2902 *pBLE2902_1; // Pointer to BLE2902 of Characteristic 1
BLE2902 *pBLE2902_2; // Pointer to BLE2902 of Characteristic 2
// Some variables to keep track on device connected
bool deviceConnected = false;
bool oldDeviceConnected = false;
// Variable that will continuously be increased and written to the client
uint32_t value = 0;
// See the following for generating UUIDs:
// https://www.uuidgenerator.net/
// UUIDs used in this example:
#define SERVICE_UUID "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHARACTERISTIC_UUID_1 "beb5483e-36e1-4688-b7f5-ea07361b26a8"
#define CHARACTERISTIC_UUID_2 "1c95d5e3-d8f7-413a-bf3d-7a2e5d7be87e"
// Callback function that is called whenever a client is connected or disconnected
class MyServerCallbacks: public BLEServerCallbacks {
void onConnect(BLEServer* pServer) {
deviceConnected = true;
};
void onDisconnect(BLEServer* pServer) {
deviceConnected = false;
}
};
void setup() {
Serial.begin(115200);
// Create the BLE Device
BLEDevice::init("ESP32");
// 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
pCharacteristic_1 = pService->createCharacteristic(
CHARACTERISTIC_UUID_1,
BLECharacteristic::PROPERTY_NOTIFY
);
pCharacteristic_2 = pService->createCharacteristic(
CHARACTERISTIC_UUID_2,
BLECharacteristic::PROPERTY_READ |
BLECharacteristic::PROPERTY_WRITE |
BLECharacteristic::PROPERTY_NOTIFY
);
// Create a BLE Descriptor
pDescr_1 = new BLEDescriptor((uint16_t)0x2901);
pDescr_1->setValue("A very interesting variable");
pCharacteristic_1->addDescriptor(pDescr_1);
// Add the BLE2902 Descriptor because we are using "PROPERTY_NOTIFY"
pBLE2902_1 = new BLE2902();
pBLE2902_1->setNotifications(true);
pCharacteristic_1->addDescriptor(pBLE2902_1);
pBLE2902_2 = new BLE2902();
pBLE2902_2->setNotifications(true);
pCharacteristic_2->addDescriptor(pBLE2902_2);
// Start the service
pService->start();
// Start advertising
BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
pAdvertising->addServiceUUID(SERVICE_UUID);
pAdvertising->setScanResponse(false);
pAdvertising->setMinPreferred(0x0); // set value to 0x00 to not advertise this parameter
BLEDevice::startAdvertising();
Serial.println("Waiting a client connection to notify...");
}
void loop() {
// notify changed value
if (deviceConnected) {
// pCharacteristic_1 is an integer that is increased with every second
// in the code below we send the value over to the client and increase the integer counter
pCharacteristic_1->setValue(value);
pCharacteristic_1->notify();
value++;
// pCharacteristic_2 is a std::string (NOT a String). In the code below we read the current value
// write this to the Serial interface and send a different value back to the Client
// Here the current value is read using getValue()
std::string rxValue = pCharacteristic_2->getValue();
Serial.print("Characteristic 2 (getValue): ");
Serial.println(rxValue.c_str());
// Here the value is written to the Client using setValue();
String txValue = "String with random value from Server: " + String(random(1000));
pCharacteristic_2->setValue(txValue.c_str());
Serial.println("Characteristic 2 (setValue): " + txValue);
// In this example "delay" is used to delay with one second. This is of course a very basic
// implementation to keep things simple. I recommend to use millis() for any production code
delay(1000);
}
// The code below keeps the connection status uptodate:
// 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;
}
}