ESP32+RF433接收发送组RF桥

zro22

硬件架构很简单ESP32外接蜂鸟远-R1和远-T2L模块作为收发射频
实现两个功能
1，可以通过指定MQTT填写内容后，转换成射频码发送出去，实现比如HA控制灯开关（无状态反馈）。
2，射频遥控器发码后 ESP32接收到 转发到HA或者MQTT，HA里面通过自动化控制设备。
可以用线程的RF-bridge
https://bbs.hassbian.com/thread-14172-1-1.html
本着DIY的原则，我自己画了个小板子，板子上有433和315两套，不过我只用433所以只买了433模块




ESPhome的代码

esphome:
  name: rfbridge
  friendly_name: RFBridge

esp32:
  board: nodemcu-32s
  framework:
    type: arduino

# Enable logging
logger:

# Enable Home Assistant API
api:
  encryption:
    key: "oio02kQmD6MJYIYddpwYGipMy/1hY="

ota:
  password: "f6b09c4d30199c5342"

wifi:
  ssid: shebeijian
  password: !secret wifi_password

  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "Rfbridge Fallback Hotspot"
    password: "iTbJierrtJuCuo"
  use_address: 192.168.10.48 

captive_portal:
    
web_server:
  port: 80
globals:
  - id: global_group
    type: int
    restore_value: no
    initial_value: '0'
  - id: global_device
    type: int
    restore_value: no
    initial_value: '0'  
  - id: global_rcvstr
    type: std::string
    restore_value: no  # Strings cannot be saved/restored    
  - id: global_rcvvalstr
    type: std::string
    restore_value: no  # Strings cannot be saved/restored        
  - id: global_rf_rcvd
    type: bool
    restore_value: no
    initial_value: '0'
  - id: global_oldrcv
    type: long long int
    restore_value: no
    initial_value: '0'
  - id: global_oldrcvtime
    type: int
    restore_value: no
    initial_value: '0'
  - id: global_rcv_skip
    type: int
    restore_value: no
    initial_value: '0'
  - id: global_same_cnt
    type: int
    restore_value: no
    initial_value: '0'
  - id: global_snd_grop
    type: std::string
    restore_value: no
  - id: global_snd_dev
    type: std::string
    restore_value: no
  - id: global_snd_state
    type: int
    restore_value: no 
    initial_value: '0'      
mqtt:
  broker: 192.168.10.222
  username: admin
  password: mqtt
  on_json_message:
    - topic: rfbridge/rftosend/raw
      qos: 0
      then:
        - remote_transmitter.transmit_rc_switch_raw:
            code: !lambda |-
                  int code = 0;
                  int i=0;
                  char strcode[25];
                  strcode[24]=0;
                  if (x.containsKey("code")){
                  code =  x["code"];
                  ESP_LOGD("RFRAWSND", "%d",code);
                  for(i=0;i<24;i++)
                  {
                    strcode[24-i-1] = '0';
                    if(code&1)
                      strcode[24-i-1] = '1';
                    code=code/2;
                    //ESP_LOGD("MQSEND", "%c",strcode[i]);
                  }
                  //itoa(code,strcode,2);
                  ESP_LOGD("RFRAWSND", "%s",strcode);
                  return strcode;}
                  return 0;
            protocol: 1
    - topic: rfbridge/rftosend/atype
      qos: 0
      then:
        - remote_transmitter.transmit_rc_switch_type_a:
            group: !lambda |-
                  /*{
                    "group": "25",  max31
                    "device": "18", max31
                    "state": 1  1 or 0
                  }*/
                  int grop = 0;
                  int i=0;
                  char strcode[6];
                  strcode[5]=0;
                  id(global_snd_grop) = "0";
                  if (x.containsKey("group")){
                  grop =  x["group"];
                  id(global_snd_grop) = grop; 
                  //ESP_LOGD("RFASND", "%d",grop);
                  /*strcode[0] = grop/10000 + 0x30;
                  strcode[1] = (grop%10000)/1000 + 0x30;
                  strcode[2] = (grop%1000)/100 + 0x30;
                  strcode[3] = (grop%100)/10 + 0x30;
                  strcode[4] = (grop%10) + 0x30 ;*/
                  for(i=0;i<5;i++)
                  {
                    strcode[4-i] = (grop&1) + 0x30;
                    grop = grop/2;
                  }
                  ESP_LOGD("RFASND", "Group:%s",strcode);
                  id(global_snd_grop) = strcode;
                  return strcode;}
                  return 0;
            device: !lambda |-
                  int devc = 0;
                  int i=0;
                  char strcode[6];
                  strcode[5]=0;
                  id(global_snd_dev) = "0";
                  if (x.containsKey("device")){
                  devc =  x["device"];
                  id(global_snd_dev) = devc;
                  //ESP_LOGD("RFASND", "%d",devc);
                  /*strcode[0] = devc/10000 + 0x30;
                  strcode[1] = (devc%10000)/1000 + 0x30;
                  strcode[2] = (devc%1000)/100 + 0x30;
                  strcode[3] = (devc%100)/10 + 0x30;
                  strcode[4] = (devc%10) + 0x30;*/
                  for(i=0;i<5;i++)
                  {
                    strcode[4-i] = (devc&1) + 0x30;
                    devc = devc/2;
                  }
                  ESP_LOGD("RFASND", "Device:%s",strcode);
                  id(global_snd_dev) = strcode;
                  return strcode;}
                  return 0;
            state: !lambda |-
                   int stat;
                   stat = x["state"];
                   id(global_snd_state) = stat;
                   ESP_LOGD("RFASND", "state:%d",stat);
                   return stat;
            protocol: 1  
        - delay: 0.01s    
        - remote_transmitter.transmit_rc_switch_type_a:
            #transmitter_id: tr433
            group: !lambda |-
                  return id(global_snd_grop);
            device: !lambda |-
                  return id(global_snd_dev);
            state: !lambda |-
                   return id(global_snd_state);
            protocol: 1
        - delay: 0.01s    
        - remote_transmitter.transmit_rc_switch_type_a:
            group: !lambda |-
                  return id(global_snd_grop);
            device: !lambda |-
                  return id(global_snd_dev);
            state: !lambda |-
                   return id(global_snd_state);
            protocol: 1   
        - delay: 0.01s                         
        - remote_transmitter.transmit_rc_switch_type_a:
            group: !lambda |-
                  return id(global_snd_grop);
            device: !lambda |-
                  return id(global_snd_dev);
            state: !lambda |-
                   return id(global_snd_state);
            protocol: 1   
        - delay: 0.01s  
        - remote_transmitter.transmit_rc_switch_type_a:
            group: !lambda |-
                  return id(global_snd_grop);
            device: !lambda |-
                  return id(global_snd_dev);
            state: !lambda |-
                   return id(global_snd_state);
            protocol: 1                                      
        - delay: 0.01s  
        - remote_transmitter.transmit_rc_switch_type_a:
            group: !lambda |-
                  return id(global_snd_grop);
            device: !lambda |-
                  return id(global_snd_dev);
            state: !lambda |-
                   return id(global_snd_state);
            protocol: 1               
remote_receiver:
  pin: 
    number: GPIO19
    #inverted: True
    mode: INPUT_PULLUP
  dump: 
    - rc_switch
  # Settings to optimize recognition of RF devices
  tolerance: 20%
  filter: 250us
  idle: 6ms
#  buffer_size: 3kb
  on_rc_switch:
    then: 
      - homeassistant.event:
          event: esphome.rf_code_received
          data:
            code: !lambda |- 
                //'char buffer [10];return itoa(data.code,buffer,16);'
                char rcvdata[80];
                std::string nullbuf;
                int grop=0;
                int devc=0;
                int channel=0;
                int cmd=0;
                int subcmd=0;
                int i;
                int curtime;
                long long temp;
                int state=0;
                id(global_rcv_skip) = 0;
                //root["code"] = x.code;
                temp = x.code;
                ESP_LOGD("RCV", "temp:%llx",temp);
                sprintf(rcvdata, "%llx", temp);
                id(global_rcvvalstr) = rcvdata;
                //if(temp>0xffffffff)
                curtime = millis();
                if(((temp>>16)&0xffffff)==0x3191f9)
                {
                  if(id(global_oldrcv)==temp)
                  {
                    if(curtime-id(global_oldrcvtime)<100)
                    {
                      id(global_rcv_skip) = 1;
                      id(global_same_cnt)++;
                    }
                  }else
                    id(global_same_cnt)=0;
                  if(((temp>>1)&0x3)==0)
                    id(global_rcv_skip) = 1;
                  if((id(global_same_cnt)>=6)&&(id(global_same_cnt)%2==0)) 
                  {
                    id(global_rcv_skip) = 0; 
                  }
                  ESP_LOGD("RCV", "Millis() %d diff: %d skip:%d cnt:%d", curtime,curtime-id(global_oldrcvtime),id(global_rcv_skip),id(global_same_cnt));
                  id(global_oldrcv) = temp;
                  if((id(global_rcv_skip)==0)||(id(global_oldrcv)==temp))
                    id(global_oldrcvtime) = curtime;
                  
                  sprintf(rcvdata, "%llx", temp>>3);
                  //root["dooya"] = rcvdata;
                  grop = (temp>>19);
                  devc = (temp&0x7ffff) >> 11;
                  channel = (temp&0x7ff) >> 7;
                  cmd = (temp&0x7f) >> 3;
                  subcmd = (temp&0x7);
                  //ESP_LOGD("RFDOOYA", "Group:%x",grop);
                  //ESP_LOGD("RFDOOYA", "Device:%x",devc);
                  //ESP_LOGD("RFDOOYA", "Channel:%x",channel);
                  //ESP_LOGD("RFDOOYA", "Command:%x",cmd);
                  //ESP_LOGD("RFDOOYA", "SubCommand:%x",subcmd);
                  id(global_rcvstr) = rcvdata;
                  //id(rfsw).turn_on();
                  return id(global_rcvstr);
                }
                if(temp<0x555555)
                {
                  for(i=0;i<24;i++)
                  {
                    rcvdata[24-i-1]=0;
                    if(temp&1)
                      rcvdata[24-i-1]=1;
                    temp = temp/2;
                  }
                  //for(i=0;i<24;i++)
                  //  ESP_LOGD("RCV", "%d,%d",i,rcvdata[i]);
                  for(i=0;i<5;i++)
                  {
                    if((rcvdata[1+2*i]==0)&&(rcvdata[2+2*i]==0))
                      grop += 1;
                    if(i==4)
                      break;
                    grop *=2; 
                  }  
                  //ESP_LOGD("RCV", "Group:%d",grop);
                  for(i=0;i<5;i++)
                  {
                    if((rcvdata[11+2*i]==0)&&(rcvdata[12+2*i]==0))
                      devc += 1;
                    if(i==4)
                      break; 
                    devc *=2; 
                  }  
                  //ESP_LOGD("RCV", "Device:%d",devc);
                  if((rcvdata[21]==0)&&(rcvdata[22]==0))
                      state = 1;
                  //ESP_LOGD("RCV", "State:%d",state);
                  //id(global_group) = grop;
                  //id(global_device) = devc;
                  sprintf(rcvdata, "%02d", grop);
                  //root["Group"] = rcvdata;//grop;
                  sprintf(rcvdata, "%02d", devc);
                  //root["Device"] = rcvdata;//devc;
                  sprintf(rcvdata, "%d", state);
                  //root["State"] = rcvdata;//state;
                  sprintf(rcvdata, "%02d%02d%d", grop,devc,state);
                  //root["msg"] = rcvdata;
                  id(global_rcvstr) = rcvdata;
                }
                if(id(global_rcv_skip)==1)
                {                 
                  return nullbuf;
                }
                else
                  return id(global_rcvstr);
            value: !lambda 'return id(global_rcvvalstr);'
      #- mqtt.publish_json:
      #    topic: rfbridge/rfrcv
      #    payload: !lambda |-
            
      - mqtt.publish:
          topic: !lambda |- 
               if(id(global_rcv_skip)==1)
               {                 
                 return "rfbridge/rcvstrnull";
               }
               else
                 return "rfbridge/rcvstr";
          payload: !lambda |- 
               if(id(global_rcv_skip)==1)
               {                 
                 return "0";
               }
               else
                 return id(global_rcvstr);      
remote_transmitter:
  - pin: GPIO21
#    id: tr433
    # RF uses a 100% carrier signal
    carrier_duty_percent: 100%
#  - pin: GPIO20
#    id: tr315
#    carrier_duty_percent: 100%
switch:
  - platform: template
    name: swforrfsnd
    id: rfsw
    turn_on_action:
      - delay: 0.2s
      - switch.turn_off: rfsw
  - platform: template
    name: RF2 raw Button
    turn_on_action:
      - remote_transmitter.transmit_rc_switch_raw:
          code: '100010000000000010111110'
          protocol: 2  
  - platform: template
    name: RFA1 Power Button
    turn_on_action:
      - remote_transmitter.transmit_rc_switch_type_a:
          group: '01001'
          device: '10110'
          state: off
          protocol: 1
    turn_off_action:
      - remote_transmitter.transmit_rc_switch_type_a:
          group: '01001'
          device: '10110'
          state: on
          protocol: 1        
  - platform: template
    name: RFA2 Power Button
    turn_on_action:
      - remote_transmitter.transmit_rc_switch_type_a:
          group: '01001'
          device: '10111'
          state: off
          protocol: 1
    turn_off_action:
      - remote_transmitter.transmit_rc_switch_type_a:
          group: '01001'
          device: '10111'
          state: on
          protocol: 1  
  - platform: template
    name: RFCA Power Button
    turn_on_action:
      - remote_transmitter.transmit_rc_switch_type_c:
          family: 'c'
          group: 3
          device: 1
          state: off
          protocol: 1
    turn_off_action:
      - remote_transmitter.transmit_rc_switch_type_c:
          family: 'c'
          group: 3
          device: 1
          state: on
          protocol: 1          
  - platform: template
    name: RFCC Power Button
    turn_on_action:
      - remote_transmitter.transmit_rc_switch_type_c:
          family: 'a'
          group: 3
          device: 1
          state: off
          protocol: 1
    turn_off_action:
      - remote_transmitter.transmit_rc_switch_type_c:
          family: 'a'
          group: 3
          device: 1
          state: on
          protocol: 1   

复制代码

发送的时候在这个topicrfbridge/rftosend/atype
publish如下格式，我这里写了循环发送6次，间隔10ms
{
                    "group": "25",
                    "device": "18",
                    "state": 1
                  }
接收的时候收到的码会publish到这个topic
rfbridge/rcvstr 数据我做了一个处理，具体可以见程序


这里面switch都是没有用的然后接收后有一些处理，主要是射频按一次按键会发送好多次，如果只发送一次可能接收端收不到，所以要发很多次，这就造成一个问题，如果是用来控制开关，会出现反复开关，所以我尝试加了一些过滤，多短时间内收到同样的码给过滤掉。但是这样还是会出现其他问题，比如用来控制上下的时候，连击会比较慢。所以我最后射频只用来开或者关。
还有另外一个问题，你手上的遥控器发送的波形可能ESPHOME无法识别。
具体看这个贴子
https://bbs.hassbian.com/thread-14331-1-1.html
比如杜亚的就无法识别，我是用逻辑分析仪抓好波形之后，按照上面贴子的方法修改了源文件
修改源文件需要用DEV版本的eSPHOME
具体需要修改的源文件在
/volume2/docker/esphomedev/.esphome/build/rfbridge/src/esphome/components/remote_base/rc_switch_protocol.cpp
可以把其他都删了，只保留你手上遥控器的格式，这样识别正确率高一些



如下是blueprint因为我设定的是开和关只有最后一位不一样，比如
AABB0是关 AABB1是开，所以
把AABB和对应的设备关联就可以了，value_a天AABB，light_a选择对应的灯

blueprint:
  name: rf bridge receiver to trigger switch or light 4 cnt
  description: create 4 rf bridge or other mqtt topic value to control light or switch
  domain: automation
  input:
    value_a:
      selector:
        number:
    value_b:
      selector:
        number:
    value_c:
      selector:
        number:
    value_d:
      selector:
        number:        
    light_a:
      selector:
        entity:
          domain:
          - light
          - switch
          multiple: true    
    light_b:
      selector:
        entity:
          domain:
          - light
          - switch
          multiple: true    
    light_c:
      selector:
        entity:
          domain:
          - light
          - switch
          multiple: true    
    light_d:
      selector:
        entity:
          domain:
          - light
          - switch
          multiple: true    
          
trigger:
#  platform: mqtt
#  topic: !input mqtttopic
  platform: event
  event_type: esphome.rf_code_received
#  event_data:
#    code: !input rf_code
action:
- variables:
#    payload: "{{ trigger.payload }}"
    payload: "{{ trigger.event.data.code }}"
    value_a: !input value_a 
    value_b: !input value_b 
    value_c: !input value_c 
    value_d: !input value_d 
- choose:
  - conditions:
    - "{{ payload == value_a*10 }}"
    sequence: 
      - service: switch.turn_off
        data:
          entity_id: !input light_a
      - service: light.turn_off
        data:
          entity_id: !input light_a    
  - conditions:
    - "{{ payload == value_a*10+1 }}"
    sequence: 
      - service: switch.turn_on
        data:
          entity_id: !input light_a    
      - service: light.turn_on
        data:
          entity_id: !input light_a        
  - conditions:
    - "{{ payload == value_b*10 }}"
    sequence: 
      - service: switch.turn_off
        data:
          entity_id: !input light_b
      - service: light.turn_off
        data:
          entity_id: !input light_b    
  - conditions:
    - "{{ payload == value_b*10+1 }}"
    sequence: 
      - service: switch.turn_on
        data:
          entity_id: !input light_b    
      - service: light.turn_on
        data:
          entity_id: !input light_b        
  - conditions:
    - "{{ payload == value_c*10 }}"
    sequence: 
      - service: switch.turn_off
        data:
          entity_id: !input light_c
      - service: light.turn_off
        data:
          entity_id: !input light_c    
  - conditions:
    - "{{ payload == value_c*10+1 }}"
    sequence: 
      - service: switch.turn_on
        data:
          entity_id: !input light_c
      - service: light.turn_on
        data:
          entity_id: !input light_c        
  - conditions:
    - "{{ payload == value_d*10 }}"
    sequence: 
      - service: switch.turn_off
        data:
          entity_id: !input light_d
      - service: light.turn_off
        data:
          entity_id: !input light_d    
  - conditions:
    - "{{ payload == value_d*10+1 }}"
    sequence: 
      - service: switch.turn_on
        data:
          entity_id: !input light_d    
      - service: light.turn_on
        data:
          entity_id: !input light_d      

复制代码

kjjuhfv

esphome不是有api组件吗?
你一个433就用esp32
我海鲜市场搞得那个欧普的遥控器
红外射频共6个组件都只用8266
结果就是搞了这6组件加api发射后再加开关和按键组件就会死机

zro22

kjjuhfv 发表于 2023-7-1 23:02
esphome不是有api组件吗?
你一个433就用esp32
我海鲜市场搞得那个欧普的遥控器

所以我基本都用ESP32，不用8266，没差几块钱

zro22

kjjuhfv 发表于 2023-7-1 23:02
esphome不是有api组件吗?
你一个433就用esp32
我海鲜市场搞得那个欧普的遥控器

API发射怎么调用？

kjjuhfv

zro22 发表于 2023-7-1 23:07
API发射怎么调用？

api:
  services:
    - service: rf_433_send
      variables:
        code: string
        repeat: int
      then:
        - remote_transmitter.transmit_rc_switch_raw:
            code: !lambda 'return code;'
            repeat:
              times: !lambda 'return repeat;'

我也是抄大佬的

kjjuhfv

zro22 发表于 2023-7-1 23:06
所以我基本都用ESP32，不用8266，没差几块钱

厂家这样设计也没办法
挺想把8266拆下来的 可惜没有设备

sorrypqa

zro22 发表于 2023-7-1 23:06
所以我基本都用ESP32，不用8266，没差几块钱

对的！ESP32比8266好用太多，而且也不贵，10元就能买到

zro22

kjjuhfv 发表于 2023-7-1 23:11
api:
  services:
    - service: rf_433_send

知道 protocol:  这个参数怎么传吗？
他的定义是rcbase 变量怎么传过去呢？

kjjuhfv

zro22 发表于 2023-7-2 11:46
知道 protocol:  这个参数怎么传吗？
他的定义是rcbase 变量怎么传过去呢？

都说我抄大佬作业的啦
以前我看到过这个参数的代码
然而我没有保存下来

bluebaby

楼主您好，请问可以用这个接收并存储433信号，然后在ha建一个播放按钮吗？比如学习开门的信号，然后在ha添加一个开门的按钮，可以直接在ha里开关门。