Published November 19, 2022 © GPL3+

Home Assistant Deep BLE Relay-Low energy

BLE relay device for Home Assistant that, for the most of time is in a very low energy state and only a few seconds per minute is awake.

IntermediateFull instructions provided2 hours2,736

Home Assistant Deep BLE Relay-Low energy

Things used in this project

Hardware components

Espressif ESP-WROOM-32

AZDelivery Mini Modulo Alimentatore 220V a 5V

5V Relay

Texas Instruments CD40106BE

Texas Instruments SN74HC74N

Raspberry Pi 4 Model B

LilyGO TTGO T-Internet PoE ESP32 - LAN8720A

LilyGO TTGO TTL USB Serial Port Adapter for T-Internet PoE

Software apps and online services

JLCPCB EasyEDA

Hand tools and fabrication machines

Soldering iron (generic)

Story

The purpose of this project, was to develope a BLE relay device for Home Assistant that, for the most of time, was in a very low energy and emission state and only for few seconds per minute was in awake state.

At the same time I didn’t need that my ON/Off remote commands was executed instantaneously but, for my needs, was enough that every ON/Off command was really executed within a time interval of one minute.

In other words, for my needs (i.e. to start and stop an aged fan coil unit), it's really unimportant that there is a time delay of at most one minute between the press of the button on the Home Assistant’s dashboard and the effective change of the relay state (that turn off or turn on the fan coil unit).

The project is entirely based on two ESP32 boards, the first acting as a remote BLE server and the second, integrated on the HA platform, acting as BLE client.

At the same time Home Assistant is hosted on a Raspberry Pi 4 Model B.

The remote ESP32 (BLE server) control the relay state by means of an output pin (GPIO 25).

Anyway, since the voltage level of the output pin is high only when the the ESP32 remote server is awake and back to zero volts when the ESP 32 goes in deep sleep state, is needed a way to convert the momentary pulse on GPIO 25 output pin in a permanent signal.

In other words, i.e., if I want that the fan coil is switched on, I need to push the button on the Home assistant dashboard so that a momentary pulse is sent to the output pin during the brief interval in wich the remote ESP32 in awake state and then this pulse is converted in a permanent signal that mantain the relay state ON and the thus the fan coil.

Obviously, to switch the fan coil off, a second pulse will be needed and within the same time interval (about 60 secs) the fan coil will be off.

To do all this, two things are essentially required:

A BLE connection between the two ESP 32 boards: the first (an HA integration), acting as BLE client and the second, the remote BLE server (directly connected to relay as we said).
A "momentary switch to toggle switch" logic converter.

Here is the piece of.yaml file in wich you can do all that:

In wich you must specify

1) MAC Address of the Remote ESP32 server server board (i.e.11:22:33:44:55:66)

2) Exposed service UUID and Characteristic UUID (see this to create your own UUID Online UUID Generator Tool)

3) BLE client automation to perform when the client connects to BLE server so that on the HA dashboard you can monitor when the remote ESP32 board is awake and when it sleep.

The second problem, is solved using the well known logic circuit that use a D-Type flip-flop to convert a momentary switch in a toggle switch (see this fora clear explanation of how it works: Convert a Momentary Switch to a Toggle Switch ).

Finally, on the remote ESP32 server, there is a feedback sensor (GPIO 34) to verify if the relay state is really ON or OFF.

Even this data have been sent over a BLE communication between server and client:

As I said, for this project I need essentially two ESP32 boards: one BLE server and one BLE client.

Let me start with the BLE client.

It is a ESP32 board that is used as a BLE tracker and is directly connected to the Home Assistant platform that is hosted on the Raspberry PI 4 model B.

I've used for this purpose a LilyGO TTGO T-Internet PoE ESP32 - LAN8720A but even any other ESP32 board would be fine.

The advantage of using the LilyGO board is that it has an onboard LAN interface and then I don't need any WiFi connection to interact with its (remember, this is a very low emission project...).

Once the board is proprerly configured, you can modify yaml file, apply updates and so on, using any PC on the same LAN:

See the code section to download complete.yaml file that I've used.

And now let's move to the second ESP32 board: the BLE remote server.

This board is mounted on the PCB (see dedicate section on this document) that hosts, in addition, the power supply, the logic needed to create the D-type Flip Flop (remember? You need to convert a momentary switch in a toggle switch) and, finally, the relay.

In this case I've used a simple ESP-WROOM-32 board on wich I've uploaded an Arduino IDE code.

Essentially in this code I need to specify:

1) the sleep/awake time interval (56 secs sleep and 4 secs awake is a good compromise):

2) the BLE service_UUID and Characteristic_UUID needed to exchange data from client to server:

3) the pin34 value (see schematic) used to know if the relay is actually ON or Off (essentially a feedback signal)

Once you've uploaded all necessary code on the two boards you've finished and you'll be able to switch on/off any electric device physically connected to the relay.

That's all.

I shall have pleasure to read you comments and suggestions.

Code

substitutions:
  name: lilygo-ttgo-poe-bt-proxy-5f7de4
packages:
  esphome.bluetooth-proxy: github://esphome/bluetooth-proxies/lilygo-t-eth-poe.yaml@main
esphome:
  name: ${name}
  name_add_mac_suffix: false

esp32_ble_tracker:  
  
ble_client:
  - mac_address: 34:94:54:25:26:2e
    id: ESP32_BLE_Remote
    on_connect:
         then:
           - lambda: |-
               id(ESP32_text_sensor_name2).publish_state("AWAKE");
    on_disconnect:
         then:
           - lambda: |-
               id(ESP32_text_sensor_name2).publish_state("Deep Sleep");

output:
  - platform: ble_client
    ble_client_id: ESP32_BLE_Remote
    service_uuid: '4fafc201-1fb5-459e-8fcc-c5c9c331914b'
    characteristic_uuid: 'beb5483e-36e1-4688-b7f5-ea07361b26a8'
    id: out_ble01   

  - platform: ble_client
    ble_client_id: ESP32_BLE_Remote
    service_uuid: '4fafc201-1fb5-459e-8fcc-c5c9c331914b'
    characteristic_uuid: 'cba1d466-344c-4be3-ab3f-189f80dd7518'
    id: out_ble02 
switch:

# Momentary Switch
  - platform: output
    name: "Momentary Switch LED BLU - Remote ESP32"
    id: relay
    icon: "mdi:power"
    on_turn_on:
    - delay: 3s
    - switch.turn_off: relay   
    output: out_ble01   

# Indicazione stato pin34
  - platform: gpio
    pin: 32
    name: "Stato pin 34 (ON-Off)"
    icon: "mdi:alarm-light"

text_sensor:
  - platform: template
    name: "Stato ESP32 remote"
    id: ESP32_text_sensor_name2
    icon: "mdi:arrow-up-circle"

sensor:
   
# RSSI based on MAC address
  - platform: ble_rssi
    mac_address: 34:94:54:25:26:2e
    name: "BLE ESP32 remote RSSI value"  
   
# Valore sul pin 34
  - platform: ble_client
    type: characteristic
    ble_client_id: ESP32_BLE_Remote
    name: "pin34 value"
    service_uuid: '4fafc201-1fb5-459e-8fcc-c5c9c331914b'
    characteristic_uuid: 'cba1d466-344c-4be3-ab3f-189f80dd7518'
    update_interval: 1s

#include <dummy.h>

/*
    Based on Neil Kolban example for IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleWrite.cpp
    Ported to Arduino ESP32 by Evandro Copercini
*/
//This code is modified by Sachin Soni(techiesms) for ESP32 tutorial Series
// ESP32 Series :- https://www.youtube.com/playlist?list=PLruzZCuhcsGNFXfOPUfNqdhP3-7_Hh7F0

#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>


// 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"
#define uS_TO_S_FACTOR 1000000  //Conversion factor for micro seconds to seconds
#define TIME_TO_SLEEP  56        //Time ESP32 will go to sleep (in seconds)
#define mS_TO_S_FACTOR 1000  //Conversion factor for milli seconds to seconds
#define WAKE_TIME  4        //Time ESP32 it's awake (in seconds)

RTC_DATA_ATTR int bootCount = 0;


class MyCallbacks: public BLECharacteristicCallbacks 
{
    void onWrite(BLECharacteristic *pCharacteristic) 
    {
     std::string value = pCharacteristic->getValue();
     
      if (value.length() > 0) {
        if (value[0] > 0) {
          Serial.println("Valore inviato dal BLE Client: 1");
          digitalWrite(25,HIGH);
          Serial.println(millis());
        }
      } else Serial.println("empty value");   
    }
    };

// LED Blu Characteristic and Descriptor pin34
  BLECharacteristic LedBluCharacteristics("cba1d466-344c-4be3-ab3f-189f80dd7518", BLECharacteristic::PROPERTY_NOTIFY);
  BLEDescriptor LedBluDescriptor(BLEUUID((uint16_t)0x2902));


void setup() 
{
  Serial.begin(115200);

  pinMode(25,OUTPUT);
  Serial.println("Visualizza quanto trasmesso dal BLE Client a questo BLE Server: ");
  
  //Set timer to TIME_TO_SLEEP seconds
  esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
  // Serial.println("Setup ESP32 to sleep for every " + String(TIME_TO_SLEEP) +
  // " Seconds");
  Serial.println("ESP32 is awake for " +  String(WAKE_TIME) + " Seconds");
  Serial.println(millis());

  // Create the BLE Device 
  BLEDevice::init("MyESP32-Cosimo-New");

  // Create the BLE Server
  BLEServer *pServer = BLEDevice::createServer();

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

    
  // Set Characteristic valore da trasmettere
  BLECharacteristic *pCharacteristic = pService->createCharacteristic(
                                         CHARACTERISTIC_UUID,
                                         BLECharacteristic::PROPERTY_READ |
                                         BLECharacteristic::PROPERTY_WRITE
                                       );

  // Create BLE Characteristics and Create a BLE Descriptor
  // valore pin34
  pService->addCharacteristic(&LedBluCharacteristics);
  LedBluDescriptor.setValue("pin34");
  LedBluCharacteristics.addDescriptor(&LedBluDescriptor);
  
  pCharacteristic->setCallbacks(new MyCallbacks());

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

   // Start advertising
  BLEAdvertising *pAdvertising = pServer->getAdvertising();
  pAdvertising->start();

  // Legge il valore sul pin 34 
  float pin34 = analogRead(34);  
  static char pin34_C[7];
  dtostrf(pin34, 6, 2, pin34_C);

  //Set pin34 Characteristic value and notify connected client
  LedBluCharacteristics.setValue(pin34_C);
  LedBluCharacteristics.notify();
  Serial.print("Valore pin 34: ");
  Serial.print(pin34);
  Serial.println(""); // Carriage Return
  
  delay(WAKE_TIME * mS_TO_S_FACTOR);

  //Go to sleep now
  Serial.println(millis());
  Serial.println("ESP32 go to sleep for " + String(TIME_TO_SLEEP) + " Seconds");
  esp_deep_sleep_start();
  
}

void loop() {
  // put your main code here, to run repeatedly:
  delay(2000);
}

Credits

Ing. Cosimo Mercuro

1 project • 0 followers

Mechanical engineer. Mechatronics teacher in italian high school.