4 Relays version
umbex opened this issue · 11 comments
umbex commented
Hello,
thanks for the great work!
I'm tinkering with the 120-4 Relays EU version, and I figured out to enable the 4th channel touch on the yaml.
FYI, touch positions are mapped as follows:
Touch 1: pos 1,2
Touch 2: pos 3,4,5
Touch 3: pos 6,7,8
Touch 4: pos 9,10
LEDS are 32.
Top side: from 31 to 8
Right side: from 9 to 14
Bottom side: from 15 to 24
Left side: from 25 to 30
Having four buttons, the mapping of scripts with button_left, middle, right will need a renaming maybe.
It will be great if you will like to support this device version.
All the best
Jetro97 commented
Same here,
I'm available to help supporting this version
iUnstable0 commented
same. also @umbex thanks for providing the positions n the led ill try maybe editing and if it works might create a PR
iUnstable0 commented
@umbex for the leds the orientation u mean when mounting it portrait? or landscape? if you get what i mean 😅
iUnstable0 commented
@umbex this is useful
#15 (comment)
I edited it and added support for 4 relays also changed a couple of things to match my needs
this is the yaml
variant.c4.yaml
script:
- id: do_nighttime_mode_active
then:
- lambda: |-
ESP_LOGD("script.do_nighttime_mode_active", "Nighttime mode activated...");
float red = ${nt_exp_red};
float green = ${nt_exp_green};
float blue = ${nt_exp_blue};
float bright = ${nt_exp_bright};
float s_red = ${nt_exp_s_red};
float s_green = ${nt_exp_s_green};
float s_blue = ${nt_exp_s_blue};
float s_bright = ${nt_exp_s_bright};
ESP_LOGD("script.do_nighttime_mode_active", "Setting TEMPLATE(s) => R: %f G: %f B: %f BR: %f", red, green, blue, bright);
id(leds_sw_left).turn_on().set_rgb( s_red, s_green, s_blue ).set_brightness(s_bright).set_transition_length(0).perform();
id(leds_sw_right).turn_on().set_rgb( s_red, s_green, s_blue ).set_brightness(s_bright).set_transition_length(0).perform();
id(figure_out_which_partition_to_light).execute(1);
id(figure_out_which_partition_to_light).execute(2);
id(figure_out_which_partition_to_light).execute(3);
id(figure_out_which_partition_to_light).execute(4);
- id: do_daytime_mode_active
then:
- lambda: |-
ESP_LOGD("script.do_daytime_mode_active", "Daytime mode activated...");
float red = ${dt_exp_red};
float green = ${dt_exp_green};
float blue = ${dt_exp_blue};
float bright = ${dt_exp_bright};
float s_red = ${nt_exp_s_red};
float s_green = ${nt_exp_s_green};
float s_blue = ${nt_exp_s_blue};
float s_bright = ${nt_exp_s_bright};
ESP_LOGD("script.do_daytime_mode_active", "Setting TEMPLATE(s) => R: %f G: %f B: %f BR: %f", red, green, blue, bright);
id(leds_sw_left).turn_off().set_rgb( s_red, s_green, s_blue ).set_brightness(s_bright).set_transition_length(0).perform();
id(leds_sw_right).turn_off().set_rgb( s_red, s_green, s_blue ).set_brightness(s_bright).set_transition_length(0).perform();
id(figure_out_which_partition_to_light).execute(1);
id(figure_out_which_partition_to_light).execute(2);
id(figure_out_which_partition_to_light).execute(3);
id(figure_out_which_partition_to_light).execute(4);
- id: figure_out_which_partition_to_light
mode: single
parameters:
output_num: int
then:
- lambda: |-
auto TAG = "script.figure_out_which_partition_to_light";
// We don't know WHICH partition light to pull RGB/BR from, but regardless we do need place to store....
float red, green, blue, br;
float s_red = ${nt_exp_s_red};
float s_green = ${nt_exp_s_green};
float s_blue = ${nt_exp_s_blue};
float s_br = ${nt_exp_s_bright};
ESP_LOGD(TAG, "Trigger was output %d", output_num);
switch (output_num) {
case 1:
// Output 1 is left button, so we want to light the top partition
id(template_light_1).current_values_as_rgb(&red, &green, &blue);
id(template_light_1).current_values_as_brightness(&br);
ESP_LOGD(TAG, "Light State => R: %f, G: %f, B: %f BR: %f", red, green, blue, br);
// Will be either just .state for entities that have bool on/off properties or something like
// .current_values.is_on() for entities that don't.
if(id(out_1).${out_1_state_exp}) {
ESP_LOGD(TAG, "out_1: ON, setting left side ON");
ESP_LOGD(TAG, "glbl_normal_regime_mode_is_nighttime: %d", id(glbl_normal_regime_mode_is_nighttime));
// If night mode is active, we dont turn off but instead change the color to match the exp_s values (left and right side of the switches for night light)
if ( id(glbl_normal_regime_mode_is_nighttime) ) {
id(leds_button_1_bottom).turn_on().set_rgb( s_red, s_green, s_blue ).set_brightness(s_br).set_transition_length(0).perform();
} else {
id(leds_button_1_bottom).turn_off().set_rgb( red, green, blue ).set_brightness(br).set_transition_length(0).perform();
}
id(leds_button_1_top).turn_on().set_rgb( red, green, blue ).set_brightness(br).set_transition_length(0).perform();
} else {
ESP_LOGD(TAG, "out_1: OFF, setting right side ON");
id(leds_button_1_bottom).turn_on().set_rgb( red, green, blue ).set_brightness(br).set_transition_length(0).perform();
ESP_LOGD(TAG, "glbl_normal_regime_mode_is_nighttime: %d", id(glbl_normal_regime_mode_is_nighttime));
if ( id(glbl_normal_regime_mode_is_nighttime) ) {
id(leds_button_1_top).turn_on().set_rgb( s_red, s_green, s_blue ).set_brightness(s_br).set_transition_length(0).perform();
} else {
id(leds_button_1_top).turn_off().set_rgb( red, green, blue ).set_brightness(br).set_transition_length(0).perform();
}
}
break;
case 2:
id(template_light_2).current_values_as_rgb(&red, &green, &blue);
id(template_light_2).current_values_as_brightness(&br);
ESP_LOGD(TAG, "Light State => R: %f, G: %f, B: %f BR: %f", red, green, blue, br);
// The C++ code we call changes based on which type of output out_2 is
if(id(out_2).${out_2_state_exp}) {
ESP_LOGD(TAG, "out_2: ON, setting left side ON");
if ( id(glbl_normal_regime_mode_is_nighttime) ) {
id(leds_button_2_bottom).turn_on().set_rgb( s_red, s_green, s_blue ).set_brightness(s_br).set_transition_length(0).perform();
} else {
id(leds_button_2_bottom).turn_off().set_rgb( red, green, blue ).set_brightness(br).set_transition_length(0).perform();
}
id(leds_button_2_top).turn_on().set_rgb( red, green, blue ).set_brightness(br).set_transition_length(0).perform();
} else {
ESP_LOGD(TAG, "out_2: OFF, setting right side ON");
id(leds_button_2_bottom).turn_on().set_rgb( red, green, blue ).set_brightness(br).set_transition_length(0).perform();
if ( id(glbl_normal_regime_mode_is_nighttime) ) {
id(leds_button_2_top).turn_on().set_rgb( s_red, s_green, s_blue ).set_brightness(s_br).set_transition_length(0).perform();
} else {
id(leds_button_2_top).turn_off().set_rgb( red, green, blue ).set_brightness(br).set_transition_length(0).perform();
}
}
break;
case 3:
id(template_light_3).current_values_as_rgb(&red, &green, &blue);
id(template_light_3).current_values_as_brightness(&br);
ESP_LOGD(TAG, "Light State => R: %f, G: %f, B: %f BR: %f", red, green, blue, br);
if(id(out_3).${out_3_state_exp}) {
ESP_LOGD(TAG, "out_3: ON, setting left side ON");
if ( id(glbl_normal_regime_mode_is_nighttime) ) {
id(leds_button_3_bottom).turn_on().set_rgb( s_red, s_green, s_blue ).set_brightness(s_br).set_transition_length(0).perform();
} else {
id(leds_button_3_bottom).turn_off().set_rgb( red, green, blue ).set_brightness(br).set_transition_length(0).perform();
}
id(leds_button_3_top).turn_on().set_rgb( red, green, blue ).set_brightness(br).set_transition_length(0).perform();
} else {
ESP_LOGD(TAG, "out_3: OFF, setting right side ON");
id(leds_button_3_bottom).turn_on().set_rgb( red, green, blue ).set_brightness(br).set_transition_length(0).perform();
if ( id(glbl_normal_regime_mode_is_nighttime) ) {
id(leds_button_3_top).turn_on().set_rgb( s_red, s_green, s_blue ).set_brightness(s_br).set_transition_length(0).perform();
} else {
id(leds_button_3_top).turn_off().set_rgb( red, green, blue ).set_brightness(br).set_transition_length(0).perform();
}
}
break;
case 4:
id(template_light_4).current_values_as_rgb(&red, &green, &blue);
id(template_light_4).current_values_as_brightness(&br);
ESP_LOGD(TAG, "Light State => R: %f, G: %f, B: %f BR: %f", red, green, blue, br);
if(id(out_4).${out_4_state_exp}) {
ESP_LOGD(TAG, "out_4: ON, setting left side ON");
if ( id(glbl_normal_regime_mode_is_nighttime) ) {
id(leds_button_4_bottom).turn_on().set_rgb( s_red, s_green, s_blue ).set_brightness(s_br).set_transition_length(0).perform();
} else {
id(leds_button_4_bottom).turn_off().set_rgb( red, green, blue ).set_brightness(br).set_transition_length(0).perform();
}
id(leds_button_4_top).turn_on().set_rgb( red, green, blue ).set_brightness(br).set_transition_length(0).perform();
} else {
ESP_LOGD(TAG, "out_4: OFF, setting right side ON");
id(leds_button_4_bottom).turn_on().set_rgb( red, green, blue ).set_brightness(br).set_transition_length(0).perform();
if ( id(glbl_normal_regime_mode_is_nighttime) ) {
id(leds_button_4_top).turn_on().set_rgb( s_red, s_green, s_blue ).set_brightness(s_br).set_transition_length(0).perform();
} else {
id(leds_button_4_top).turn_off().set_rgb( red, green, blue ).set_brightness(br).set_transition_length(0).perform();
}
}
break;
default:
ESP_LOGE(TAG, "Unknown output number: %d", output_num);
return;
}
# Called on boot or any time we're transitioning from mood-light to a "normal" mode
- id: resume_normal_regime_for_leds
mode: single
# When resuming normal regime, figure out which color scheme we should be using and then run the "figure out which partition to light" script for each output
then:
# TODO: SUN HORIZON
# - script.execute:
# id: figure_out_normal_regime_mode
- script.execute:
id: figure_out_which_partition_to_light
output_num: 1
- script.execute:
id: figure_out_which_partition_to_light
output_num: 2
- script.execute:
id: figure_out_which_partition_to_light
output_num: 3
- script.execute:
id: figure_out_which_partition_to_light
output_num: 4
##
# See the LEDs section of readme.md
# There are 10 LEDs on each side, we have 3 groups which means we'll need 4 "buffers"
# 10 - 4 = 6 and 6/3 is 2 so we'll use 2 leds per partition
##
light:
- name: "Left"
platform: partition
id: leds_sw_left
segments:
- id: leds_all
from: 25
to: 30
- id: leds_all
from: 0
to: 1
- id: leds_all
from: 3
to: 4
- id: leds_all
from: 6
to: 7
effects:
- addressable_scan:
name: "Scan"
- addressable_rainbow:
name: "Rainbow"
speed: 10
width: 20
- name: "Right"
platform: partition
id: leds_sw_right
segments:
- id: leds_all
from: 9
to: 14
- id: leds_all
from: 16
to: 17
- id: leds_all
from: 19
to: 20
- id: leds_all
from: 22
to: 23
effects:
- addressable_scan:
name: "Scan"
- addressable_rainbow:
name: "Rainbow"
speed: 10
width: 20
- name: "Button Left Top (internal)"
platform: partition
id: leds_button_1_top
internal: true
segments:
- id: leds_all
from: 31
to: 31
- name: "Button Left Bottom (internal)"
platform: partition
id: leds_button_1_bottom
internal: true
segments:
- id: leds_all
from: 24
to: 24
- name: "Button Middle Left Top (internal)"
platform: partition
id: leds_button_2_top
internal: true
# segments: [3]
segments:
- id: leds_all
from: 2
to: 2
- name: "Button Middle Left Bottom (internal)"
platform: partition
id: leds_button_2_bottom
internal: true
# segments: [22]
segments:
- id: leds_all
from: 21
to: 21
- name: "Button Middle Right Top (internal)"
platform: partition
id: leds_button_3_top
internal: true
# segments: [6]
segments:
- id: leds_all
from: 5
to: 5
- name: "Button Middle Right Bottom (internal)"
platform: partition
id: leds_button_3_bottom
internal: true
# segments: [19]
segments:
- id: leds_all
from: 18
to: 18
- name: "Button Right Top (internal)"
platform: partition
id: leds_button_4_top
internal: true
# segments: [9]
segments:
- id: leds_all
from: 8
to: 8
- name: "Button Right Bottom (internal)"
platform: partition
id: leds_button_4_bottom
internal: true
# segments: [16]
segments:
- id: leds_all
from: 15
to: 15
# Expose a "template" light entity to HA.
# Use this to "wrap" the partition lights and pass through values to them.
# See readme.md for more info
- platform: custom
lambda: |-
// Sign of life
ESP_LOGD("light.template_light", "Alive!");
auto template_light_1 = new TemplateLight();
App.register_component(template_light_1);
auto template_light_2 = new TemplateLight();
App.register_component(template_light_2);
auto template_light_3 = new TemplateLight();
App.register_component(template_light_3);
auto template_light_4 = new TemplateLight();
App.register_component(template_light_4);
return {template_light_1, template_light_2, template_light_3, template_light_4};
lights:
- name: "Indicator 1"
id: template_light_1
# Expose to HA, under config section
internal: false
entity_category: config
# Template light should restore to last state / ON at boot
restore_mode: RESTORE_AND_ON
# We do not bother with gamma correction here, we want to keep the values as unadulterated as possible as this is JUST a pass through
# The actual light(s) that we pass values to will handle gamma correction (if configured)
gamma_correct: 0.0
# Likewise, we do not want to do any smoothing here, we want to pass the values through as quickly as possible
default_transition_length: 0s
# In testing, I can't get the (gamma corrected...) partition light(s) to turn on at all below ~20%.
# Not clear _why_ this is (too dim to see?) but it's a problem because there's nothing preventing you from setting a brightness of < 20% in HA.
# HA thinks that the light is on, but it's not actually on.
# Ideally i'd be able to set min_brightness here like I can with other types of light in ESPHome, but I can't.
# More than likely i'll need to implement this myself in the template_light.h file.
##
# We need to link our state to the actual partition lights... which is not as straightforward as expected.
# After a lot of trial/error, this is the least janky method I could come up with.
##
# Because we have a transition length of 0, the on_state hook really shouldn't be called more than 2x
# Once as soon as any command is received; it'll print the state we're about to move away from
# Once as soon as we've reached the commanded state that was just received; it'll print the state we're at / should match what HA commanded.
# However, the on_state call is STILL needed because a light that is on full red and then given a command to go to full purple will not pass through
# on/off state.
##
on_turn_on:
- lambda: |-
// Get user requested RGB values and pass them through to the partition lights
float red, green, blue, br;
id(template_light_1).current_values_as_rgb(&red, &green, &blue);
id(template_light_1).current_values_as_brightness(&br);
// Pass through should happen ONLY in the on_state and on_turn_off hooks so just log here
// Since we have ZERO gamma correction, the values here should _match_ the ones set in HA
// They'll just be normalized though. So HA sends red: 255, here, we get 1.0
ESP_LOGD("template_light_1.on_turn_on", "ON_TURN_ON => R: %f, G: %f, B: %f BR: %f", red, green, blue, br);
on_turn_off:
- lambda: |-
// Get template RGB values
float red, green, blue, br;
id(template_light_1).current_values_as_rgb(&red, &green, &blue);
id(template_light_1).current_values_as_brightness(&br);
// OFF means OFF so both partitions should be off
ESP_LOGD("template_light_1.on_turn_off", "TURN OFF");
id(leds_button_1_top).turn_off().set_rgb( red, green, blue ).set_brightness(br).set_transition_length(0).perform();
id(leds_button_1_bottom).turn_off().set_rgb( red, green, blue ).set_brightness(br).set_transition_length(0).perform();
on_state:
- lambda: |-
// Get template RGB values
float red, green, blue, br;
id(template_light_1).current_values_as_rgb(&red, &green, &blue);
id(template_light_1).current_values_as_brightness(&br);
ESP_LOGD("template_light_1.on_state", "State => R: %f, G: %f, B: %f BR: %f", red, green, blue, br);
# Figure out which partition light to light up now that we have an updated state
- script.execute:
id: figure_out_which_partition_to_light
# Output 1 = top
output_num: 1
- name: "Indicator 2"
id: template_light_2
internal: false
entity_category: config
restore_mode: RESTORE_AND_ON
gamma_correct: 0.0
default_transition_length: 0s
on_turn_on:
- lambda: |-
// Get user requested RGB values and pass them through to the partition lights
float red, green, blue, br;
id(template_light_2).current_values_as_rgb(&red, &green, &blue);
id(template_light_2).current_values_as_brightness(&br);
// Pass through should happen ONLY in the on_state and on_turn_off hooks so just log here
// Since we have ZERO gamma correction, the values here should _match_ the ones set in HA
// They'll just be normalized though. So HA sends red: 255, here, we get 1.0
ESP_LOGD("template_light_2.on_turn_on", "ON_TURN_ON => R: %f, G: %f, B: %f BR: %f", red, green, blue, br);
on_turn_off:
- lambda: |-
// Get template RGB values
float red, green, blue, br;
id(template_light_2).current_values_as_rgb(&red, &green, &blue);
id(template_light_2).current_values_as_brightness(&br);
// OFF means OFF so both partitions should be off
ESP_LOGD("template_light_2.on_turn_off", "TURN OFF");
id(leds_button_2_top).turn_off().set_rgb( red, green, blue ).set_brightness(br).set_transition_length(0).perform();
id(leds_button_2_bottom).turn_off().set_rgb( red, green, blue ).set_brightness(br).set_transition_length(0).perform();
on_state:
- lambda: |-
// Get template RGB values
float red, green, blue, br;
id(template_light_2).current_values_as_rgb(&red, &green, &blue);
id(template_light_2).current_values_as_brightness(&br);
ESP_LOGD("template_light_2.on_state", "State => R: %f, G: %f, B: %f BR: %f", red, green, blue, br);
- script.execute:
id: figure_out_which_partition_to_light
# Output 2 = middle on 3c version
output_num: 2
- name: "Indicator 3"
id: template_light_3
internal: false
entity_category: config
restore_mode: RESTORE_AND_ON
gamma_correct: 0.0
default_transition_length: 0s
on_turn_on:
- lambda: |-
// Get user requested RGB values and pass them through to the partition lights
float red, green, blue, br;
id(template_light_3).current_values_as_rgb(&red, &green, &blue);
id(template_light_3).current_values_as_brightness(&br);
// Pass through should happen ONLY in the on_state and on_turn_off hooks so just log here
// Since we have ZERO gamma correction, the values here should _match_ the ones set in HA
// They'll just be normalized though. So HA sends red: 255, here, we get 1.0
ESP_LOGD("template_light_3.on_turn_on", "ON_TURN_ON => R: %f, G: %f, B: %f BR: %f", red, green, blue, br);
on_turn_off:
- lambda: |-
// Get template RGB values
float red, green, blue, br;
id(template_light_3).current_values_as_rgb(&red, &green, &blue);
id(template_light_3).current_values_as_brightness(&br);
// OFF means OFF so both partitions should be off
ESP_LOGD("template_light_3.on_turn_off", "TURN OFF");
id(leds_button_3_top).turn_off().set_rgb( red, green, blue ).set_brightness(br).set_transition_length(0).perform();
id(leds_button_3_bottom).turn_off().set_rgb( red, green, blue ).set_brightness(br).set_transition_length(0).perform();
on_state:
- lambda: |-
// Get template RGB values
float red, green, blue, br;
id(template_light_3).current_values_as_rgb(&red, &green, &blue);
id(template_light_3).current_values_as_brightness(&br);
ESP_LOGD("template_light_3.on_state", "State => R: %f, G: %f, B: %f BR: %f", red, green, blue, br);
- script.execute:
id: figure_out_which_partition_to_light
output_num: 3
- name: "Indicator 4"
id: template_light_4
internal: false
entity_category: config
restore_mode: RESTORE_AND_ON
gamma_correct: 0.0
default_transition_length: 0s
on_turn_on:
- lambda: |-
// Get user requested RGB values and pass them through to the partition lights
float red, green, blue, br;
id(template_light_4).current_values_as_rgb(&red, &green, &blue);
id(template_light_4).current_values_as_brightness(&br);
// Pass through should happen ONLY in the on_state and on_turn_off hooks so just log here
// Since we have ZERO gamma correction, the values here should _match_ the ones set in HA
// They'll just be normalized though. So HA sends red: 255, here, we get 1.0
ESP_LOGD("template_light_4.on_turn_on", "ON_TURN_ON => R: %f, G: %f, B: %f BR: %f", red, green, blue, br);
on_turn_off:
- lambda: |-
// Get template RGB values
float red, green, blue, br;
id(template_light_4).current_values_as_rgb(&red, &green, &blue);
id(template_light_4).current_values_as_brightness(&br);
// OFF means OFF so both partitions should be off
ESP_LOGD("template_light_4.on_turn_off", "TURN OFF");
id(leds_button_4_top).turn_off().set_rgb( red, green, blue ).set_brightness(br).set_transition_length(0).perform();
id(leds_button_4_bottom).turn_off().set_rgb( red, green, blue ).set_brightness(br).set_transition_length(0).perform();
on_state:
- lambda: |-
// Get template RGB values
float red, green, blue, br;
id(template_light_4).current_values_as_rgb(&red, &green, &blue);
id(template_light_4).current_values_as_brightness(&br);
ESP_LOGD("template_light_4.on_state", "State => R: %f, G: %f, B: %f BR: %f", red, green, blue, br);
# Set up the gpio outputs for the relays
output:
- id: relay_1
platform: gpio
pin: GPIO18
- id: relay_2
platform: gpio
pin: GPIO17
- id: relay_3
platform: gpio
pin: GPIO27
- id: relay_4
platform: gpio
pin: GPIO23testswitch.yaml (snippet)
packages:
common: !include packages/base.yaml
# 3 relay version
output: !include
file: packages/variant.c4.yaml
vars:
# Relay 1,3 are wired up to lights
# out_1_state_exp: "state"
out_1_state_exp: "current_values.is_on()"
# out_2_state_exp: "state"
out_2_state_exp: "current_values.is_on()"
# out_3_state_exp: "state"
out_3_state_exp: "current_values.is_on()"
# out_4_state_exp: "state"
out_4_state_exp: "current_values.is_on()"
# Customize what each of the three relays do
light:
# Relay 1 and 2 are the fan/light combo
- name: Left Light
id: out_1
platform: binary
output: relay_1
restore_mode: RESTORE_DEFAULT_OFF
# When changing between states, we need to update the partition light(s)
on_turn_on:
- script.execute:
id: figure_out_which_partition_to_light
output_num: 1
on_turn_off:
- script.execute:
id: figure_out_which_partition_to_light
output_num: 1
# Main overhead light
- name: Middle Left Light
id: out_2
platform: binary
output: relay_2
restore_mode: RESTORE_DEFAULT_OFF
on_turn_on:
- script.execute:
id: figure_out_which_partition_to_light
output_num: 2
on_turn_off:
- script.execute:
id: figure_out_which_partition_to_light
output_num: 2
# Main overhead light
- name: Middle Right Light
id: out_3
platform: binary
output: relay_3
restore_mode: RESTORE_DEFAULT_OFF
on_turn_on:
- script.execute:
id: figure_out_which_partition_to_light
output_num: 3
on_turn_off:
- script.execute:
id: figure_out_which_partition_to_light
output_num: 3
- name: Right Light
id: out_4
platform: binary
output: relay_4
restore_mode: RESTORE_DEFAULT_OFF
on_turn_on:
- script.execute:
id: figure_out_which_partition_to_light
output_num: 4
on_turn_off:
- script.execute:
id: figure_out_which_partition_to_light
output_num: 4
tx_ultimate_touch:
id: tx_touch
uart: uart_touch
on_press:
# Let the user know we've registered the touch
- script.execute: buzz_default
# Like "traditional" switches, we act as soon as pressed and do not wait for "release"
# Unless user has disabled touch input processing
- lambda: >
ESP_LOGD("tx_ultimate_touch.on_press", "Touch Position: %d / State: %d", touch.x, touch.state);
if (!id(glbl_sw_touch_enable)) {
ESP_LOGD("tx_ultimate_touch.on_press", "Touch is disabled, ignoring");
return;
}
// 4 ch version means we split the touch surface into 4 equal size zones
// 0-2, 3-5, 6-8, 9-11
// There's nothing stopping you from creating unequal sized zones if desired!
/////////////////////////////////
// The if/else pattern is extended or shortened depending on the number of relays
// In addition to modifying the if/else pattern, you'll need to update the code that
// checks the state of each output.
// I wish ESPHome would have a more homogenous API for this since there IS a homogenous
// API for calling the turn_on/turn_off methods!
/////////////////////////////////
if (touch.x <= 2) {
ESP_LOGD("tx_ultimate_touch.on_press", "Toggle 1");
if(id(out_1).current_values.is_on() ) {
id(out_1).turn_off().perform();
} else {
id(out_1).turn_on().perform();
}
} else if (touch.x <= 5) {
ESP_LOGD("tx_ultimate_touch.on_press", "Toggle 2");
if(id(out_2).current_values.is_on() ) {
id(out_2).turn_off().perform();
} else {
id(out_2).turn_on().perform();
}
} else if (touch.x <= 8) {
ESP_LOGD("tx_ultimate_touch.on_press", "Toggle 3");
if(id(out_3).current_values.is_on() ) {
id(out_3).turn_off().perform();
} else {
id(out_3).turn_on().perform();
}
} else {
ESP_LOGD("tx_ultimate_touch.on_press", "Toggle 4");
if(id(out_4).current_values.is_on() ) {
id(out_4).turn_off().perform();
} else {
id(out_4).turn_on().perform();
}
} (thanks to @kquinsland)
m4dm4xi commented
Hello, thanks for the great work!
I'm tinkering with the 120-4 Relays EU version, and I figured out to enable the 4th channel touch on the yaml.
FYI, touch positions are mapped as follows: Touch 1: pos 1,2 Touch 2: pos 3,4,5 Touch 3: pos 6,7,8 Touch 4: pos 9,10
LEDS are 32. Top side: from 31 to 8 Right side: from 9 to 14 Bottom side: from 15 to 24 Left side: from 25 to 30
Having four buttons, the mapping of scripts with button_left, middle, right will need a renaming maybe. It will be great if you will like to support this device version. All the best
Have you found a properly working solution?
SebTM commented
Hey, I'm looking forward to get one of the 4-gang version, is there any chance this component will add support for the 4-gang version as well? ✌🏻