『瀚思彼岸』» 智能家居技术论坛

标题: CEM5855H毫米波雷达使用esphome通过串口连入HA可修改参数 [打印本页]

作者: qqjil    时间: 2022-8-13 13:07
标题: CEM5855H毫米波雷达使用esphome通过串口连入HA可修改参数
本帖最后由 qqjil 于 2022-8-13 13:07 编辑

前几天写了个CEM5825F的通过串口接入HA,按照一样的思路把5855H的串口也接入了HA,LD1115H有几条串口命令不一样,一样的也是生效的,也能显示运动状态。
https://bbs.hassbian.com/thread-17438-1-1.html CEM5825F的参考链接使用5855H和LD1115H对比了下,发现5855H误报情况比1115H要好,但是5855H有个问题是有时候触发非常不灵敏,就找卖家看能不能改到1115H固件,要了好久卖家给了我2条命令“ind_min_mov=1”和”ind_min_occ=2“,改了下效果立马变好,我也把这2条命令加进去了,有此问题的可以试一下。
yaml配置文件
  1. esphome:
  2.   name: cem5855h
  3.   
  4.   includes:
  5.   - UartReadLineSensor_55h.h

  6. esp32:
  7.   board: esp32dev

  8. # Enable logging
  9. logger:
  10.   #level: VERBOSE #makes uart stream available in esphome logstream
  11.   #baud_rate: 0 #disable logging over uart

  12. # Enable Home Assistant API
  13. api:

  14. ota:
  15.   password: "password"

  16. wifi:
  17.   networks:
  18.   - ssid: "WIFI"
  19.     password: "12345678"
  20.   - ssid: "WIFI2"
  21.     password: "12345678"  
  22.   - ssid: "WIFI3"
  23.     password: "12345678"   
  24.   # Enable fallback hotspot (captive portal) in case wifi connection fails
  25.   ap:
  26.     ssid: "mmWave-Occupancy"
  27.     password: "password"

  28. substitutions:
  29.   device_name: mmwave-sensor
  30.   
  31. captive_portal:

  32. web_server:
  33.   port: 80
  34.   version: 2
  35.   include_internal: true

  36. http_request:
  37.   useragent: esphome/$device_name
  38.   timeout: 2s

  39. # switch:
  40. #   - platform: safe_mode
  41. #     internal: true
  42. #     name: use_safe_mode

  43. binary_sensor:
  44. - platform: gpio
  45.   name: mmwave_in_bedroom
  46.   pin:
  47.     number: GPIO5
  48.     mode: INPUT_PULLDOWN

  49. uart:
  50.   id: uart_bus
  51.   tx_pin: GPIO16
  52.   rx_pin: GPIO17
  53.   baud_rate: 115200
  54.   # debug:
  55.   #   direction: BOTH
  56.   #   dummy_receiver: true
  57.   #   after:
  58.   #     delimiter: "\n"
  59.   #   sequence:
  60.   #     - lambda: UARTDebug::log_string(direction, bytes);

  61. number:
  62.   - platform: template
  63.     id: th1
  64.     name: "th1 移动灵敏度"
  65.     mode: box
  66.     min_value: 130
  67.     max_value: 1000
  68.     initial_value: 130
  69.     optimistic: true
  70.     step: 50
  71.     restore_value: true
  72.     #unit_of_measurement: m
  73.     set_action:
  74.       - uart.write: !lambda
  75.                       int th1 = (int)ceil(x / 1.0);
  76.                       std::string mss = "th1=" + to_string(th1);
  77.                       return std::vector<unsigned char>(mss.begin(), mss.end());
  78.                      
  79.   - platform: template
  80.     id: th2
  81.     name: "th2 静止灵敏度"
  82.     mode: box
  83.     min_value: 200
  84.     max_value: 1000
  85.     initial_value: 250
  86.     optimistic: true
  87.     step: 50
  88.     restore_value: true
  89.     #unit_of_measurement: ms
  90.     set_action:
  91.       - uart.write: !lambda
  92.                       int th2 = (int)ceil(x / 1.0);
  93.                       std::string mss = "th2=" + to_string(th2);
  94.                       return std::vector<unsigned char>(mss.begin(), mss.end());
  95.                      
  96.   - platform: template
  97.     id: th_in
  98.     name: "th_in 触发灵敏度"
  99.     mode: box
  100.     min_value: 130
  101.     max_value: 1000
  102.     initial_value: 360
  103.     optimistic: true
  104.     step: 50
  105.     restore_value: true
  106.     #unit_of_measurement: ms
  107.     set_action:
  108.       - uart.write: !lambda
  109.                       int th_in = (int)ceil(x / 1.0);
  110.                       std::string mss = "th_in=" + to_string(th_in);
  111.                       return std::vector<unsigned char>(mss.begin(), mss.end());
  112.                      
  113.   - platform: template
  114.     id: tons
  115.     name: "GPIO 延时时间"
  116.     mode: box
  117.     min_value: 1
  118.     max_value: 100
  119.     initial_value: 30
  120.     optimistic: true
  121.     step: 1
  122.     restore_value: true
  123.     unit_of_measurement: "秒"
  124.     set_action:
  125.       - uart.write: !lambda
  126.                       int tons = (int)ceil(x / 1.0);
  127.                       std::string mss = "tons=" + to_string(tons);
  128.                       return std::vector<unsigned char>(mss.begin(), mss.end());
  129.                      
  130.   - platform: template
  131.     id: utons
  132.     name: "uart 帧间隔"
  133.     mode: box
  134.     min_value: 50
  135.     max_value: 1000
  136.     initial_value: 100
  137.     optimistic: true
  138.     step: 50
  139.     restore_value: true
  140.     unit_of_measurement: "毫秒"
  141.     set_action:
  142.       - uart.write: !lambda
  143.                       int utons = (int)ceil(x / 1.0);
  144.                       std::string mss = "utons=" + to_string(utons);
  145.                       return std::vector<unsigned char>(mss.begin(), mss.end());
  146.                      
  147.   - platform: template
  148.     id: ind_min_mov
  149.     name: "ind_min_mov 移动幅度"
  150.     mode: box
  151.     min_value: 0
  152.     max_value: 5
  153.     initial_value: 1
  154.     optimistic: true
  155.     step: 1
  156.     restore_value: true
  157.     #unit_of_measurement: m
  158.     set_action:
  159.       - uart.write: !lambda
  160.                       int ind_min_mov = (int)ceil(x / 1.0);
  161.                       std::string mss = "ind_min_mov=" + to_string(ind_min_mov);
  162.                       return std::vector<unsigned char>(mss.begin(), mss.end());
  163.                      
  164.   - platform: template
  165.     id: ind_min_occ
  166.     name: "ind_min_occ 静止幅度"
  167.     mode: box
  168.     min_value: 0
  169.     max_value: 5
  170.     initial_value: 2
  171.     optimistic: true
  172.     step: 1
  173.     restore_value: true
  174.     #unit_of_measurement: m
  175.     set_action:
  176.       - uart.write: !lambda
  177.                       int ind_min_occ = (int)ceil(x / 1.0);
  178.                       std::string mss = "ind_min_occ=" + to_string(ind_min_occ);
  179.                       return std::vector<unsigned char>(mss.begin(), mss.end());
  180. button:
  181.   - platform: template
  182.     id: save
  183.     name: "save 保存"
  184.     on_press:
  185.       - uart.write: "save"

  186.   - platform: template
  187.     id: get_all
  188.     name: "get_all 获取参数"
  189.     on_press:
  190.       - uart.write: "get_all"

  191.   - platform: template
  192.     id: initial
  193.     name: "initial 恢复出厂设置"
  194.     on_press:
  195.       - uart.write: "initial"
  196.       
  197. text_sensor:
  198. - platform: custom
  199.   lambda: |-
  200.     auto my_custom_sensor = new UartReadLineSensor(id(uart_bus));
  201.     App.register_component(my_custom_sensor);
  202.     return {my_custom_sensor};
  203.   text_sensors:
  204.     id: "uart_readline"
  205.     name: "mmWave状态"
复制代码
C++文件UartReadLineSensor_55h.h
  1. #include "esphome.h"

  2. class UartReadLineSensor : public Component, public UARTDevice, public TextSensor{
  3. public:
  4.   UartReadLineSensor(UARTComponent *parent) : UARTDevice(parent) {}

  5.   void setup() override {
  6.     // nothing to do here
  7.   }

  8.   int readline(int readch, char *buffer, int len)
  9.   {
  10.     static int pos = 0;
  11.     int rpos;

  12.     if (readch > 0) {
  13.       switch (readch) {
  14.         case '\n': // Ignore new-lines
  15.           break;
  16.         case '\r': // Return on CR
  17.           rpos = pos;
  18.           pos = 0;  // Reset position index ready for next time
  19.           return rpos;
  20.         default:
  21.           if (pos < len-1) {
  22.             buffer[pos++] = readch;
  23.             buffer[pos] = 0;
  24.           }
  25.       }
  26.     }
  27.     // No end of line has been found, so return -1.
  28.     return -1;
  29.   }

  30.   void loop() override {
  31.     const int max_line_length = 80;
  32.     static char buffer[max_line_length];
  33.         static uint8_t mov_flag = 0;
  34.         static int uartdata = 0;
  35.         static char u16_dis[7] = {0};
  36.         static char u16_dis_1[6] = {0};
  37.         static char u16_dis_2[5] = {0};
  38.         static int i,j;
  39.         static float intdis = 0;
  40.         static float f32rmax;
  41.         static char chartemp[4] = {0};
  42.         static char chartemp5[5] = {0};
  43.         static char chartemp2[2] = {0};
  44.         static char chartemp3[3] = {0};
  45.         static uint8_t chartemp1 = 0;
  46.         
  47.     while (available()) {
  48.                 uartdata = readline(read(), buffer, max_line_length);
  49.                 if(uartdata > 0) {
  50.                         //publish_state(buffer);
  51.                          if(buffer[0] == 0x6d && buffer[1] == 0x6f && buffer[2] == 0x76)
  52.                         {
  53.                                 if(mov_flag != 0)
  54.                                 {
  55.                                         mov_flag = 0;
  56.                                         publish_state("运动");
  57.                                 }
  58.                         }
  59.                         
  60.                         else if(buffer[0] == 0x6f && buffer[1] == 0x63 && buffer[2] == 0x63)
  61.                         {
  62.                                 if(mov_flag != 1)
  63.                                 {
  64.                                         mov_flag = 1;
  65.                                         publish_state("静止");
  66.                                 }
  67.                                 
  68.                         }
  69.                         else if(buffer[0] == 0x6e && buffer[1] == 0x75 && buffer[2] == 0x6C)
  70.                         {
  71.                                 if(mov_flag != 2)
  72.                                 {
  73.                                         mov_flag = 2;
  74.                                         publish_state("无人");
  75.                                 }
  76.                         }
  77.                         else if(buffer[0] == 0x74 && buffer[1] == 0x68 && buffer[2] == 0x31 && buffer[3] == 0x20 && buffer[4] == 0x69 && buffer[5] == 0x73 && buffer[6] == 0x20 )
  78.                         {
  79.                                 j = 0;
  80.                                 if(uartdata == 9)
  81.                                 {
  82.                                         for(i = 7; i < uartdata; i++)
  83.                                         {
  84.                                                 chartemp2[j] = buffer[i];
  85.                                                 j++;
  86.                                         }
  87.                                         id(th1).publish_state(atoi(chartemp2));                                       
  88.                                 }
  89.                                 if(uartdata == 10)
  90.                                 {
  91.                                         for(i = 7; i < uartdata; i++)
  92.                                         {
  93.                                                 chartemp3[j] = buffer[i];
  94.                                                 j++;
  95.                                         }
  96.                                         id(th1).publish_state(atoi(chartemp3));                                       
  97.                                 }
  98.                                 if(uartdata == 11)
  99.                                 {
  100.                                         for(i = 7; i < uartdata; i++)
  101.                                         {
  102.                                                 chartemp[j] = buffer[i];
  103.                                                 j++;
  104.                                         }
  105.                                         id(th1).publish_state(atoi(chartemp));                                       
  106.                                 }
  107.                         }
  108.                         else if(buffer[0] == 0x74 && buffer[1] == 0x68 && buffer[2] == 0x32 && buffer[3] == 0x20 && buffer[4] == 0x69 && buffer[5] == 0x73 && buffer[6] == 0x20 )
  109.                         {
  110.                                 j = 0;
  111.                                 if(uartdata == 9)
  112.                                 {
  113.                                         for(i = 7; i < uartdata; i++)
  114.                                         {
  115.                                                 chartemp2[j] = buffer[i];
  116.                                                 j++;
  117.                                         }
  118.                                         id(th2).publish_state(atoi(chartemp2));                                       
  119.                                 }
  120.                                 if(uartdata == 10)
  121.                                 {
  122.                                         for(i = 7; i < uartdata; i++)
  123.                                         {
  124.                                                 chartemp3[j] = buffer[i];
  125.                                                 j++;
  126.                                         }
  127.                                         id(th2).publish_state(atoi(chartemp3));                                       
  128.                                 }
  129.                                 if(uartdata == 11)
  130.                                 {
  131.                                         for(i = 7; i < uartdata; i++)
  132.                                         {
  133.                                                 chartemp[j] = buffer[i];
  134.                                                 j++;
  135.                                         }
  136.                                         id(th2).publish_state(atoi(chartemp));                                       
  137.                                 }
  138.                         }
  139.                         else if(buffer[0] == 0x74 && buffer[1] == 0x6f && buffer[2] == 0x6e && buffer[3] == 0x73 && buffer[4] == 0x20 && buffer[5] == 0x69 && buffer[6] == 0x73 && buffer[7] == 0x20 )
  140.                         {
  141.                                 j = 0;
  142.                                 if(uartdata == 9)
  143.                                 {
  144.                                         chartemp1 = buffer[8]-48;
  145.                                         id(tons).publish_state(chartemp1);                                       
  146.                                 }
  147.                                 if(uartdata == 10)
  148.                                 {
  149.                                         for(i = 8; i < uartdata; i++)
  150.                                         {
  151.                                                 chartemp2[j] = buffer[i];
  152.                                                 j++;
  153.                                         }
  154.                                         id(tons).publish_state(atoi(chartemp2));                                       
  155.                                 }
  156.                                 if(uartdata == 11)
  157.                                 {
  158.                                         for(i = 8; i < uartdata; i++)
  159.                                         {
  160.                                                 chartemp3[j] = buffer[i];
  161.                                                 j++;
  162.                                         }
  163.                                         id(tons).publish_state(atoi(chartemp3));                                       
  164.                                 }                                
  165.                         }
  166.                         else if(buffer[0] == 0x75 && buffer[1] == 0x74 && buffer[2] == 0x6f && buffer[3] == 0x6e && buffer[4] == 0x73 && buffer[5] == 0x20 && buffer[6] == 0x69 && buffer[7] == 0x73 && buffer[8] == 0x20 )
  167.                         {
  168.                                 j = 0;
  169.                                 if(uartdata == 11)
  170.                                 {
  171.                                         for(i = 9; i < uartdata; i++)
  172.                                         {
  173.                                                 chartemp2[j] = buffer[i];
  174.                                                 j++;
  175.                                         }
  176.                                         id(utons).publish_state(atoi(chartemp2));                                       
  177.                                 }
  178.                                 if(uartdata == 12)
  179.                                 {
  180.                                         for(i = 9; i < uartdata; i++)
  181.                                         {
  182.                                                 chartemp3[j] = buffer[i];
  183.                                                 j++;
  184.                                         }
  185.                                         id(utons).publish_state(atoi(chartemp3));                                       
  186.                                 }        
  187.                                 if(uartdata == 13)
  188.                                 {
  189.                                         for(i = 9; i < uartdata; i++)
  190.                                         {
  191.                                                 chartemp[j] = buffer[i];
  192.                                                 j++;
  193.                                         }
  194.                                         id(utons).publish_state(atoi(chartemp));                                       
  195.                                 }                                
  196.                         }
  197.                         else if(buffer[0] == 0x74 && buffer[1] == 0x68 && buffer[2] == 0x5f && buffer[3] == 0x69 && buffer[4] == 0x6e && buffer[5] == 0x20 && buffer[6] == 0x69 && buffer[7] == 0x73 && buffer[8] == 0x20 )
  198.                         {
  199.                                 j = 0;
  200.                                 if(uartdata == 11)
  201.                                 {
  202.                                         for(i = 9; i < uartdata; i++)
  203.                                         {
  204.                                                 chartemp2[j] = buffer[i];
  205.                                                 j++;
  206.                                         }
  207.                                         id(th_in).publish_state(atoi(chartemp2));                                       
  208.                                 }
  209.                                 if(uartdata == 12)
  210.                                 {
  211.                                         for(i = 9; i < uartdata; i++)
  212.                                         {
  213.                                                 chartemp3[j] = buffer[i];
  214.                                                 j++;
  215.                                         }
  216.                                         id(th_in).publish_state(atoi(chartemp3));                                       
  217.                                 }        
  218.                                 if(uartdata == 13)
  219.                                 {
  220.                                         for(i = 9; i < uartdata; i++)
  221.                                         {
  222.                                                 chartemp[j] = buffer[i];
  223.                                                 j++;
  224.                                         }
  225.                                         id(th_in).publish_state(atoi(chartemp));                                       
  226.                                 }                                
  227.                         }
  228.                         memset(chartemp,0,4);
  229.                         memset(chartemp3,0,3);
  230.                         memset(chartemp2,0,2);
  231.                         memset(chartemp5,0,2);
  232.                 }
  233.     }
  234.   }
  235. };
复制代码




作者: sxrcm    时间: 2022-8-13 13:41
本帖最后由 sxrcm 于 2022-10-20 11:45 编辑

给雷达大王点赞
作者: jjcs    时间: 2022-8-13 15:35
大佬牛逼
作者: 碧悠门下小书童    时间: 2022-8-15 09:50
这个牛的,大佬牛逼!
作者: fjn1999    时间: 2022-8-24 17:25
哎,问个问题,无论5855还是1115, 调整的参数每次断电重启都恢复到出厂设置,我不清楚,ESPhome的固件,是否每次断电重启后,把存储的参数写入5855/1115?

一直困扰着我啊。
作者: qqjil    时间: 2022-8-24 21:15
fjn1999 发表于 2022-8-24 17:25
哎,问个问题,无论5855还是1115, 调整的参数每次断电重启都恢复到出厂设置,我不清楚,ESPhome的固件,是 ...

你应该是设置完参数后没有发save命令或者没有点我固件上面的保存按钮,否则断电参数会重置的
作者: he674963336    时间: 2022-8-31 18:37
大佬牛逼   
作者: pnjycn    时间: 2022-9-28 22:07
干货太干了,难以下咽,99%像我这种小白,看完跟看天书一样
作者: he674963336    时间: 2022-9-28 22:57
这个牛的,大佬牛逼!
作者: wodepiqi    时间: 2022-10-2 13:11
不会切换无人
作者: qqjil    时间: 2022-10-15 17:11
wodepiqi 发表于 2022-10-2 13:11
不会切换无人

不切无人你的固件应该是LD1115H的,需要CME5855H的固件版本
作者: jyz_0501    时间: 2022-10-15 19:34
点赞 ~ 毫米波 慢慢要走入人感领域了
作者: 情非殇    时间: 2022-10-15 22:17
本帖最后由 情非殇 于 2022-10-16 00:14 编辑

请教下,大佬有没有uart转mqtt的作业给抄一下,我想直接在nodered里分析处理

作者: wodepiqi    时间: 2022-10-16 07:33
qqjil 发表于 2022-10-15 17:11
不切无人你的固件应该是LD1115H的,需要CME5855H的固件版本

cme跟cme
是两种嘛
作者: wodepiqi    时间: 2022-10-16 07:35
qqjil 发表于 2022-10-15 17:11
不切无人你的固件应该是LD1115H的,需要CME5855H的固件版本

5855的上位机里面输出的日志固件版本就是1115的固件
作者: mmtzwyd    时间: 2022-11-10 06:31
不知道楼主的5855有没有这种情况。就是长时间不触发后,再次触发很不时触发不了,要凑近挥手才有用,但是触发一次后,短时间内又很灵敏。
作者: mmtzwyd    时间: 2022-11-10 17:44
我问过客服了,技术支持的人说. 无人状态五分钟后会进入休眠状态,休眠状态是比较难再次触发的. 而我卫生间里边要很大的动作才能再次触发.....

作者: qqjil    时间: 2022-11-12 16:41
mmtzwyd 发表于 2022-11-10 17:44
我问过客服了,技术支持的人说. 无人状态五分钟后会进入休眠状态,休眠状态是比较难再次触发的. 而我卫生间里 ...

你看下这2个参数 th_in的灵敏度这个是休眠后触发的灵敏度,你可以改到和th1的灵敏度一样,这个是防误报用的
还有 ind_min_mov 移动幅度 可以改小一档,这个是检测运动的速度,越小能检测越小的幅度

作者: hejie127    时间: 2022-11-15 22:02
楼主请问,另一个帖子中:https://bbs.hassbian.com/thread-17438-1-1.html 你也分享过固件,另一个帖子中的固件是不是esp32的。

这个帖子中提到了你的固件。但是好像不可用。
麻烦你分享一下 esp12S的固件行吗。可以和这个帖子中的硬件配套的。https://bbs.hassbian.com/thread-17617-1-1.html

作者: feifei006    时间: 2023-3-14 21:44
hejie127 发表于 2022-11-15 22:02
楼主请问,另一个帖子中:https://bbs.hassbian.com/thread-17438-1-1.html 你也分享过固件,另一个帖子中 ...

同求,用ESP12S,一传数据就死机了
作者: feifei006    时间: 2023-3-16 10:41
请教一个问是,按你的这个代码接入了CEM5855H,不过用的是ESP12S的芯片,结果就一直显示几条正常数据,就显示一条Connection closed错误,加到HA里就是一下显示不可用一下显示可用,一直来回跳,是什么问题呢?ESP32和ESP12S的代码是不是也不一样呢?
作者: godzqh    时间: 2023-3-21 12:12
feifei006 发表于 2023-3-16 10:41
请教一个问是,按你的这个代码接入了CEM5855H,不过用的是ESP12S的芯片,结果就一直显示几条正常数据,就显 ...

调用数据太多 ESP12S扛不住
就显示几个数据就行了
作者: zxyny1989    时间: 2024-4-21 22:21
我用esp32和d1 mini均会死机,不知道是什么情况




欢迎光临 『瀚思彼岸』» 智能家居技术论坛 (https://bbs.hassbian.com/) Powered by Discuz! X3.5