Skip to content
  • Home
  • Aktuell
  • Tags
  • 0 Ungelesen 0
  • Kategorien
  • Unreplied
  • Beliebt
  • GitHub
  • Docu
  • Hilfe
Skins
  • Light
  • Brite
  • Cerulean
  • Cosmo
  • Flatly
  • Journal
  • Litera
  • Lumen
  • Lux
  • Materia
  • Minty
  • Morph
  • Pulse
  • Sandstone
  • Simplex
  • Sketchy
  • Spacelab
  • United
  • Yeti
  • Zephyr
  • Dark
  • Cyborg
  • Darkly
  • Quartz
  • Slate
  • Solar
  • Superhero
  • Vapor

  • Standard: (Kein Skin)
  • Kein Skin
Einklappen
ioBroker Logo

Community Forum

  1. ioBroker Community Home
  2. Deutsch
  3. Off Topic
  4. Microcontroller
  5. Tasmota ESPHome Presence Sensor LD2410

NEWS

  • UPDATE 31.10.: Amazon Alexa - ioBroker Skill läuft aus ?
    apollon77A
    apollon77
    48
    3
    8.3k

  • Monatsrückblick – September 2025
    BluefoxB
    Bluefox
    13
    1
    2.0k

  • Neues Video "KI im Smart Home" - ioBroker plus n8n
    BluefoxB
    Bluefox
    15
    1
    2.4k

Tasmota ESPHome Presence Sensor LD2410

Geplant Angeheftet Gesperrt Verschoben Microcontroller
187 Beiträge 17 Kommentatoren 45.5k Aufrufe 18 Watching
  • Älteste zuerst
  • Neuste zuerst
  • Meiste Stimmen
Antworten
  • In einem neuen Thema antworten
Anmelden zum Antworten
Dieses Thema wurde gelöscht. Nur Nutzer mit entsprechenden Rechten können es sehen.
  • ZarelloZ Zarello

    Kleiner Wasserstandsbericht von mir:
    Wenn man sonst so gut wie nichts auf dem ESP8266 laufen lässt und auch die Stats nicht abholt, funktioniert der Sensor bei mir.
    Sobald ein PWM für 'ne LED nebenbei laufen soll, kommt der ESP nicht mehr hinterher. Auch Updates funktionieren dann bei mir nur noch, wenn ich den LD2410 abklemme und den Sensor über USB aktualisiere. Über WLAN kann ich das dann komplett vergessen.
    Es liegt möglicherweise auch daran, dass ich das Ganze etwas umgebaut habe, damit die maximalen Entfernungen für bewegte und bewegungslose Personen getrennt angegeben werden können und alle Sensitivitäten für die Bereiche getrennt angegeben werden können.

    Bisher sind bei einem Neustart immer die eingestellten Werte wieder zurückgesetzt. Egal wie ich es probiert habe (ob vom LD2410 beim Start auslesen oder die Werte des ESPHome wieder zum Sensor schreiben) hat es bisher nicht funktionert, dass er seine Konfiguration behalten hat.

    Da ich des öfteren Meldungen hatte, dass nicht mehr genug Speicher für eine Allokation vorhanden ist, habe ich sämtlichen dynamischen Speicherallokationen soweit wie möglich entfernt bzw. reduziert.

    @liv-in-sky : Das Setzen der Werte von aussen über MQTT funktioniert übrigens über einen anderen Topic als das auslesen. Die Topics zum Setzen der Werte haben per Default am Ende command statt state. Leider muss man die erst erzeugen lassen indem man z.B. über die Kommandozeile ein entsprechenden Topic einfach postet.
    (z.B.:mosquitto_pub -t ledtest/config/motion_hold_cmd -m 2 -- angepasst an die geänderten Topics, wie ich sie in meiner YAML verwendet habe).
    Dann muss man noch in den Objekteigenschaften im MQTT-Bereich publish auf true setzen.

    Hier erstmal meine Sourcen, wie sie zur Zeit bei mir rumliegen:

    #include "esphome.h"
    #include <iterator>
    #include <deque>
    
    template<class T, unsigned size_>
    class CyclicBuffer
    {
      size_t _start {0};
      size_t _end {0};
      bool _values_dropped {false};
      std::array<T,size_> _buffer;
    
    public:
      class iterator : public std::iterator<std::bidirectional_iterator_tag, T>
      {
        CyclicBuffer& _b;
        size_t _pos;
    
      public:
        iterator (CyclicBuffer& b, size_t pos)
        : _b (b), _pos (pos) {};
    
        // prefix++
        iterator& operator++ () { _pos = _pos+1; return *this; }
        iterator operator++ (int) { iterator i = *this; _pos = _pos+1; return i; }
        T& operator* () { return _b[_pos]; }
        T* operator-> () { return &(_b[_pos]); }
        bool operator== (const iterator& other) const { return _pos == other._pos; }
        bool operator!= (const iterator& other) const { return _pos != other._pos; }
      };
    
      size_t size () const { return (_end + size_ - _start) % size_; }
      iterator begin () { return iterator(*this, 0);}
      iterator end () { return iterator(*this, (_end + size_ - _start) % size_);}
      T& operator[] (size_t pos) { return _buffer[(_start+pos)%size_]; }
      const T& operator[] (size_t pos) const { return _buffer[(_start+pos)%size_]; }
    
      void clear () { _end = _start; }
    
      void push_back (const T &v)
       {
        if (((_end + 1) % size_) == _start)
        {
          _values_dropped = true;
          return;
        }
    
        _buffer[_end] = v;
        _end = (_end+1) % size_;
      }
    
      void pop_front ()
      {
        if (_start != _end)
          _start = (_start + 1) % size_;
      }
    };
    
    /*
    TARGET EXAMPLE DATA
    {F4:F3:F2:F1}:{0D:00}:{02}:{AA}: 02  : 4B:00:  4F  : 00:00 : 64   :  29:00 :{55}: {00} :{F8:F7:F6:F5}
    {  header   }  {len}  {typ}{hd}{state}{mdist}{mval}{stadis}{staval}{decdis} {tl} {chck} {    MFR    }
    */
    typedef struct
    {
        uint32_t MFR;
        uint16_t len;
        uint8_t type;                 // target or engineering
        uint8_t head;                // fixed head
        uint8_t state;              // state
        uint8_t movdist;          // movement distance
        uint8_t movdist2;          // movement distance
        uint8_t movval;           // movement energy value
        uint8_t stadist;        // stationary distance
        uint8_t stadist2;        // stationary distance
        uint8_t staval;         // stationary energy value
        uint8_t decdist;      // detection distance
        uint8_t decdist2;      // detection distance
        uint8_t tail;         // tail
        uint8_t chk;         // unused
        uint32_t MFR_end ;  // end
    } TARGET;
    
    /*
    CONF EXAMPLE DATA
    FD:FC:FB:FA MFR[0-3]
    1C:00 len[4-5]
    61:01 CMD[6-7]
    00:00 ACKstat[8-9]
    AA Head [10]
    08 maxDist [11]
    06 maxMovDist[12]
    06 maxStaDist[13]
    1E:1E:1E:1E:1E:1E:1E:1E:1E:1E:1E:1E:1E:1E:1E:1E:1E:1E (9mov & 9sta sensitivities)
    5A:00 none[32-33]
    04:03:02:01[34-37]
    */
    typedef struct
    {
        uint32_t MFR;
        uint16_t len;
        uint8_t cmd;
        uint8_t cmd_val;
        uint8_t ack_stat;
        uint8_t ack_stathigh;
        uint8_t head;
        uint8_t max_dist;
        uint8_t max_mov_dist;
        uint8_t max_sta_dist;
        uint8_t mov0sen;
        uint8_t mov1sen;
        uint8_t mov2sen;
        uint8_t mov3sen;
        uint8_t mov4sen;
        uint8_t mov5sen;
        uint8_t mov6sen;
        uint8_t mov7sen;
        uint8_t mov8sen;
        uint8_t sta0sen;
        uint8_t sta1sen;
        uint8_t sta2sen;
        uint8_t sta3sen;
        uint8_t sta4sen;
        uint8_t sta5sen;
        uint8_t sta6sen;
        uint8_t sta7sen;
        uint8_t sta8sen;
        uint16_t none;
        uint32_t MFR_end;
    } CONF;
    
    class LD2410 : public Component, public UARTDevice
    {
    public:
      //using BufferType = std::deque<uint8_t>;
      using BufferType = CyclicBuffer<uint8_t, 120>;
    
      BufferType bytes;
      const std::array<uint8_t, 6> config_header = {0xFD, 0xFC, 0xFB, 0xFA, 0x1C, 0x00};
      const std::array<uint8_t, 6> target_header = {0xF4, 0xF3, 0xF2, 0xF1, 0x0D, 0x00};
      const std::array<uint8_t, 6> ld2410_end_conf = {0x04, 0x03, 0x02, 0x01};
    
      LD2410(UARTComponent *parent);
    
      void setup() override;
      void loop() override;
    
      void setConfigMode(bool confenable);
      void setSensitivity(int gate, int senval_mov, int senval_sta);
      void setMaxDistancesAndNoneDuration(int maxMovingDistanceRange, int maxStillDistanceRange, int noneDuration);
      void queryParameters();
      void restart();
    
    private:
      void setMaxDistancesAndNoneDurationImpl(int maxMovingDistanceRange, int maxStillDistanceRange, int noneDuration);
      void queryParametersImpl();
      void factoryReset();
      void reboot();
      void ESP_LOGD_HEX(std::vector<uint8_t> bytes, uint8_t separator);
      void sendCommand(char *commandStr, char *commandValue, int commandValueLen);
      int twoByteToInt(char firstByte, char secondByte);
      void handleTargetData(BufferType buffer);
      void handleConfData(BufferType buffer);
    
      void setEngineeringMode(bool engenable);
      void setSensitivityImpl(int gate, int senval_mov, int senval_sta);
      void setBaudrate(int index);
      bool doesHeaderMatch(BufferType bytes, std::array<uint8_t,6> header);
    
      typedef union
      {
        TARGET target;
        uint8_t bytes[sizeof(TARGET)];
      } TARGETUnion;
    
      typedef union
      {
        CONF conf;
        uint8_t bytes[sizeof(CONF)];
      } CONFUnion;
    };
    
    LD2410::LD2410(UARTComponent *parent) : UARTDevice(parent)
    {
    }
    
    void LD2410::setup()
    {
      setConfigMode (true);
    #if 0
      setMaxDistancesAndNoneDurationImpl(id(maxconfigDistanceMoving).state / 0.75,
                                         id(maxconfigDistanceStill).state / 0.75,
                                         id(noneDuration).state);
      setSensitivityImpl(0, id(sensitivity0Moving).state, id(sensitivity0Still).state);
      setSensitivityImpl(1, id(sensitivity1Moving).state, id(sensitivity1Still).state);
      setSensitivityImpl(2, id(sensitivity2Moving).state, id(sensitivity2Still).state);
      setSensitivityImpl(3, id(sensitivity3Moving).state, id(sensitivity3Still).state);
      setSensitivityImpl(4, id(sensitivity4Moving).state, id(sensitivity4Still).state);
      setSensitivityImpl(5, id(sensitivity5Moving).state, id(sensitivity5Still).state);
      setSensitivityImpl(6, id(sensitivity6Moving).state, id(sensitivity6Still).state);
      setSensitivityImpl(7, id(sensitivity7Moving).state, id(sensitivity7Still).state);
      setSensitivityImpl(8, id(sensitivity8Moving).state, id(sensitivity8Still).state);
    #endif
      queryParametersImpl();
      setConfigMode (false);
    }
    
    void LD2410::loop()
    {
      while (available())
      {
        bytes.push_back(read());
        while (bytes.size() >= 6)
        {
          if (doesHeaderMatch(bytes, config_header))
          {
            if (bytes.size() < sizeof(CONF))
            {
              break;
            }
            handleConfData(bytes);
            bytes.clear();
          }
          else if (doesHeaderMatch(bytes, target_header)) {
            if (bytes.size() < sizeof(TARGET))
            {
              break;
            }
            handleTargetData(bytes);
            bytes.clear();
          }
          else
          {
            //ESP_LOGD("custom", "erase one byte");
            bytes.pop_front();
          }
        }
      }
    }
    
    void LD2410::ESP_LOGD_HEX(std::vector<uint8_t> bytes, uint8_t separator)
    {
      std::string res;
      size_t len = bytes.size();
      char buf[5];
      for (size_t i = 0; i < len; i++) {
        if (i > 0) {
          res += separator;
        }
        sprintf(buf, "%02X", bytes[i]);
        res += buf;
      }
      ESP_LOGD("custom", "%s", res.c_str());
    }
    
    void LD2410::sendCommand(char *commandStr, char *commandValue, int commandValueLen)
    {
      uint16_t len = 2;
      if (commandValue != nullptr) {
        len += commandValueLen;
      }
      static std::vector<uint8_t> ld2410_conf = {0xFD, 0xFC, 0xFB, 0xFA};
      size_t needed_size = 8 + (commandValue != nullptr ? commandValueLen : 0) + ld2410_end_conf.size ();
      if (ld2410_conf.capacity () < needed_size)
        ld2410_conf.reserve (needed_size);
    
      ld2410_conf.resize (8);
      ld2410_conf[4] = lowByte(len);
      ld2410_conf[5] = highByte(len);
      ld2410_conf[6] = commandStr[0];
      ld2410_conf[7] = commandStr[1];
    
      if (commandValue != nullptr)
      {
        for (int i = 0; i < commandValueLen; i++)
        {
          ld2410_conf.push_back(commandValue[i]);
        }
      }
      for (int i = 0; i < ld2410_end_conf.size(); i++) 
      {
        ld2410_conf.push_back(ld2410_end_conf[i]);
      }
      // ESP_LOGD_HEX(ld2410_conf,':');
      write_array(ld2410_conf);
    }
    
    int LD2410::twoByteToInt(char firstByte, char secondByte)
    {
      return (int16_t)(secondByte << 8) + firstByte;
    }
    
    void LD2410::handleTargetData(BufferType buffer)
    {
      static TARGETUnion targetUnion;
      std::copy(buffer.begin(), buffer.end(), targetUnion.bytes);
      if (id(show_stats).state == 1 && targetUnion.target.type == 0x02 && targetUnion.target.state != 0x00)
      {
        int movdist = twoByteToInt(targetUnion.target.movdist, targetUnion.target.movdist2);
        if (id(movingTargetDistance).state != movdist)
        {
          id(movingTargetDistance).publish_state(movdist);
        }
        if (id(movingTargetEnergy).state != targetUnion.target.movval)
        {
          id(movingTargetEnergy).publish_state(targetUnion.target.movval);
        }
        int stadist = twoByteToInt(targetUnion.target.stadist, targetUnion.target.stadist2);
        if (id(stillTargetDistance).state != stadist)
        {
          id(stillTargetDistance).publish_state(stadist);
        }
        if (id(stillTargetEnergy).state != targetUnion.target.staval)
        {
          id(stillTargetEnergy).publish_state(targetUnion.target.staval);
        }
        int decdist = twoByteToInt(targetUnion.target.decdist, targetUnion.target.decdist2);
        if (id(detectDistance).state != decdist)
        {
          id(detectDistance).publish_state(decdist);
        }
      }
      else 
      {
        return; 
      }
      // Engineering data - datasheet is horrible
      // if (targetUnion.target.type == 0x01)
      // }
    }
    
    void LD2410::handleConfData(BufferType buffer)
    {
      static CONFUnion confUnion;
      std::copy(buffer.begin(), buffer.end(), confUnion.bytes);
      if (confUnion.conf.cmd == 0x61 && confUnion.conf.cmd_val == 0x01
          && confUnion.conf.ack_stat == 0x00 && confUnion.conf.head == 0xAA)
      {
        id(maxconfigDistanceMoving).publish_state(float(confUnion.conf.max_mov_dist * 0.75));
        id(maxconfigDistanceStill).publish_state(float(confUnion.conf.max_sta_dist * 0.75));
        id(sensitivity0Moving).publish_state(confUnion.conf.mov0sen);
        id(sensitivity0Still).publish_state(confUnion.conf.sta0sen);
        id(sensitivity1Moving).publish_state(confUnion.conf.mov1sen);
        id(sensitivity1Still).publish_state(confUnion.conf.sta1sen);
        id(sensitivity2Moving).publish_state(confUnion.conf.mov2sen);
        id(sensitivity2Still).publish_state(confUnion.conf.sta2sen);
        id(sensitivity3Moving).publish_state(confUnion.conf.mov3sen);
        id(sensitivity3Still).publish_state(confUnion.conf.sta3sen);
        id(sensitivity4Moving).publish_state(confUnion.conf.mov4sen);
        id(sensitivity4Still).publish_state(confUnion.conf.sta4sen);
        id(sensitivity5Moving).publish_state(confUnion.conf.mov5sen);
        id(sensitivity5Still).publish_state(confUnion.conf.sta5sen);
        id(sensitivity6Moving).publish_state(confUnion.conf.mov6sen);
        id(sensitivity6Still).publish_state(confUnion.conf.sta6sen);
        id(sensitivity7Moving).publish_state(confUnion.conf.mov7sen);
        id(sensitivity7Still).publish_state(confUnion.conf.sta7sen);
        id(sensitivity8Moving).publish_state(confUnion.conf.mov8sen);
        id(sensitivity8Still).publish_state(confUnion.conf.sta8sen);
        id(noneDuration).publish_state(confUnion.conf.none);
      }
    }
    
    void LD2410::setConfigMode(bool confenable)
    {
      char cmd[2] = {char (confenable ? 0xFF : 0xFE),0x00};
      char value[2] = {0x01, 0x00};
      sendCommand(cmd, confenable ? value : nullptr, 2);
    }
    
    void LD2410::queryParameters()
    {
      setConfigMode (true);
      queryParametersImpl();
      setConfigMode (false);
    }
    
    void LD2410::queryParametersImpl()
    {
      char cmd_query[2] = {0x61, 0x00};
      sendCommand(cmd_query, nullptr, 0);
    }
    
    void LD2410::setEngineeringMode(bool engenable)
    {
      char cmd[2] = {char (engenable ? 0x62 : 0x63),0x00};
      sendCommand(cmd, nullptr, 0);
    }
    
    void LD2410::setMaxDistancesAndNoneDuration(int maxMovingDistanceRange, int maxStillDistanceRange, int noneDuration)
    {
      setConfigMode (true);
      setMaxDistancesAndNoneDurationImpl(maxMovingDistanceRange, maxStillDistanceRange, noneDuration);
      setConfigMode (false);
    }
    
    void LD2410::setMaxDistancesAndNoneDurationImpl(int maxMovingDistanceRange, int maxStillDistanceRange, int noneDuration)
    {
      char cmd[2] = {0x60, 0x00};
      char value[18] = {0x00, 0x00, lowByte(maxMovingDistanceRange), highByte(maxMovingDistanceRange), 0x00, 0x00,
                        0x01, 0x00, lowByte(maxStillDistanceRange), highByte(maxStillDistanceRange), 0x00, 0x00,
                        0x02, 0x00, lowByte(noneDuration), highByte(noneDuration), 0x00, 0x00};
      sendCommand(cmd, value, sizeof(value));
    }
    
    void LD2410::setSensitivityImpl(int gate, int senval_mov, int senval_sta)
    {
      ESP_LOGD("custom", "set sensitivity for gate %d to (%d / %d)", gate, senval_mov, senval_sta);
      //  64 00  00 00  FF FF 00 00 01 00  28 00 00 00 02 00 28 00 00 00 04 03 02 01
      // {cmd  }{dword}{   dgate  }{mword} {   mval   }{sword}{   sval   }{    MFR  }
      char cmd[2] = {0x64, 0x00};
      char value[18] = {0x00, 0x00, lowByte(gate), highByte(gate), 0x00, 0x00,
                        0x01, 0x00, lowByte(senval_mov), highByte(senval_mov), 0x00, 0x00,
                        0x02, 0x00, lowByte(senval_sta), highByte(senval_sta), 0x00, 0x00};
      sendCommand(cmd, value, sizeof(value));
    }
    
    void LD2410::setSensitivity(int gate, int senval_mov, int senval_sta)
    {
      setConfigMode (true);
      setSensitivityImpl(gate, senval_mov, senval_sta);
      setConfigMode (false);
    }
    
    void LD2410::restart()
    {
      setConfigMode (true);
      factoryReset ();
      reboot ();
    }
    
    void LD2410::factoryReset()
    {
      char cmd[2] = {0xA2, 0x00};
      sendCommand(cmd, nullptr, 0);
    }
    
    void LD2410::reboot()
    {
      char cmd[2] = {0xA3, 0x00};
      sendCommand(cmd, nullptr, 0);
      // not need to exit config mode because the ld2410 will reboot automatically
    }
    
    void LD2410::setBaudrate(int index)
    {
      char cmd[2] = {0xA1, 0x00};
      char value[2] = {char (index), 0x00};
      sendCommand(cmd, value, sizeof(value));
    }
    
    bool LD2410::doesHeaderMatch(BufferType bytes, std::array<uint8_t,6> header)
    {
      return std::equal(header.begin(), header.end(), bytes.begin());
    }
    

    esphome:
      name: led-test
      friendly_name: led-test
      includes:
        - uart_read_line_sensor_ld2410v3.h
    #  on_boot:
    #    priority: -100
    #    then:
    #      - script.execute: get_config
    
    
    esp8266:
      board: d1_mini
    
    wifi:
      ssid: !secret wifi_ssid
      password: !secret wifi_password
    
      # Enable fallback hotspot (captive portal) in case wifi connection fails
      ap:
        ssid: !secret ap_ssid
        password: !secret ap_password
    
    ota:
      password: !secret ota_password
    
    # Enable logging
    logger:
      baud_rate: 0
    
    web_server:
      port: 80
    
    mqtt:
      broker: 192.168.1.33
      username: ledtest
    #  password: !secret mqtt_password
      topic_prefix: ledtest
    
    uart:
      id: uart1
      tx_pin: TX
      rx_pin: RX
      baud_rate: 256000
      parity: NONE
      stop_bits: 1
    
    #light:
    #  - platform: monochromatic
    #    name: "RGB-LED Red"
    #    output: output_r
    #  - platform: monochromatic
    #    name: "RGB-LED Green"
    #    output: output_g
    #  - platform: monochromatic
    #    name: "RGB-LED Blue"
    #    output: output_b
    
    output:
    #  - platform: esp8266_pwm
    #    id: output_r
    #    pin: D1
    #    inverted: true
    #    frequency: 50 Hz
    #    #max_power: 50%
    #  - platform: esp8266_pwm
    #    id: output_g
    #    pin: D2
    #    inverted: true
    #    frequency: 50 Hz
    #    #max_power: 50%
    #  - platform: esp8266_pwm
    #    id: output_b
    #    pin: D3
    #    inverted: true
    #    frequency: 50 Hz
    #    #max_power: 50%
      - platform: gpio
        pin: D1
        id: led_red
        inverted: true
      - platform: gpio
        pin: D2
        id: led_green
        inverted: true
      - platform: gpio
        pin: D3
        id: led_blue
        inverted: true
    
    captive_portal:
    
    switch:
    # - platform: safe_mode
    #   name: use_safe_mode
       
     - platform: template
       name: configmode
       id: configmode
       optimistic: true
       # assumed_state: false
       internal: true
       turn_on_action:
         # - switch.turn_off: engineering_mode
         - lambda: 'static_cast<LD2410 *>(ld2410)->setConfigMode(true);'
         - delay: 100ms
         - script.execute: clear_targets
       turn_off_action:
         - lambda: 'static_cast<LD2410 *>(ld2410)->setConfigMode(false);'
    
     - platform: template
       name: show_target_stats
       id: show_stats
       optimistic: true
       internal: false
       turn_off_action:
         - script.execute: clear_targets
    
    sensor:
    #  - platform: wifi_signal
    #    name: "Wifi Power"
    #    update_interval: 10s
    
     - platform: template
       name: movingTargetDistance
       id: movingTargetDistance
       unit_of_measurement: "cm"
       accuracy_decimals: 0
       internal: false
       state_topic: ledtest/moveDistance
       
     - platform: template
       name: movingTargetEnergy
       id: movingTargetEnergy
       unit_of_measurement: "%"
       accuracy_decimals: 0
       internal: false
       state_topic: ledtest/moveEnergy
       
     - platform: template
       name: stillTargetDistance
       id: stillTargetDistance
       unit_of_measurement: "cm"
       accuracy_decimals: 0
       internal: false
       state_topic: ledtest/stillDistance
       
     - platform: template
       name: stillTargetEnergy
       id: stillTargetEnergy
       unit_of_measurement: "%"
       accuracy_decimals: 0
       internal: false
       state_topic: ledtest/stillEnergy
       
     - platform: template
       name: detectDistance
       id: detectDistance
       unit_of_measurement: "cm"
       accuracy_decimals: 0
       internal: false
       state_topic: ledtest/distance
       
    custom_component:
     - lambda: |-
         return {new LD2410(id(uart1))};
       components:
         - id: ld2410
    
    
    binary_sensor:
     - platform: gpio
       name: mmwave_presence_ld2410
       id: mmwave_presence_ld2410
       pin: D7
       device_class: motion
       state_topic: ledtest/occupancy
       on_state:
         then:
           - if: 
               condition: 
                 - binary_sensor.is_off: mmwave_presence_ld2410
               then: 
                 - delay: 150ms
                 - script.execute: clear_targets
                 - output.turn_off:
                    id: led_blue
               else: 
                 - output.turn_on:
                    id: led_blue
    
    number:
     - platform: template
       name: configMaxDistanceMoving
       id: maxconfigDistanceMoving
       unit_of_measurement: "M"
       min_value: 0.75
       max_value: 6
       step: 0.75
       update_interval: never
       optimistic: true
       state_topic: ledtest/config/dist_max_move
       command_topic: ledtest/config/dist_max_move_cmd
       on_value:
         - lambda: |-
             auto uart_component = static_cast<LD2410 *>(ld2410);
             uart_component->setMaxDistancesAndNoneDuration(x/0.75,id(maxconfigDistanceStill).state/0.75,id(noneDuration).state);
    
     - platform: template
       name: configMaxDistanceStill
       id: maxconfigDistanceStill
       unit_of_measurement: "M"
       min_value: 0.75
       max_value: 6
       step: 0.75
       update_interval: never
       optimistic: true
       state_topic: ledtest/config/dist_max_still
       command_topic: ledtest/config/dist_max_still_cmd
       on_value:
         - lambda: |-
             auto uart_component = static_cast<LD2410 *>(ld2410);
             uart_component->setMaxDistancesAndNoneDuration(id(maxconfigDistanceMoving).state/0.75,x/0.75,id(noneDuration).state);
    
     - platform: template
       name: "sensitivity_threshold_0_moving"
       id: sensitivity0Moving
       min_value: 10
       max_value: 100
       step: 5
       mode: box
       update_interval: never
       optimistic: true
       state_topic: ledtest/config/sens_threshold_0_move
       command_topic: ledtest/config/sens_threshold_0_move_cmd
       on_value:
         - lambda: |-
             auto uart_component = static_cast<LD2410 *>(ld2410);
             uart_component->setSensitivity(0,x,id(sensitivity0Still).state);
         
     - platform: template
       name: "sensitivity_threshold_0_still"
       id: sensitivity0Still
       min_value: 10
       max_value: 100
       step: 5
       mode: box
       update_interval: never
       optimistic: true
       state_topic: ledtest/config/sens_threshold_0_still
       command_topic: ledtest/config/sens_threshold_0_still_cmd
       on_value:
         - lambda: |-
             auto uart_component = static_cast<LD2410 *>(ld2410);
             uart_component->setSensitivity(0,id(sensitivity0Moving).state,x);
         
     - platform: template
       name: "sensitivity_threshold_1_moving"
       id: sensitivity1Moving
       min_value: 10
       max_value: 100
       step: 5
       mode: box
       update_interval: never
       optimistic: true
       state_topic: ledtest/config/sens_threshold_1_move
       command_topic: ledtest/config/sens_threshold_1_move_cmd
       on_value:
         - lambda: |-
             auto uart_component = static_cast<LD2410 *>(ld2410);
             uart_component->setSensitivity(1,x,id(sensitivity1Still).state);
         
     - platform: template
       name: "sensitivity_threshold_1_still"
       id: sensitivity1Still
       min_value: 10
       max_value: 100
       step: 5
       mode: box
       update_interval: never
       optimistic: true
       state_topic: ledtest/config/sens_threshold_1_still
       command_topic: ledtest/config/sens_threshold_1_still_cmd
       on_value:
         - lambda: |-
             auto uart_component = static_cast<LD2410 *>(ld2410);
             uart_component->setSensitivity(1,id(sensitivity1Moving).state,x);
         
     - platform: template
       name: "sensitivity_threshold_2_moving"
       id: sensitivity2Moving
       min_value: 10
       max_value: 100
       step: 5
       mode: box
       update_interval: never
       optimistic: true
       state_topic: ledtest/config/sens_threshold_2_move
       command_topic: ledtest/config/sens_threshold_2_move_cmd
       on_value:
         - lambda: |-
             auto uart_component = static_cast<LD2410 *>(ld2410);
             uart_component->setSensitivity(2,x,id(sensitivity2Still).state);
         
     - platform: template
       name: "sensitivity_threshold_2_still"
       id: sensitivity2Still
       min_value: 10
       max_value: 100
       step: 5
       mode: box
       update_interval: never
       optimistic: true
       state_topic: ledtest/config/sens_threshold_2_still
       command_topic: ledtest/config/sens_threshold_2_still_cmd
       on_value:
         - lambda: |-
             auto uart_component = static_cast<LD2410 *>(ld2410);
             uart_component->setSensitivity(2,id(sensitivity2Moving).state,x);
         
     - platform: template
       name: "sensitivity_threshold_3_moving"
       id: sensitivity3Moving
       min_value: 10
       max_value: 100
       step: 5
       mode: box
       update_interval: never
       optimistic: true
       state_topic: ledtest/config/sens_threshold_3_move
       command_topic: ledtest/config/sens_threshold_3_move_cmd
       on_value:
         - lambda: |-
             auto uart_component = static_cast<LD2410 *>(ld2410);
             uart_component->setSensitivity(3,x,id(sensitivity3Still).state);
         
     - platform: template
       name: "sensitivity_threshold_3_still"
       id: sensitivity3Still
       min_value: 10
       max_value: 100
       step: 5
       mode: box
       update_interval: never
       optimistic: true
       state_topic: ledtest/config/sens_threshold_3_still
       command_topic: ledtest/config/sens_threshold_3_still_cmd
       on_value:
         - lambda: |-
             auto uart_component = static_cast<LD2410 *>(ld2410);
             uart_component->setSensitivity(3,id(sensitivity3Moving).state,x);
         
     - platform: template
       name: "sensitivity_threshold_4_moving"
       id: sensitivity4Moving
       min_value: 10
       max_value: 100
       step: 5
       mode: box
       update_interval: never
       optimistic: true
       state_topic: ledtest/config/sens_threshold_4_move
       command_topic: ledtest/config/sens_threshold_4_move_cmd
       on_value:
         - lambda: |-
             auto uart_component = static_cast<LD2410 *>(ld2410);
             uart_component->setSensitivity(4,x,id(sensitivity4Still).state);
         
     - platform: template
       name: "sensitivity_threshold_4_still"
       id: sensitivity4Still
       min_value: 10
       max_value: 100
       step: 5
       mode: box
       update_interval: never
       optimistic: true
       state_topic: ledtest/config/sens_threshold_4_still
       command_topic: ledtest/config/sens_threshold_4_still_cmd
       on_value:
         - lambda: |-
             auto uart_component = static_cast<LD2410 *>(ld2410);
             uart_component->setSensitivity(4,id(sensitivity4Moving).state,x);
         
     - platform: template
       name: "sensitivity_threshold_5_moving"
       id: sensitivity5Moving
       min_value: 10
       max_value: 100
       step: 5
       mode: box
       update_interval: never
       optimistic: true
       state_topic: ledtest/config/sens_threshold_5_move
       command_topic: ledtest/config/sens_threshold_5_move_cmd
       on_value:
         - lambda: |-
             auto uart_component = static_cast<LD2410 *>(ld2410);
             uart_component->setSensitivity(5,x,id(sensitivity5Still).state);
         
     - platform: template
       name: "sensitivity_threshold_5_still"
       id: sensitivity5Still
       min_value: 10
       max_value: 100
       step: 5
       mode: box
       update_interval: never
       optimistic: true
       state_topic: ledtest/config/sens_threshold_5_still
       command_topic: ledtest/config/sens_threshold_5_still_cmd
       on_value:
         - lambda: |-
             auto uart_component = static_cast<LD2410 *>(ld2410);
             uart_component->setSensitivity(5,id(sensitivity5Moving).state,x);
         
     - platform: template
       name: "sensitivity_threshold_6_moving"
       id: sensitivity6Moving
       min_value: 10
       max_value: 100
       step: 5
       mode: box
       update_interval: never
       optimistic: true
       state_topic: ledtest/config/sens_threshold_6_move
       command_topic: ledtest/config/sens_threshold_6_move_cmd
       on_value:
         - lambda: |-
             auto uart_component = static_cast<LD2410 *>(ld2410);
             uart_component->setSensitivity(6,x,id(sensitivity6Still).state);
         
     - platform: template
       name: "sensitivity_threshold_6_still"
       id: sensitivity6Still
       min_value: 10
       max_value: 100
       step: 5
       mode: box
       update_interval: never
       optimistic: true
       state_topic: ledtest/config/sens_threshold_6_still
       command_topic: ledtest/config/sens_threshold_6_still_cmd
       on_value:
         - lambda: |-
             auto uart_component = static_cast<LD2410 *>(ld2410);
             uart_component->setSensitivity(6,id(sensitivity6Moving).state,x);
         
     - platform: template
       name: "sensitivity_threshold_7_moving"
       id: sensitivity7Moving
       min_value: 10
       max_value: 100
       step: 5
       mode: box
       update_interval: never
       optimistic: true
       state_topic: ledtest/config/sens_threshold_7_move
       command_topic: ledtest/config/sens_threshold_7_move_cmd
       on_value:
         - lambda: |-
             auto uart_component = static_cast<LD2410 *>(ld2410);
             uart_component->setSensitivity(7,x,id(sensitivity7Still).state);
         
     - platform: template
       name: "sensitivity_threshold_7_still"
       id: sensitivity7Still
       min_value: 10
       max_value: 100
       step: 5
       mode: box
       update_interval: never
       optimistic: true
       state_topic: ledtest/config/sens_threshold_7_still
       command_topic: ledtest/config/sens_threshold_7_still_cmd
       on_value:
         - lambda: |-
             auto uart_component = static_cast<LD2410 *>(ld2410);
             uart_component->setSensitivity(7,id(sensitivity7Moving).state,x);
         
     - platform: template
       name: "sensitivity_threshold_8_moving"
       id: sensitivity8Moving
       min_value: 10
       max_value: 100
       step: 5
       mode: box
       update_interval: never
       optimistic: true
       state_topic: ledtest/config/sens_threshold_8_move
       command_topic: ledtest/config/sens_threshold_8_move_cmd
       on_value:
         - lambda: |-
             auto uart_component = static_cast<LD2410 *>(ld2410);
             uart_component->setSensitivity(8,x,id(sensitivity8Still).state);
         
     - platform: template
       name: "sensitivity_threshold_8_still"
       id: sensitivity8Still
       min_value: 10
       max_value: 100
       step: 5
       mode: box
       update_interval: never
       optimistic: true
       state_topic: ledtest/config/sens_threshold_8_still
       command_topic: ledtest/config/sens_threshold_8_still_cmd
       on_value:
         - lambda: |-
             auto uart_component = static_cast<LD2410 *>(ld2410);
             uart_component->setSensitivity(8,id(sensitivity8Moving).state,x);
         
     - platform: template
       name: "motion_hold_(sec)"
       id: noneDuration
       min_value: 0
       max_value: 900
       step: 1
       mode: box
       update_interval: never
       optimistic: true
       state_topic: ledtest/config/motion_hold
       command_topic: ledtest/config/motion_hold_cmd
       on_value:
         - lambda: |-
             auto uart_component = static_cast<LD2410 *>(ld2410);
             uart_component->setMaxDistancesAndNoneDuration(id(maxconfigDistanceMoving).state, id(maxconfigDistanceStill).state, x);
    
    button:
     - platform: restart
       name: "reset/restart_ESP/MCU"
       entity_category: diagnostic
       on_press:
         - lambda: 'static_cast<LD2410 *>(ld2410)->restart();'
    
     - platform: template
       name: "queryParameters"
       #entity_category: diagnostic
       on_press:
         - lambda: 'static_cast<LD2410 *>(ld2410)->queryParameters();'
    
    script:
     - id: clear_targets
       then:
         - lambda: |-
             //id(hasTarget).publish_state(0);
             //id(hasMovingTarget).publish_state(0);
             //id(hasStillTarget).publish_state(0);
             id(movingTargetDistance).publish_state(0);
             id(movingTargetEnergy).publish_state(0);
             id(stillTargetDistance).publish_state(0);
             id(stillTargetEnergy).publish_state(0);
             id(detectDistance).publish_state(0);
    

    Falls jemand übrigens weiß, wie man im YAML Variablen benutzt oder womöglich sogar Schleifen programmiert, da hätte ich gesteigertes Interesse ;-)
    Schleife meint hier nicht eine Schleife in einem Lambda sondern mehrere number - plattform: template Einträge, die sich nur duch wenige Einträge voneinander unterscheiden. Siehe im obigen YAML die Einträge mit den IDs sensitivity[0-8](Still|Moving).

    liv-in-skyL Offline
    liv-in-skyL Offline
    liv-in-sky
    schrieb am zuletzt editiert von
    #33

    erstmal danke, dass du weiter testest

    Bisher sind bei einem Neustart immer die eingestellten Werte wieder zurückgesetzt.

    bei dem yaml, welches ich gepostet habe, bleibt das setting - wie das im yaml gemacht wird, weiß ich nicht

    mit esp32 hatte ich als erstes geschafft, ein stabiles yaml zu bekommen - war verwundert, aber auch das yaml für den wemos d1 mini läuft stabil

    nach einem gelösten Thread wäre es sinnvoll dies in der Überschrift des ersten Posts einzutragen [gelöst]-... Bitte benutzt das Voting rechts unten im Beitrag wenn er euch geholfen hat. Forum-Tools: PicPick https://picpick.app/en/download/ und ScreenToGif https://www.screentogif.com/downloads.html

    ZarelloZ 1 Antwort Letzte Antwort
    0
    • BananaJoeB Online
      BananaJoeB Online
      BananaJoe
      Most Active
      schrieb am zuletzt editiert von BananaJoe
      #34

      @zarello sagte in Tasmota ESPHome Presence Sensor LD2410:

      Leider muss man die erst erzeugen lassen indem man z.B. über die Kommandozeile ein entsprechenden Topic einfach postet.
      (z.B.:mosquitto_pub -t ledtest/config/motion_hold_cmd -m 2 -- angepasst an die geänderten Topics, wie ich sie in meiner YAML verwendet habe).
      Dann muss man noch in den Objekteigenschaften im MQTT-Bereich publish auf true setzen.

      Du kannst auch mit sendTo arbeiten, dann wird das Topic auch angelegt und ist nutzbar (hab ich diverse mal für Tasmota gebraucht da außer dem POWER unter cmnd in der Regel nicht angelegt wird, Tasmota aber ja auf alle bekannten Befehle dort lauscht):

      // Beispiel für SendTo von https://github.com/ioBroker/ioBroker.mqtt
      // Test ob ich das zum Anlegen von neuen MQTT-Topics etc. nutzen kann
      /*
       * @param {string}  MQTT instance     Specify MQTT instance to send message through (may be either server or client)
       * @param {string}  action            Action to use (always 'sendMessage2Client' for sending plain messages)
       * @param {object}  payload         
       * @param {string}  payload.topic     Topic to publish message on
       * @param {string}  payload.message   Message to be published on specified topic
       *
       */
      sendTo('mqtt.0', 'sendMessage2Client', {topic: 'znil/Tests/Testnachricht', message: '42'});
      

      im MQTT-Adapter den ich als Client für einen Mosquitto einsetze sind ansonsten alle Haken raus:
      8eb2d491-8b1f-4d14-b7c0-c2601bb64b14-image.png

      So kann man bei Bedarf die "MQTT-Datenpunkte" damit anlegen. Oder gleich im Skript immer mit sendTo arbeiten
      Bei Bedarf hätte ich auch ein Blockly-Beispiel

      Das ganz habe ich in der Hilfe zum MQTT-Adapter gefunden (auch wenn da nicht steht das man es zum anlegen nutzen soll)

      ioBroker@Ubuntu 24.04 LTS (VMware) für: >260 Geräte, 5 Switche, 7 AP, 9 IP-Cam, 1 NAS 42TB, 1 ESXi 15TB, 4 Proxmox 1TB, 1 Hyper-V 48TB, 14 x Echo, 5x FireTV, 5 x Tablett/Handy VIS || >=160 Tasmota/Shelly || >=95 ZigBee || PV 8.1kW / Akku 14kWh || 2x USV 750W kaskadiert || Creality CR-10 SE 3D-Drucker

      ZarelloZ 1 Antwort Letzte Antwort
      1
      • BananaJoeB BananaJoe

        @zarello sagte in Tasmota ESPHome Presence Sensor LD2410:

        Leider muss man die erst erzeugen lassen indem man z.B. über die Kommandozeile ein entsprechenden Topic einfach postet.
        (z.B.:mosquitto_pub -t ledtest/config/motion_hold_cmd -m 2 -- angepasst an die geänderten Topics, wie ich sie in meiner YAML verwendet habe).
        Dann muss man noch in den Objekteigenschaften im MQTT-Bereich publish auf true setzen.

        Du kannst auch mit sendTo arbeiten, dann wird das Topic auch angelegt und ist nutzbar (hab ich diverse mal für Tasmota gebraucht da außer dem POWER unter cmnd in der Regel nicht angelegt wird, Tasmota aber ja auf alle bekannten Befehle dort lauscht):

        // Beispiel für SendTo von https://github.com/ioBroker/ioBroker.mqtt
        // Test ob ich das zum Anlegen von neuen MQTT-Topics etc. nutzen kann
        /*
         * @param {string}  MQTT instance     Specify MQTT instance to send message through (may be either server or client)
         * @param {string}  action            Action to use (always 'sendMessage2Client' for sending plain messages)
         * @param {object}  payload         
         * @param {string}  payload.topic     Topic to publish message on
         * @param {string}  payload.message   Message to be published on specified topic
         *
         */
        sendTo('mqtt.0', 'sendMessage2Client', {topic: 'znil/Tests/Testnachricht', message: '42'});
        

        im MQTT-Adapter den ich als Client für einen Mosquitto einsetze sind ansonsten alle Haken raus:
        8eb2d491-8b1f-4d14-b7c0-c2601bb64b14-image.png

        So kann man bei Bedarf die "MQTT-Datenpunkte" damit anlegen. Oder gleich im Skript immer mit sendTo arbeiten
        Bei Bedarf hätte ich auch ein Blockly-Beispiel

        Das ganz habe ich in der Hilfe zum MQTT-Adapter gefunden (auch wenn da nicht steht das man es zum anlegen nutzen soll)

        ZarelloZ Offline
        ZarelloZ Offline
        Zarello
        schrieb am zuletzt editiert von
        #35

        @bananajoe sagte in Tasmota ESPHome Presence Sensor LD2410:

        Du kannst auch mit sendTo arbeiten, dann wird das Topic auch angelegt

        sendTo('mqtt.0', 'sendMessage2Client', {topic: 'znil/Tests/Testnachricht', message: '42'});
        

        Schade, mit dem mqtt-client Adapter scheint das nicht zu funktionieren - getestet mit 'mqtt-client.0' als Ziel.
        Jetzt muss ich mir wohl überlegen, ob ich den normalen mqtt Adapter verwenden möchte und alle Datenpunkte umziehen möchte.

        1 Antwort Letzte Antwort
        0
        • liv-in-skyL liv-in-sky

          erstmal danke, dass du weiter testest

          Bisher sind bei einem Neustart immer die eingestellten Werte wieder zurückgesetzt.

          bei dem yaml, welches ich gepostet habe, bleibt das setting - wie das im yaml gemacht wird, weiß ich nicht

          mit esp32 hatte ich als erstes geschafft, ein stabiles yaml zu bekommen - war verwundert, aber auch das yaml für den wemos d1 mini läuft stabil

          ZarelloZ Offline
          ZarelloZ Offline
          Zarello
          schrieb am zuletzt editiert von
          #36

          @liv-in-sky sagte in Tasmota ESPHome Presence Sensor LD2410:

          bei dem yaml, welches ich gepostet habe, bleibt das setting - wie das im yaml gemacht wird, weiß ich nicht

          Ich habe da ein bisschen in der setup Methode in der Header-Datei rumgespielt.
          Inzwischen habe ich festgestellt, so wie es jetzt ist bleiben bei Strom aus und wieder an die Settings erhalten.
          Nur wenn ich eine neue Software aufspiele hat er wieder seine Default-Werte. Das wundert mich, denn eigentlich hole ich die Werte am Anfang vom Sensor. Eine neue Software sollte für den Sensor ja nichts anderes sein als aus- und wieder einschalten. Evtl. wird aber irgendwo noch der Reset aufgerufen. Den werde ich mal abklemmen.

          Außerdem wird bei mir der Wert für stillTargetDistance niemals geändert. Der bleibt einfach auf 0.
          Bekommst Du da sinnvolle Werte?

          liv-in-skyL 1 Antwort Letzte Antwort
          0
          • ZarelloZ Zarello

            @liv-in-sky sagte in Tasmota ESPHome Presence Sensor LD2410:

            bei dem yaml, welches ich gepostet habe, bleibt das setting - wie das im yaml gemacht wird, weiß ich nicht

            Ich habe da ein bisschen in der setup Methode in der Header-Datei rumgespielt.
            Inzwischen habe ich festgestellt, so wie es jetzt ist bleiben bei Strom aus und wieder an die Settings erhalten.
            Nur wenn ich eine neue Software aufspiele hat er wieder seine Default-Werte. Das wundert mich, denn eigentlich hole ich die Werte am Anfang vom Sensor. Eine neue Software sollte für den Sensor ja nichts anderes sein als aus- und wieder einschalten. Evtl. wird aber irgendwo noch der Reset aufgerufen. Den werde ich mal abklemmen.

            Außerdem wird bei mir der Wert für stillTargetDistance niemals geändert. Der bleibt einfach auf 0.
            Bekommst Du da sinnvolle Werte?

            liv-in-skyL Offline
            liv-in-skyL Offline
            liv-in-sky
            schrieb am zuletzt editiert von liv-in-sky
            #37

            @zarello sagte in Tasmota ESPHome Presence Sensor LD2410:

            stillTargetDistance

            bei mir auch nicht - steht in der webgui , bleibt aber immer 0 - auch kein mqtt datenpunkt

            ich konzentriere mich aber auf den presence dp - mehr brauche ich eigentlich nicht (oder ich weiß noch nicht, dass ich ihn brauche

            nach einem gelösten Thread wäre es sinnvoll dies in der Überschrift des ersten Posts einzutragen [gelöst]-... Bitte benutzt das Voting rechts unten im Beitrag wenn er euch geholfen hat. Forum-Tools: PicPick https://picpick.app/en/download/ und ScreenToGif https://www.screentogif.com/downloads.html

            ZarelloZ 1 Antwort Letzte Antwort
            0
            • liv-in-skyL liv-in-sky

              @zarello sagte in Tasmota ESPHome Presence Sensor LD2410:

              stillTargetDistance

              bei mir auch nicht - steht in der webgui , bleibt aber immer 0 - auch kein mqtt datenpunkt

              ich konzentriere mich aber auf den presence dp - mehr brauche ich eigentlich nicht (oder ich weiß noch nicht, dass ich ihn brauche

              ZarelloZ Offline
              ZarelloZ Offline
              Zarello
              schrieb am zuletzt editiert von
              #38

              Idee wäre, über zwei Geräte aus den Abständen die Position zu ermitteln. Aber ich vermute, dass wird sowieso nicht funktionieren, da zwei Geräte in einem Raum sich höchstwahrscheinlich gegenseitig stören.
              Die müsste man dann synchronisieren und immer eines der beiden ausschalten, allerdings bieten die Geräte diese Option nicht und wenn man ihnen einfach den Strom klaut, funktionieren sie vermutlich nicht mehr so gut, denn nach meinen Beobachtungen funktioniert die Detektion von unbewegten Personen nur, wenn sie vorher als bewegt erkannt wurden.
              Wenn man sich im Sensorbereich komplett still verhält (Atem anhalten), kann man danach normal atmen ohne, dass der Sensor anschlägt. Erst wenn man sich wieder etwas mehr bewegt und der Sensor das erkennt, bleibt er danach auch aktiv, wenn man nur atmet.

              liv-in-skyL 1 Antwort Letzte Antwort
              0
              • liv-in-skyL liv-in-sky

                hier noch ein yaml für einen wemos D1 mini mit esphome - zeile 53 ff und 172 sind die pins definiert

                • die pins zum anschliessen sind im yaml zu lesen
                • die zusatzdatei https://forum.iobroker.net/post/957138 muss auch im system sein

                esphome:
                 name: ld2410m3d1
                 includes:
                   - uart_read_line_sensor_ld2410v3.h
                 on_boot:
                    priority: -100
                    then:
                     - script.execute: get_config
                
                
                esp8266:
                     board: esp01_1m
                
                
                # Enable logging
                logger:
                 baud_rate: 0
                 logs:
                   sensor: INFO # DEBUG level with uart_target_output = overload!
                   binary_sensor: INFO
                   text_sensor: INFO
                
                # Enable Home Assistant API
                api:
                
                ota:
                 
                
                wifi:
                 ssid: "yyyyyyyyy1"
                 password: "xxxxxxxxxxxxxx2"
                 use_address: 192.168.178.67
                
                
                
                substitutions:
                 device_name: dev-sensor
                
                mqtt:
                 broker: 192.168.178.59
                 port: 1506
                 topic_prefix: ld2410motion/motion3
                 
                 
                web_server:
                 port: 80
                 version: 2
                 include_internal: true
                 ota: false
                
                captive_portal:
                
                uart:
                 id: uart_bus
                 tx_pin:
                   number: GPIO1
                 rx_pin: 
                   number: GPIO3
                 baud_rate: 256000
                 parity: NONE
                 stop_bits: 1
                
                switch:
                 - platform: safe_mode
                   name: use_safe_mode
                   
                 - platform: template
                   name: configmode
                   id: configmode
                   optimistic: true
                   # assumed_state: false
                   turn_on_action:
                     # - switch.turn_off: engineering_mode
                     - lambda: 'static_cast<LD2410 *>(ld2410)->setConfigMode(true);'
                     - delay: 100ms
                     - script.execute: clear_targets
                   turn_off_action:
                     - lambda: 'static_cast<LD2410 *>(ld2410)->setConfigMode(false);'
                
                 - platform: template
                   name: show_target_stats
                   id: show_stats
                   optimistic: true
                   internal: true
                   turn_off_action:
                     - script.execute: clear_targets
                
                text_sensor:
                 - platform: template
                   name: uptime_human_readable
                   id: uptime_human_readable
                   icon: mdi:clock-start
                   update_interval: 60s
                
                sensor:
                 - platform: uptime
                   name: uptime_sensor
                   id: uptime_sensor
                   update_interval: 60s
                   internal: true
                   on_raw_value:
                     then:
                       - text_sensor.template.publish:
                           id: uptime_human_readable
                           state: !lambda |-
                                     int seconds = round(id(uptime_sensor).raw_state);
                                     int days = seconds / (24 * 3600);
                                     seconds = seconds % (24 * 3600);
                                     int hours = seconds / 3600;
                                     seconds = seconds % 3600;
                                     int minutes = seconds /  60;
                                     seconds = seconds % 60;
                                     return (
                                       (days ? to_string(days)+":" : "00:") +
                                       (hours ? to_string(hours)+":" : "00:") +
                                       (minutes ? to_string(minutes)+":" : "00:") +
                                       (to_string(seconds))
                                     ).c_str();
                
                 - platform: custom # currently crashes ESP32
                   lambda: |-
                     auto uart_component = static_cast<LD2410 *>(ld2410);
                     //return {uart_component->movingTargetDistance,uart_component->movingTargetEnergy,uart_component->stillTargetDistance,uart_component->stillTargetEnergy,uart_component->detectDistance};
                     return {};
                   sensors:
                   
                 - platform: template
                   name: movingTargetDistance
                   id: movingTargetDistance
                   unit_of_measurement: "cm"
                   accuracy_decimals: 0
                   internal: true
                   
                 - platform: template
                   name: movingTargetEnergy
                   id: movingTargetEnergy
                   unit_of_measurement: "%"
                   accuracy_decimals: 0
                   internal: true
                   
                 - platform: template
                   name: stillTargetDistance
                   id: stillTargetDistance
                   unit_of_measurement: "cm"
                   accuracy_decimals: 0
                   internal: true
                   
                 - platform: template
                   name: stillTargetEnergy
                   id: stillTargetEnergy
                   unit_of_measurement: "%"
                   accuracy_decimals: 0
                   internal: true
                   
                 - platform: template
                   name: detectDistance
                   id: detectDistance
                   unit_of_measurement: "cm"
                   accuracy_decimals: 0
                   internal: true
                   
                custom_component:
                 - lambda: |-
                     return {new LD2410(id(uart_bus))};
                   components:
                     - id: ld2410
                     
                binary_sensor:
                 - platform: gpio
                   name: mmwave_presence_ld2410
                   id: mmwave_presence_ld2410
                   pin: GPIO5
                   device_class: motion
                   on_state:
                     then:
                       - if: 
                           condition: 
                             - binary_sensor.is_off: mmwave_presence_ld2410
                           then: 
                             - delay: 150ms
                             - script.execute: clear_targets
                
                number:  
                 - platform: template
                   name: configMaxDistance
                   id: maxconfigDistance
                   unit_of_measurement: "M"
                   min_value: 0.75
                   max_value: 6
                   step: 0.75
                   update_interval: never
                   optimistic: true
                   set_action:
                     - switch.turn_on: configmode
                     - delay: 50ms
                     - lambda: |-
                         auto uart_component = static_cast<LD2410 *>(ld2410);
                         uart_component->setMaxDistancesAndNoneDuration(x/0.75,x/0.75,id(noneDuration).state);
                     - delay: 50ms
                     - lambda: 'static_cast<LD2410 *>(ld2410)->queryParameters();'
                     - delay: 50ms
                     - switch.turn_off: configmode
                
                 - platform: template
                   name: "sensitivity_threshold_(%)"
                   id: allSensitivity
                   min_value: 10
                   max_value: 100
                   step: 5
                   mode: box
                   update_interval: never
                   optimistic: true
                   set_action:
                     - switch.turn_on: configmode
                     - delay: 50ms
                     - lambda: |-
                         auto uart_component = static_cast<LD2410 *>(ld2410);
                         uart_component->setAllSensitivity(x);
                     - delay: 50ms
                     - lambda: 'static_cast<LD2410 *>(ld2410)->queryParameters();'
                     - delay: 50ms
                     - switch.turn_off: configmode
                     
                 - platform: template
                   name: "motion_hold_(sec)"
                   id: noneDuration
                   min_value: 0
                   # max_value: 32767
                   max_value: 900
                   step: 1
                   mode: box
                   update_interval: never
                   optimistic: true
                   set_action:
                     - switch.turn_on: configmode
                     - delay: 50ms
                     - lambda: |-
                         auto uart_component = static_cast<LD2410 *>(ld2410);
                         uart_component->setMaxDistancesAndNoneDuration(id(maxconfigDistance).state, id(maxconfigDistance).state, x);
                     - delay: 50ms
                     - lambda: 'static_cast<LD2410 *>(ld2410)->queryParameters();'
                     - delay: 50ms
                     - switch.turn_off: configmode
                button:
                 - platform: restart
                   name: "reset/restart_ESP/MCU"
                   entity_category: diagnostic
                   on_press:
                     - switch.turn_on: configmode
                     - delay: 50ms
                     - lambda: 'static_cast<LD2410 *>(ld2410)->factoryReset();'
                     - delay: 150ms
                     - lambda: 'static_cast<LD2410 *>(ld2410)->reboot();'
                     - delay: 150ms
                
                script:
                 - id: get_config
                   then:
                     - switch.turn_on: configmode
                     - delay: 500ms
                     - lambda: 'static_cast<LD2410 *>(ld2410)->queryParameters();'
                     - delay: 500ms
                     - switch.turn_off: configmode
                     
                 - id: clear_targets
                   then:
                     - lambda: |-
                         //id(hasTarget).publish_state(0);
                         //id(hasMovingTarget).publish_state(0);
                         //id(hasStillTarget).publish_state(0);
                         id(movingTargetDistance).publish_state(0);
                         id(movingTargetEnergy).publish_state(0);
                         id(stillTargetDistance).publish_state(0);
                         id(stillTargetEnergy).publish_state(0);
                         id(detectDistance).publish_state(0);
                

                ich bin kein profi mit esphome - vielleicht habe ich das ganze etwas umständlich gemacht. hier eine kurze beschreibung:

                • vorbereitendes yamls: name ändern, unter mqtt die richtigen daten eingeben

                • die stromversorgung für den sensor nicht durch den esp nehmen, sondern den esp 5V und den sensor vcc parallel an der stromversorgung anschliessen - also nicht über den mini usb port anschliessen (nur zum flashen) -

                • genutzt wird der esphome adapter

                • die zusatzdatei uart_read_line_sensor_ld2410v3.h ins system kopieren: /opt/iobroker/iobroker-data/esphome.0

                • dann ein standard esphome yaml für den esp erstellt unter: https://web.esphome.io/ und die wifi angaben machen - der esp wird dazu am usb port des pc's angeschlossen (die serielle-verbindung zwischen sensor und esp erst anschliessen, wenn das erste flashen vorbei ist - wenn noch am pc angeschlossen)

                • die ip adresse habe ich dann im yaml eingetragen - unter wifi - use address

                • der esp mit esphome wird anschliessend im adapter dashboard sichtbar - dann adapt drücken

                • im esphome-dashboard auf edit drücken und das yaml hineinkopieren - sichern - installieren - der esp wird über wifi neu geflasht

                war das erfolgreich müßte unter der ip adresse des esp eine webseite aufgehen, in der man das ganze konfigurieren kann

                Image 014.png

                dann testen, ob der esp richtige daten im mqtt ordner bringt

                S Offline
                S Offline
                Stadtschloss
                schrieb am zuletzt editiert von Stadtschloss
                #39

                @liv-in-sky Danke für das Script! Leider bleibt bei mir der Wert "mmwave_presence_ld2410" immer auf ON. Auch nach den abgelaufenen 5 Sekunden wo keine Bewegung passiert.

                Edit: Ah okay musst noch die Out vom Sensor an den D1 anlöten :)

                liv-in-skyL 1 Antwort Letzte Antwort
                0
                • ZarelloZ Zarello

                  Idee wäre, über zwei Geräte aus den Abständen die Position zu ermitteln. Aber ich vermute, dass wird sowieso nicht funktionieren, da zwei Geräte in einem Raum sich höchstwahrscheinlich gegenseitig stören.
                  Die müsste man dann synchronisieren und immer eines der beiden ausschalten, allerdings bieten die Geräte diese Option nicht und wenn man ihnen einfach den Strom klaut, funktionieren sie vermutlich nicht mehr so gut, denn nach meinen Beobachtungen funktioniert die Detektion von unbewegten Personen nur, wenn sie vorher als bewegt erkannt wurden.
                  Wenn man sich im Sensorbereich komplett still verhält (Atem anhalten), kann man danach normal atmen ohne, dass der Sensor anschlägt. Erst wenn man sich wieder etwas mehr bewegt und der Sensor das erkennt, bleibt er danach auch aktiv, wenn man nur atmet.

                  liv-in-skyL Offline
                  liv-in-skyL Offline
                  liv-in-sky
                  schrieb am zuletzt editiert von
                  #40

                  @zarello
                  sorry - habe deinen letzten post völlig übersehen :-(
                  scheint, als ob du tief in den sensor einsteigst :-)

                  habe ja 3 sensoren in einem zimmer getestet - die presence funtioniert ohne gegenseitige störungen - ob das auch für die anderen werte gilt, kann ich nicht sagen, da ich die entfernungen nicht protokoliere bzw trianguliere

                  wenn ich über die api, die entfernung beobachte - 2 sensoren direkt vor mir am schreibtisch, werden die werte für ... bei beiden korrekt angezeigt

                  Image 022.png

                  @zarello sagte in Tasmota ESPHome Presence Sensor LD2410:

                  unbewegten Personen nur, wenn sie vorher als bewegt erkannt

                  kommt eher selten vor, dass ich in einen bereich (bewegungslos) hineingehe - auch versuche ich meist zu atmen - ist so eine angewohnheit von mir :-) :-) :-)

                  bisher nutze ich den sensor (weitere langzeit-tests):

                  • sitze ich auf dem sofa in meinem büro, werden die monitore des hauptdesktops abgeschalten - die brauchen viele watt - gehe ich wieder zum schreibtisch, werden die monitore wieder aktiviert - funktioniert alles sehr stabil

                  mittlerweile ist die hardware auch in gehäuse eingebaut - habe aber die sensoren außerhalb des gehäuses angebracht - innerhalb wollte das ganze nicht mehr so richtig (obwohl es plastik ist)

                  ich fand die idee mit den leds ganz gut - muss mal schauen, wenn ich zeit habe, ob ich die aus deinem yaml in meine esp32 yaml bekomme und ob das ganze dann noch funtioniert - sollte bald noch eine lieferung bekommen

                  nach einem gelösten Thread wäre es sinnvoll dies in der Überschrift des ersten Posts einzutragen [gelöst]-... Bitte benutzt das Voting rechts unten im Beitrag wenn er euch geholfen hat. Forum-Tools: PicPick https://picpick.app/en/download/ und ScreenToGif https://www.screentogif.com/downloads.html

                  ZarelloZ 1 Antwort Letzte Antwort
                  0
                  • S Stadtschloss

                    @liv-in-sky Danke für das Script! Leider bleibt bei mir der Wert "mmwave_presence_ld2410" immer auf ON. Auch nach den abgelaufenen 5 Sekunden wo keine Bewegung passiert.

                    Edit: Ah okay musst noch die Out vom Sensor an den D1 anlöten :)

                    liv-in-skyL Offline
                    liv-in-skyL Offline
                    liv-in-sky
                    schrieb am zuletzt editiert von
                    #41

                    @stadtschloss ja - den pin braucht man irgendwie :-)

                    nach einem gelösten Thread wäre es sinnvoll dies in der Überschrift des ersten Posts einzutragen [gelöst]-... Bitte benutzt das Voting rechts unten im Beitrag wenn er euch geholfen hat. Forum-Tools: PicPick https://picpick.app/en/download/ und ScreenToGif https://www.screentogif.com/downloads.html

                    1 Antwort Letzte Antwort
                    1
                    • liv-in-skyL liv-in-sky

                      @zarello
                      sorry - habe deinen letzten post völlig übersehen :-(
                      scheint, als ob du tief in den sensor einsteigst :-)

                      habe ja 3 sensoren in einem zimmer getestet - die presence funtioniert ohne gegenseitige störungen - ob das auch für die anderen werte gilt, kann ich nicht sagen, da ich die entfernungen nicht protokoliere bzw trianguliere

                      wenn ich über die api, die entfernung beobachte - 2 sensoren direkt vor mir am schreibtisch, werden die werte für ... bei beiden korrekt angezeigt

                      Image 022.png

                      @zarello sagte in Tasmota ESPHome Presence Sensor LD2410:

                      unbewegten Personen nur, wenn sie vorher als bewegt erkannt

                      kommt eher selten vor, dass ich in einen bereich (bewegungslos) hineingehe - auch versuche ich meist zu atmen - ist so eine angewohnheit von mir :-) :-) :-)

                      bisher nutze ich den sensor (weitere langzeit-tests):

                      • sitze ich auf dem sofa in meinem büro, werden die monitore des hauptdesktops abgeschalten - die brauchen viele watt - gehe ich wieder zum schreibtisch, werden die monitore wieder aktiviert - funktioniert alles sehr stabil

                      mittlerweile ist die hardware auch in gehäuse eingebaut - habe aber die sensoren außerhalb des gehäuses angebracht - innerhalb wollte das ganze nicht mehr so richtig (obwohl es plastik ist)

                      ich fand die idee mit den leds ganz gut - muss mal schauen, wenn ich zeit habe, ob ich die aus deinem yaml in meine esp32 yaml bekomme und ob das ganze dann noch funtioniert - sollte bald noch eine lieferung bekommen

                      ZarelloZ Offline
                      ZarelloZ Offline
                      Zarello
                      schrieb am zuletzt editiert von
                      #42

                      @liv-in-sky sagte in Tasmota ESPHome Presence Sensor LD2410:

                      scheint, als ob du tief in den sensor einsteigst :-)

                      Ich hatte schon überlegt, ob ich bei Gelegenheit einen Vorschlag für einen überarbeiteten LD2410 in ESPHome mache. Aber da benötige ich etwas mehr meiner knappen Zeit für, da ich dann zuerst rausfinden muss, wie ich eine eigene ESPHome-Variante mit dem ESPHome-Adapter verwende.
                      Und vermutlich werde ich dann die ganzen unterschiedlichen Sensitivitäten eher über 1-2 Objekte über JSON steuern und in dem Fall evtl. auch als Alternative, dass man einfach nur einen Wert eintragen kann statt einer Liste und dieser dann für alle Bereiche verwendet wird. Wie gesagt: Zeit haben...

                      habe ja 3 sensoren in einem zimmer getestet - die presence funtioniert ohne gegenseitige störungen - ob das auch für die anderen werte gilt, kann ich nicht sagen, da ich die entfernungen nicht protokoliere bzw trianguliere

                      wenn ich über die api, die entfernung beobachte - 2 sensoren direkt vor mir am schreibtisch, werden die werte für ... bei beiden korrekt angezeigt

                      Das wäre ja super. Da bin ich mal gespannt. Im Moment warte ich noch auf Anschlusskabel mit passenden Steckern, da ich beschlossen habe, dass ich nicht alle Sensoren anlöten möchte. Die Pins liegen einfach zu dicht beieinander.

                      kommt eher selten vor, dass ich in einen bereich (bewegungslos) hineingehe - auch versuche ich meist zu atmen - ist so eine angewohnheit von mir :-) :-) :-)

                      Ich hatte es schon ein paar mal geschafft so ruhig auf dem Sofa zu sitzen, dass der Sensor mich nicht mehr erkannt hat. Passiert eher bei größerer Entfernung (> 3m).
                      Vielleicht sollte ich mir auch einfach das Atmen wieder angewöhnen ;-)
                      Aber wenn die sich nicht gegenseitig stören kann ich ja auch einfach einen zweiten hinstellen, der dann dichter am Sofa ist.

                      mittlerweile ist die hardware auch in gehäuse eingebaut - habe aber die sensoren außerhalb des gehäuses angebracht - innerhalb wollte das ganze nicht mehr so richtig (obwohl es plastik ist)

                      Im Datenblatt des Sensors stehen dazu ganz interessante Infos: Je nach Art des Plastiks gibt es eine empfohlene Dicke (berechnet anhand der halben Wellenlänge des Mediums, meist zwischen 2-5 mm) und einen empfohlenen Abstand (einfache oder eineinhalbfache Wellenlänge in der Luft: 12,4 bzw. 18,6mm).
                      Das Plastik sollte allerdings möglichst homogen sein. Ein 3D-gedrucktes Teil entspricht dem mit Sicherheit nicht, da gibt es viel zu viele Lufteinschlüsse.

                      Ich hatte bei mir einfach mal Papier als Abdeckung getestet. Das hatte gut funktioniert. Ich werde vermutlich die Gehäuse so bauen, dass ich die Seite vor dem Sensor einfach mit Papier abklebe, das sieht etwas netter aus als der blanke Sensor.

                      1 Antwort Letzte Antwort
                      0
                      • Stefan WilkeS Offline
                        Stefan WilkeS Offline
                        Stefan Wilke
                        schrieb am zuletzt editiert von Stefan Wilke
                        #43

                        Ein richtig guter Bewegungs- und Präsenz Sensor der LD2410 und mein langer Weg zur wirklich guten Erkennung.

                        Den Adapter ESPHome 0.2.4 installiert aber ich habe es nicht geschafft, egal was ich auch probiert habe die YAML Datei über ESPHome im IoBroker zu kompilieren oder gar auf den ESP32 zu übertragen. Stundenlang im Netz gesucht aber keine Lösung dazu gefunden bis ich dann auf diesen Link
                        https://smarthomeyourself.de/wiki/esphome/esphome-mit-python-ueber-die-kommandozeile-flashen/
                        gestoßen bin.

                        Hier wird wirklich super erklärt wie man ESPHome mit Python über die Kommandozeile flashen kann.
                        Bei meiner langen Suche im Netz habe ich auch eine gute id2410.yaml Datei mit dazugehöriger ld2410.h Datei gefunden.

                        Python auf meinem Windows PC installiert, ein neues Verzeichnis esphome angelegt und dann noch Kommandozeile aus dem Arbeitsplatz heraus gestartet. In der Kommandozeile dann noch die 4 Befehle ausgeführt.
                        Jetzt noch mit dem letzten Befehl die YAML Datei kompiliert und ab damit auf den ESP32

                        Anschließend kann man noch in der Web Oberfläche des ESP32 die einzelnen Parameter einstellen und diese werden auch übernommen.

                        Was die Werte motionGate0Sensitivity bis motionGate8Sensitivity sowie staticGate2Sensitivity bis staticGate8Sensitivity bewirken ist mir leider nicht bekannt. Vielleicht kann mich jemand aufklären. Diese Werte waren ursprünglich anders aber ich habe in der Web Oberfläche auf den Reset Button geklickt und dann waren es die Einstellungen wie auf meinem Bild und der Sensor arbeitet so wie ich mir das vorgestellt habe.

                        Jetzt muß ich nur noch jemand finden, der mir ein 3D Gehäuse druckt.

                        LD2410.jpg

                        ld2410 mqtt Daten.jpg

                        So ein Gehäuse wäre schon schön.
                        ld2410 Gehäuse.jpg

                        Meine YAML Datei und dazu auch die h Datei
                        ld2410.yaml

                        ld2410.h

                        In der ld2410.yaml Datei unter WIFI die IP des ESP32, die SSID und das Netzwerkpasswort, unter mqtt die IP eures mqtt Broker ggf. auch den Port eintragen.

                        Dann noch ein kleines Blockly. Geht bestimmt einfacher und besser aber funktioniert bei mir.

                        ld2410 Blockly.jpg

                        Ich habe noch nicht ganz die Türklinke in der Hand und das Licht geht an und bleibt auch solange an bis ich den Raum verlasse. Habe noch ein Verzögerung von 4 Sekunden eingebaut mit der Variable setze timer auf 4.

                        liv-in-skyL 1 Antwort Letzte Antwort
                        0
                        • Stefan WilkeS Stefan Wilke

                          Ein richtig guter Bewegungs- und Präsenz Sensor der LD2410 und mein langer Weg zur wirklich guten Erkennung.

                          Den Adapter ESPHome 0.2.4 installiert aber ich habe es nicht geschafft, egal was ich auch probiert habe die YAML Datei über ESPHome im IoBroker zu kompilieren oder gar auf den ESP32 zu übertragen. Stundenlang im Netz gesucht aber keine Lösung dazu gefunden bis ich dann auf diesen Link
                          https://smarthomeyourself.de/wiki/esphome/esphome-mit-python-ueber-die-kommandozeile-flashen/
                          gestoßen bin.

                          Hier wird wirklich super erklärt wie man ESPHome mit Python über die Kommandozeile flashen kann.
                          Bei meiner langen Suche im Netz habe ich auch eine gute id2410.yaml Datei mit dazugehöriger ld2410.h Datei gefunden.

                          Python auf meinem Windows PC installiert, ein neues Verzeichnis esphome angelegt und dann noch Kommandozeile aus dem Arbeitsplatz heraus gestartet. In der Kommandozeile dann noch die 4 Befehle ausgeführt.
                          Jetzt noch mit dem letzten Befehl die YAML Datei kompiliert und ab damit auf den ESP32

                          Anschließend kann man noch in der Web Oberfläche des ESP32 die einzelnen Parameter einstellen und diese werden auch übernommen.

                          Was die Werte motionGate0Sensitivity bis motionGate8Sensitivity sowie staticGate2Sensitivity bis staticGate8Sensitivity bewirken ist mir leider nicht bekannt. Vielleicht kann mich jemand aufklären. Diese Werte waren ursprünglich anders aber ich habe in der Web Oberfläche auf den Reset Button geklickt und dann waren es die Einstellungen wie auf meinem Bild und der Sensor arbeitet so wie ich mir das vorgestellt habe.

                          Jetzt muß ich nur noch jemand finden, der mir ein 3D Gehäuse druckt.

                          LD2410.jpg

                          ld2410 mqtt Daten.jpg

                          So ein Gehäuse wäre schon schön.
                          ld2410 Gehäuse.jpg

                          Meine YAML Datei und dazu auch die h Datei
                          ld2410.yaml

                          ld2410.h

                          In der ld2410.yaml Datei unter WIFI die IP des ESP32, die SSID und das Netzwerkpasswort, unter mqtt die IP eures mqtt Broker ggf. auch den Port eintragen.

                          Dann noch ein kleines Blockly. Geht bestimmt einfacher und besser aber funktioniert bei mir.

                          ld2410 Blockly.jpg

                          Ich habe noch nicht ganz die Türklinke in der Hand und das Licht geht an und bleibt auch solange an bis ich den Raum verlasse. Habe noch ein Verzögerung von 4 Sekunden eingebaut mit der Variable setze timer auf 4.

                          liv-in-skyL Offline
                          liv-in-skyL Offline
                          liv-in-sky
                          schrieb am zuletzt editiert von
                          #44

                          @stefan-wilke

                          erstmal vielen dank für deinen post - bin gerade am testen - weißt du, wie man diesen datenpunkt aktiviert - ist immer off bei mir - geht das überhaupt ?

                          Image 079.png

                          bisher verstehe ich die anzeigen nicht richtig - es werden massig daten gesendet - also gut für entfernungsmessung und schnell !

                          bei meinem yaml gibt es off und on, wenn man im bereich ist - also bedeutend weniger datentransfer

                          hast du eine link, wo du dieses yaml her hast ?
                          die motionGate und sensitivityGat sachen, sollen wohl die bereiche darstellen ?

                          nach einem gelösten Thread wäre es sinnvoll dies in der Überschrift des ersten Posts einzutragen [gelöst]-... Bitte benutzt das Voting rechts unten im Beitrag wenn er euch geholfen hat. Forum-Tools: PicPick https://picpick.app/en/download/ und ScreenToGif https://www.screentogif.com/downloads.html

                          1 Antwort Letzte Antwort
                          0
                          • Stefan WilkeS Offline
                            Stefan WilkeS Offline
                            Stefan Wilke
                            schrieb am zuletzt editiert von Stefan Wilke
                            #45

                            @liv-in-sky

                            keine Ahnung wie man diesen Datenpunkt aktiviert. Habe den Link gefunden wo ich meine YAML und h Datei her habe. https://github.com/amandel/esphome-ld2410

                            Ja, es werden viele Daten gesendet aber bisher war das für mein IOBroker auf dem Pi kein Problem.

                            Das mit motionGate und sensiivityGate habe ich noch nicht verstanden aber ich könnte mir vorstellen, das man z.B. einen Bereich von 30-150 cm angeben kann und wenn dort jemand erkannt wird geht Lampe 1 an und wenn im Bereich von 4-5 Meter jemand erkannt wird geht Lampe 2 an.

                            Habe gerade noch 2 Bilder für ein Gehäuse gefunden aber leider ohne 3D Druckdatei.

                            Bild1.jpg Bild2.jpg

                            liv-in-skyL 1 Antwort Letzte Antwort
                            0
                            • Stefan WilkeS Stefan Wilke

                              @liv-in-sky

                              keine Ahnung wie man diesen Datenpunkt aktiviert. Habe den Link gefunden wo ich meine YAML und h Datei her habe. https://github.com/amandel/esphome-ld2410

                              Ja, es werden viele Daten gesendet aber bisher war das für mein IOBroker auf dem Pi kein Problem.

                              Das mit motionGate und sensiivityGate habe ich noch nicht verstanden aber ich könnte mir vorstellen, das man z.B. einen Bereich von 30-150 cm angeben kann und wenn dort jemand erkannt wird geht Lampe 1 an und wenn im Bereich von 4-5 Meter jemand erkannt wird geht Lampe 2 an.

                              Habe gerade noch 2 Bilder für ein Gehäuse gefunden aber leider ohne 3D Druckdatei.

                              Bild1.jpg Bild2.jpg

                              liv-in-skyL Offline
                              liv-in-skyL Offline
                              liv-in-sky
                              schrieb am zuletzt editiert von liv-in-sky
                              #46

                              @stefan-wilke

                              bei mir ist das setting "show stats" nach einem neustart (strom aus/ein) nicht mehr gesetzt - damit keine werte - ist das bei dir auch so ?

                              edit: kann aber über ein blockly wieder gestzt werden, wenn esp online geht

                              nach einem gelösten Thread wäre es sinnvoll dies in der Überschrift des ersten Posts einzutragen [gelöst]-... Bitte benutzt das Voting rechts unten im Beitrag wenn er euch geholfen hat. Forum-Tools: PicPick https://picpick.app/en/download/ und ScreenToGif https://www.screentogif.com/downloads.html

                              Stefan WilkeS 1 Antwort Letzte Antwort
                              0
                              • liv-in-skyL liv-in-sky

                                @stefan-wilke

                                bei mir ist das setting "show stats" nach einem neustart (strom aus/ein) nicht mehr gesetzt - damit keine werte - ist das bei dir auch so ?

                                edit: kann aber über ein blockly wieder gestzt werden, wenn esp online geht

                                Stefan WilkeS Offline
                                Stefan WilkeS Offline
                                Stefan Wilke
                                schrieb am zuletzt editiert von
                                #47

                                @liv-in-sky

                                Ja, das ist bei mir auch so.

                                in der YAML Datei ist etwas zu deiner Frage zu dem Datenpunkt zu finden.
                                binary_sensor:

                                • platform: gpio
                                  name: mmwave_presence_ld2410
                                  id: mmwave_presence_ld2410
                                  pin: GPIO14
                                  device_class: motion

                                Habe keine Ahnung was das bedeutet aber ich könnte mir vorstellen, dass das mit dem Out Pin auf dem ld2410 zu tun hat.

                                liv-in-skyL 1 Antwort Letzte Antwort
                                0
                                • Stefan WilkeS Stefan Wilke

                                  @liv-in-sky

                                  Ja, das ist bei mir auch so.

                                  in der YAML Datei ist etwas zu deiner Frage zu dem Datenpunkt zu finden.
                                  binary_sensor:

                                  • platform: gpio
                                    name: mmwave_presence_ld2410
                                    id: mmwave_presence_ld2410
                                    pin: GPIO14
                                    device_class: motion

                                  Habe keine Ahnung was das bedeutet aber ich könnte mir vorstellen, dass das mit dem Out Pin auf dem ld2410 zu tun hat.

                                  liv-in-skyL Offline
                                  liv-in-skyL Offline
                                  liv-in-sky
                                  schrieb am zuletzt editiert von
                                  #48

                                  @stefan-wilke ja habe ich auch gefunden

                                  ja definiert den pin - aber es reagiert nicht im mqtt - evtl muss man den ersteller in github anschreiben

                                  in dem ls2410.h file kann mal wohl die stats immer einschalten zeile 189 - habe es aber nicht getestet

                                  nach einem gelösten Thread wäre es sinnvoll dies in der Überschrift des ersten Posts einzutragen [gelöst]-... Bitte benutzt das Voting rechts unten im Beitrag wenn er euch geholfen hat. Forum-Tools: PicPick https://picpick.app/en/download/ und ScreenToGif https://www.screentogif.com/downloads.html

                                  Stefan WilkeS 1 Antwort Letzte Antwort
                                  0
                                  • liv-in-skyL liv-in-sky

                                    @stefan-wilke ja habe ich auch gefunden

                                    ja definiert den pin - aber es reagiert nicht im mqtt - evtl muss man den ersteller in github anschreiben

                                    in dem ls2410.h file kann mal wohl die stats immer einschalten zeile 189 - habe es aber nicht getestet

                                    Stefan WilkeS Offline
                                    Stefan WilkeS Offline
                                    Stefan Wilke
                                    schrieb am zuletzt editiert von Stefan Wilke
                                    #49

                                    @liv-in-sky

                                    Habe eine Github Anfrage gestartet und auch schon eine Antwort auf meine Frage erhalten. Es funktioniert, habe es gerade getestet.

                                    Um das Setting "Show Stats" auch nach einen Neustart auf On zu setzten muß in meiner YAML Datei folgende Zeilen eingefügt werden.

                                    Anstatt:
                                    
                                    esphome:
                                      name: "radarsensor"
                                      includes:
                                        - ld2410.h
                                    
                                    muss das da stehen:
                                    
                                    esphome:
                                      name: "radarsensor"
                                      includes:
                                        - ld2410.h
                                      on_boot:
                                        priority: -10
                                        # ...
                                        then:
                                          - switch.turn_on: show_stats
                                    
                                    und etwas weiter unten 
                                    
                                    Anstatt:
                                    
                                    switch:
                                      - platform: custom
                                        lambda: |-
                                          auto c = static_cast<LD2410 *>(ld2410);
                                          return {c->show_stats, c->show_engineering_stats};
                                    
                                        switches:
                                          - name: "Show Stats"
                                          - name: "Show Engineering Stats"
                                            
                                    muss das dort stehen:
                                    
                                    switch:
                                      - platform: custom
                                        lambda: |-
                                          auto c = static_cast<LD2410 *>(ld2410);
                                          return {c->show_stats, c->show_engineering_stats};
                                    
                                        switches:
                                          - name: "Show Stats"
                                            id: show_stats
                                          - name: "Show Engineering Stats"
                                            id: show_eng_stats
                                    
                                    liv-in-skyL 1 Antwort Letzte Antwort
                                    1
                                    • Stefan WilkeS Stefan Wilke

                                      @liv-in-sky

                                      Habe eine Github Anfrage gestartet und auch schon eine Antwort auf meine Frage erhalten. Es funktioniert, habe es gerade getestet.

                                      Um das Setting "Show Stats" auch nach einen Neustart auf On zu setzten muß in meiner YAML Datei folgende Zeilen eingefügt werden.

                                      Anstatt:
                                      
                                      esphome:
                                        name: "radarsensor"
                                        includes:
                                          - ld2410.h
                                      
                                      muss das da stehen:
                                      
                                      esphome:
                                        name: "radarsensor"
                                        includes:
                                          - ld2410.h
                                        on_boot:
                                          priority: -10
                                          # ...
                                          then:
                                            - switch.turn_on: show_stats
                                      
                                      und etwas weiter unten 
                                      
                                      Anstatt:
                                      
                                      switch:
                                        - platform: custom
                                          lambda: |-
                                            auto c = static_cast<LD2410 *>(ld2410);
                                            return {c->show_stats, c->show_engineering_stats};
                                      
                                          switches:
                                            - name: "Show Stats"
                                            - name: "Show Engineering Stats"
                                              
                                      muss das dort stehen:
                                      
                                      switch:
                                        - platform: custom
                                          lambda: |-
                                            auto c = static_cast<LD2410 *>(ld2410);
                                            return {c->show_stats, c->show_engineering_stats};
                                      
                                          switches:
                                            - name: "Show Stats"
                                              id: show_stats
                                            - name: "Show Engineering Stats"
                                              id: show_eng_stats
                                      
                                      liv-in-skyL Offline
                                      liv-in-skyL Offline
                                      liv-in-sky
                                      schrieb am zuletzt editiert von liv-in-sky
                                      #50

                                      @stefan-wilke

                                      noch eine frage - die version auf github ist anders als die version von dir -z.b. die version ist auf github neuer und die mqtt settings fehlen

                                      hast du vor das yaml weiter zu pflegen und wenn ja, könntest du das posten?

                                      nach einem gelösten Thread wäre es sinnvoll dies in der Überschrift des ersten Posts einzutragen [gelöst]-... Bitte benutzt das Voting rechts unten im Beitrag wenn er euch geholfen hat. Forum-Tools: PicPick https://picpick.app/en/download/ und ScreenToGif https://www.screentogif.com/downloads.html

                                      Stefan WilkeS 1 Antwort Letzte Antwort
                                      0
                                      • liv-in-skyL liv-in-sky

                                        @stefan-wilke

                                        noch eine frage - die version auf github ist anders als die version von dir -z.b. die version ist auf github neuer und die mqtt settings fehlen

                                        hast du vor das yaml weiter zu pflegen und wenn ja, könntest du das posten?

                                        Stefan WilkeS Offline
                                        Stefan WilkeS Offline
                                        Stefan Wilke
                                        schrieb am zuletzt editiert von
                                        #51

                                        @liv-in-sky

                                        Ich verstehe nicht so ganz was du meinst. Habe so gut wie keine Ahnung von ESPHome Programmen. Meine YAML Datei ist nach stundenlanger Suche aus dem Netz aber ich kann jetzt auf die Schnelle die Quelle nicht finden.

                                        Mein Sensor lauft jetzt richtig gut und sehr schnell. Ich kann mir gerade nicht vorstellen, was man daran noch ändern sollte. So eine schnelle Reaktionszeit habe ich mit keinem Bewegungsmelder gesehen.

                                        Eins fehlt mir doch noch. Ein Gehäuse und am Besten eins mit Kugelgelenk für den kleinen Sensor.

                                        Was fehlt dir denn an meiner Yaml Datei, was stellst du dir denn vor?

                                        liv-in-skyL 1 Antwort Letzte Antwort
                                        0
                                        • Stefan WilkeS Stefan Wilke

                                          @liv-in-sky

                                          Ich verstehe nicht so ganz was du meinst. Habe so gut wie keine Ahnung von ESPHome Programmen. Meine YAML Datei ist nach stundenlanger Suche aus dem Netz aber ich kann jetzt auf die Schnelle die Quelle nicht finden.

                                          Mein Sensor lauft jetzt richtig gut und sehr schnell. Ich kann mir gerade nicht vorstellen, was man daran noch ändern sollte. So eine schnelle Reaktionszeit habe ich mit keinem Bewegungsmelder gesehen.

                                          Eins fehlt mir doch noch. Ein Gehäuse und am Besten eins mit Kugelgelenk für den kleinen Sensor.

                                          Was fehlt dir denn an meiner Yaml Datei, was stellst du dir denn vor?

                                          liv-in-skyL Offline
                                          liv-in-skyL Offline
                                          liv-in-sky
                                          schrieb am zuletzt editiert von
                                          #52

                                          @stefan-wilke

                                          dieser link - von dir gepostet https://github.com/amandel/esphome-ld2410 - enthält ein etwas anderes sample yaml als das, was du gepostest hast

                                          nach einem gelösten Thread wäre es sinnvoll dies in der Überschrift des ersten Posts einzutragen [gelöst]-... Bitte benutzt das Voting rechts unten im Beitrag wenn er euch geholfen hat. Forum-Tools: PicPick https://picpick.app/en/download/ und ScreenToGif https://www.screentogif.com/downloads.html

                                          1 Antwort Letzte Antwort
                                          0
                                          Antworten
                                          • In einem neuen Thema antworten
                                          Anmelden zum Antworten
                                          • Älteste zuerst
                                          • Neuste zuerst
                                          • Meiste Stimmen


                                          Support us

                                          ioBroker
                                          Community Adapters
                                          Donate

                                          618

                                          Online

                                          32.4k

                                          Benutzer

                                          81.4k

                                          Themen

                                          1.3m

                                          Beiträge
                                          Community
                                          Impressum | Datenschutz-Bestimmungen | Nutzungsbedingungen | Einwilligungseinstellungen
                                          ioBroker Community 2014-2025
                                          logo
                                          • Anmelden

                                          • Du hast noch kein Konto? Registrieren

                                          • Anmelden oder registrieren, um zu suchen
                                          • Erster Beitrag
                                            Letzter Beitrag
                                          0
                                          • Home
                                          • Aktuell
                                          • Tags
                                          • Ungelesen 0
                                          • Kategorien
                                          • Unreplied
                                          • Beliebt
                                          • GitHub
                                          • Docu
                                          • Hilfe