wip

components/esp32_nimble_mqtt_room/__init__.py

@@ -0,0 +1,39 @@
+import esphome.config_validation as cv
+import esphome.codegen as cg
+from esphome.const import (
+  CONF_ID,
+)
+from esphome.components import mqtt, nimble_tracker
+
+DEPENDENCIES = ["mqtt"]
+AUTO_LOAD=["nimble_distance_custom"]
+
+CONF_NIMBLE_ID = "esp32_nimble_mqtt_room"
+
+CONF_ROOM_KEY = 'room'
+CONF_BASE_TOPIC_KEY = 'base_topic'
+# CONF_MY_OPTIONAL_KEY = 'my_optional_key'
+CONF_MAC_KEY = 'mac_addr'
+
+esp32_nimble_tracker_ns = cg.esphome_ns.namespace("esp32_nimble_mqtt_room")
+ESP32NimbleMQTTRoom = esp32_nimble_tracker_ns.class_(
+    "ESP32NimbleMQTTRoom", cg.Component, nimble_tracker.NimbleDeviceListener
+)
+
+CONFIG_SCHEMA = cv.Schema({
+  cv.GenerateID(): cv.declare_id(ESP32NimbleMQTTRoom),
+  cv.Required(CONF_ROOM_KEY): cv.string,
+  cv.Required(CONF_MAC_KEY): cv.All(cv.ensure_list(cv.string)),
+  cv.Optional(CONF_BASE_TOPIC_KEY, default="esphome_presense"): cv.string,
+}).extend(cv.COMPONENT_SCHEMA).extend(nimble_tracker.NIMBLE_DEVICE_LISTENER_SCHEMA)
+
+async def to_code(config):
+  var = cg.new_Pvariable(config[CONF_ID])
+  await cg.register_component(var, config)
+
+  cg.add(var.set_room(config[CONF_ROOM_KEY]))
+  cg.add(var.set_base_topic(config[CONF_BASE_TOPIC_KEY]))
+  cg.add(var.set_addresses(config[CONF_MAC_KEY]))
+
+  await nimble_tracker.device_listener_to_code(var, config)
+  await nimble_tracker.register_ble_device(var, config)

components/esp32_nimble_mqtt_room/esp32_nimble_mqtt_room.cpp

@@ -0,0 +1,20 @@
+#include "esp32_nimble_mqtt_room.h"
+
+namespace esphome
+{
+    namespace esp32_nimble_mqtt_room
+    {
+        void ESP32NimbleMQTTRoom::on_result(nimble_distance_custom::NimbleDistanceCustomResult& result)
+        {
+            auto address = result.address.toString();
+
+            this->publish_json(
+                this->base_topic_ + "/devices/" + address + "/" + this->room_,
+                [=](ArduinoJson::JsonObject root) -> void {
+                    root["id"] = address;
+                    root["distance"] = result.distance;
+                }
+            );
+        };
+    } // namespace esp32_nimble_tracker
+} // namespace esphome

components/esp32_nimble_mqtt_room/esp32_nimble_mqtt_room.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/mqtt/custom_mqtt_device.h"
+#include "esphome/components/nimble_distance_custom/nimble_distance_custom.h"
+
+namespace esphome
+{
+    namespace esp32_nimble_mqtt_room
+    {
+        class ESP32NimbleMQTTRoom : 
+            public mqtt::CustomMQTTDevice, 
+            public nimble_distance_custom::NimbleDistanceCustomComponent
+        {
+            protected:
+                std::string room_;
+                std::string base_topic_ = "esphome_presense";
+            public:
+                void on_result(nimble_distance_custom::NimbleDistanceCustomResult&) override;
+                void set_room(std::string room) { room_ = room; }
+                void set_base_topic(std::string base_topic) { base_topic_ = base_topic; }
+        };
+    } // namespace esp32_nimble_tracker
+} // namespace esphome

components/esp32_nimble_tracker/__init__.py

@@ -0,0 +1,30 @@
+import esphome.config_validation as cv
+import esphome.codegen as cg
+from esphome.const import (
+  CONF_ID,
+)
+
+DEPENDENCIES = ["esp32"]
+
+# CONF_NIMBLE_ID = "esp32_nimble_tracker"
+
+CONF_MY_REQUIRED_KEY = 'my_required_key'
+CONF_MY_OPTIONAL_KEY = 'my_optional_key'
+
+esp32_nimble_tracker_ns = cg.esphome_ns.namespace("esp32_nimble_tracker")
+ESP32NimbleTracker = esp32_nimble_tracker_ns.class_(
+    "ESP32NimbleTracker", cg.Component
+)
+
+CONFIG_SCHEMA = cv.Schema({
+  cv.GenerateID(): cv.declare_id(ESP32NimbleTracker),
+  cv.Required(CONF_MY_REQUIRED_KEY): cv.string,
+  cv.Optional(CONF_MY_OPTIONAL_KEY, default=10): cv.int_,
+}).extend(cv.COMPONENT_SCHEMA)
+
+def to_code(config):
+  var = cg.new_Pvariable(config[CONF_ID])
+  yield cg.register_component(var, config)
+
+  await nimble_tracker.device_listener_to_code(var, config)
+  await nimble_tracker.register_ble_device(var, config)

components/esp32_nimble_tracker/esp32_nimble_tracker.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+
+namespace esphome
+{
+    namespace esp32_nimble_tracker
+    {
+        class ESP32NimbleTracker : public Component {};
+    } // namespace esp32_nimble_tracker
+} // namespace esphome

components/nimble_distance/sensor.py

@@ -1,38 +0,0 @@
-import esphome.codegen as cg
-import esphome.config_validation as cv
-from esphome.components import sensor, nimble_tracker
-from esphome.const import (
-    DEVICE_CLASS_DISTANCE,
-    STATE_CLASS_MEASUREMENT,
-    UNIT_METER,
-)
-
-DEPENDENCIES = ["nimble_tracker"]
-
-nimble_distance_ns = cg.esphome_ns.namespace("nimble_distance")
-NimbleDistanceSensor = nimble_distance_ns.class_(
-    "NimbleDistanceSensor",
-    sensor.Sensor,
-    cg.Component,
-    nimble_tracker.NimbleDeviceListener,
-)
-
-
-CONFIG_SCHEMA = cv.All(
-    sensor.sensor_schema(
-        NimbleDistanceSensor,
-        unit_of_measurement=UNIT_METER,
-        accuracy_decimals=2,
-        device_class=DEVICE_CLASS_DISTANCE,
-        state_class=STATE_CLASS_MEASUREMENT,
-    )
-    .extend(nimble_tracker.NIMBLE_DEVICE_LISTENER_SCHEMA)
-    .extend(cv.COMPONENT_SCHEMA),
-)
-
-
-async def to_code(config):
-    var = await sensor.new_sensor(config)
-    await cg.register_component(var, config)
-    await nimble_tracker.device_listener_to_code(var, config)
-    await nimble_tracker.register_ble_device(var, config)

components/nimble_distance_custom/__init__.py

@@ -0,0 +1,21 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import nimble_tracker
+from esphome.const import (
+    DEVICE_CLASS_DISTANCE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_METER,
+)
+
+DEPENDENCIES = ["nimble_tracker"]
+
+nimble_custom_distance_ns = cg.esphome_ns.namespace("nimble_custom_distance")
+NimbleDistanceCustomComponent = nimble_custom_distance_ns.class_(
+    "NimbleDistanceCustomComponent",
+    cg.Component,
+    nimble_tracker.NimbleDeviceListener,
+)
+
+CONFIG_SCHEMA = cv.Schema({
+  cv.GenerateID(): cv.declare_id(NimbleDistanceCustomComponent),  
+}).extend(cv.COMPONENT_SCHEMA).extend(nimble_tracker.NIMBLE_DEVICE_LISTENER_SCHEMA)

components/nimble_distance_custom/nimble_distance_custom.cpp

@@ -1,10 +1,10 @@
-#include "nimble_distance_sensor.h"
+#include "nimble_distance_custom.h"
 
 namespace esphome
 {
-    namespace nimble_distance
+    namespace nimble_distance_custom
     {
-        static const char *const TAG = "nimble_distance";
+        static const char *const TAG = "nimble_distance_custom";
 
         static int median_of_3(int a, int b, int c)
         {
@@ -14,7 +14,7 @@ namespace esphome
             int the_median = the_max ^ the_min ^ a ^ b ^ c;
             return (the_median);
         }
-        int NimbleDistanceSensor::get_1m_rssi(nimble_tracker::NimbleTrackerEvent *tracker_event)
+        int NimbleDistanceCustomComponent::get_1m_rssi(nimble_tracker::NimbleTrackerEvent *tracker_event)
         {
             return this->ref_rssi_; //+ tracker_event->getTXPower() + 99;
         }
@@ -34,7 +34,7 @@ namespace esphome
             return this->one_euro_.push(&inter1, &inter2) && this->diff_filter_.push(&inter2, &this->output);
         }
 
-        void NimbleDistanceSensor::setup()
+        void NimbleDistanceCustomComponent::setup()
         {
             this->filter_ = new Filter(ONE_EURO_FCMIN, ONE_EURO_BETA, ONE_EURO_DCUTOFF);
         }
@@ -43,7 +43,7 @@ namespace esphome
         // https://medium.com/beingcoders/convert-rssi-value-of-the-ble-bluetooth-low-energy-beacons-to-meters-63259f307283
         // and copied a lot of code from
         // https://github.com/ESPresense/ESPresense/blob/master/lib/BleFingerprint/BleFingerprint.cpp
-        bool NimbleDistanceSensor::update_state(nimble_tracker::NimbleTrackerEvent *tracker_event)
+        bool NimbleDistanceCustomComponent::update_state(nimble_tracker::NimbleTrackerEvent *tracker_event)
         {
             this->oldest_ = this->recent_;
             this->recent_ = this->newest_;
@@ -75,7 +75,15 @@ namespace esphome
 
             this->last_reported_micro_seconds_ = now;
             this->last_reported_position_ = this->filter_->output.value.position;
-            this->publish_state(this->filter_->output.value.position);
+            // /this->publish_state(this->filter_->output.value.position);
+
+            auto res = NimbleDistanceCustomResult{
+                tracker_event->getAddress(),
+                this->filter_->output.value.position
+            };
+
+            this->on_result(res);
+
             return true;
         }
     } // namespace nimble_distance

components/nimble_distance_custom/nimble_distance_custom.h

@@ -18,12 +18,11 @@
 
 // For NimbleDistanceSensor
 #include "esphome/core/component.h"
-#include "esphome/components/sensor/sensor.h"
 #include "esphome/components/nimble_tracker/nimble_tracker.h"
 
 namespace esphome
 {
-    namespace nimble_distance
+    namespace nimble_distance_custom
     {
         class Filter
         {
@@ -37,7 +36,13 @@ namespace esphome
             DifferentialFilter<float, unsigned long> diff_filter_;
         };
 
-        class NimbleDistanceSensor : public sensor::Sensor,
+        typedef struct
+        {
+            NimBLEAddress address;
+            float distance;
+        } NimbleDistanceCustomResult;
+
+        class NimbleDistanceCustomComponent:
                                      public Component,
                                      public nimble_tracker::NimbleDeviceListener
         {
@@ -47,6 +52,7 @@ namespace esphome
 
         protected:
             bool update_state(nimble_tracker::NimbleTrackerEvent *tracker_event) override;
+            virtual void on_result(NimbleDistanceCustomResult& result);
             Filter *filter_;
             int rssi_ = NO_RSSI, newest_ = NO_RSSI, recent_ = NO_RSSI, oldest_ = NO_RSSI;
 

components/nimble_tracker/nimble_device_listener.cpp

@@ -19,9 +19,9 @@ namespace esphome
             }
         }
 
-        void NimbleDeviceListener::set_address(std::string address) {
+        void NimbleDeviceListener::set_addresses(std::vector<std::string> addresses) {
             this->match_by_ = MATCH_BY_ADDRESS;
-            this->address_ = address;
+            this->addresses_ = addresses;
         }
 
         bool NimbleDeviceListener::parse_event(NimbleTrackerEvent *tracker_event)
@@ -51,7 +51,9 @@ namespace esphome
                 ESP_LOGD(TAG, "Found device %s", tracker_event->toString().c_str());
                 auto address = tracker_event->getAddress().toString();
 
-                if (this->address_ == address) {
+                auto &v = this->addresses_;
+
+                if(std::find(v.begin(), v.end(), address) != v.end()) {
                     return this->update_state(tracker_event);
                 } else {
                     return false;

components/nimble_tracker/nimble_device_listener.h

@@ -14,7 +14,7 @@ namespace esphome
         public:
             bool parse_event(NimbleTrackerEvent *tracker_event);
             void set_irk(std::string irk_hex);
-            void set_address(std::string address);
+            void set_addresses(std::vector<std::string>);
 
         protected:
             virtual bool update_state(NimbleTrackerEvent *tracker_event) = 0;
@@ -27,7 +27,7 @@ namespace esphome
             MatchType match_by_;
 
             uint8_t *irk_;
-            std::string address_;
+            std::vector<std::string> addresses_;
         };
 
     } // namespace nimble_tracker