Ensure brightness is limited to 100

As suggested by coderabbitai.

.github/workflows/versioning.yml

@@ -41,11 +41,84 @@ jobs:
           git config user.name "GitHub Actions"
           git config user.email "actions@github.com"
 
+      - name: Get PR information
+        id: pr_info
+        if: github.event_name == 'push'
+        uses: actions/github-script@v7
+        with:
+          script: |
+            try {
+              // Use GitHub's reliable API to find PRs associated with this commit
+              const { data: associatedPRs } = await github.rest.repos.listPullRequestsAssociatedWithCommit({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                commit_sha: context.sha
+              });
+
+              if (associatedPRs.length > 0) {
+                // Get the most recent merged PR
+                const pr = associatedPRs.find(pr => pr.state === 'closed' && pr.merged_at) || associatedPRs[0];
+
+                return {
+                  title: pr.title,
+                  body: pr.body || 'No description provided',
+                  number: pr.number,
+                  found: true
+                };
+              } else {
+                // Fallback for direct pushes or when no PR is found
+                const commit = await github.rest.repos.getCommit({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  ref: context.sha
+                });
+
+                return {
+                  title: 'Direct push to main',
+                  body: commit.data.commit.message,
+                  number: null,
+                  found: false
+                };
+              }
+            } catch (error) {
+              console.log('Could not get PR info:', error.message);
+              return {
+                title: 'Version update',
+                body: 'Automated version bump',
+                number: null,
+                found: false
+              };
+            }
+
       - name: Bump version
         run: |
           chmod +x ./versioning/bump_version.sh
           ./versioning/bump_version.sh
 
+      - name: Create tag message
+        id: tag_message
+        run: |
+          NEW_VERSION=$(cat ./versioning/VERSION)
+
+          if [ "${{ github.event_name }}" == "push" ] && [ "${{ steps.pr_info.outcome }}" == "success" ]; then
+            # Use PR information directly in heredoc to avoid quoting issues
+            cat > tag_message.txt << EOF
+          # v${NEW_VERSION} - ${{ fromJson(steps.pr_info.outputs.result).title }}
+
+          ${{ fromJson(steps.pr_info.outputs.result).body }}
+          EOF
+          else
+            # Manual dispatch or PR info unavailable - simpler message
+            cat > tag_message.txt << EOF
+          # v${NEW_VERSION} - Manual tag update
+
+          Tag updated via manual workflow dispatch.
+          EOF
+          fi
+
+          # Store the message for use in subsequent steps
+          echo "TAG_MESSAGE_FILE=tag_message.txt" >> $GITHUB_ENV
+
       - name: Push Changes and Tags
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -55,9 +128,10 @@ jobs:
 
       - name: Update stable tag
         if: |
-          success() &&
+          success() && (
-          github.event_name == 'workflow_dispatch' &&
+            github.event_name == 'workflow_dispatch' && inputs.update_stable ||
-          inputs.update_stable
+            github.event_name == 'push'
+          )
         run: |
           # Verify version bump was successful
           if [ ! -f "./versioning/VERSION" ]; then
@@ -71,10 +145,10 @@ jobs:
             echo "Backing up current stable tag ($OLD_STABLE)"
           fi
 
-          # Update tag
+          # Update tag with detailed message
           NEW_VERSION=$(cat ./versioning/VERSION)
           echo "Updating stable tag to $NEW_VERSION"
-          git tag -fa stable -m "Update stable tag"
+          git tag -fa stable -F "$TAG_MESSAGE_FILE"
           git push origin stable --force
 
       - name: Update latest tag
@@ -96,9 +170,15 @@ jobs:
             echo "Backing up current latest tag ($OLD_LATEST)"
           fi
 
-          # Update tag
+          # Update tag with detailed message
           NEW_VERSION=$(cat ./versioning/VERSION)
           echo "Updating latest tag to $NEW_VERSION"
-          git tag -fa latest -m "Update latest tag"
+          git tag -fa latest -F "$TAG_MESSAGE_FILE"
           git push origin latest --force
+
+      - name: Cleanup
+        if: always()
+        run: |
+          # Clean up temporary files
+          [ -f tag_message.txt ] && rm tag_message.txt || true
 ...

ESPHome/TX-Ultimate-Easy-ESPHome_core_common.yaml

@@ -29,6 +29,8 @@ substitutions:
 
   DUMP_CONFIG_CALLER_DELAY: 10s  # Delay to dump config after requested
 
+  TAG_CORE_COMMON: core.common
+
 api:
   id: api_server
   on_client_connected:
@@ -48,9 +50,9 @@ binary_sensor:
       then:
         - lambda: |-
             if (x)
-              ESP_LOGW("core", "Pending restart: YES");
+              ESP_LOGW("${TAG_CORE_COMMON}", "Pending restart: YES");
             else
-              ESP_LOGCONFIG("core", "Pending restart: No");
+              ESP_LOGD("${TAG_CORE_COMMON}", "Pending restart: No");
         - script.execute: dump_config_caller
 
 button:
@@ -74,9 +76,13 @@ esphome:
     version: ${version}
   platformio_options:
     build_flags:
-      - -D TX_ULTIMATE_EASY_CORE
+      - -D TX_ULTIMATE_EASY_CORE_COMMON
 
   on_boot:
+    - priority: 750
+      then:
+        - script.execute: restore_from_nvs
+
     - priority: 700
       then:
         - script.execute: boot_initialize
@@ -89,6 +95,15 @@ esphome:
       then:
         - script.execute: boot_done
 
+external_components:
+  - source:
+      type: git
+      url: https://github.com/edwardtfn/TX-Ultimate-Easy
+      ref: v${version}
+    refresh: 1h
+    components:
+      - tx_ultimate_easy
+
 globals:
   - id: is_us_model
     type: bool
@@ -149,7 +164,7 @@ script:
           id(is_us_model) = (sl_tx_model_format->state == "${TX_MODEL_FORMAT_US_TEXT}");
           id(gang_count) = sl_tx_model_gang->active_index().value() + 1;
           if (id(gang_count) < 1 || id(gang_count) > 4) {
-            ESP_LOGE("core_hw_leds", "Invalid number of gangs: %" PRIu8, id(gang_count));
+            ESP_LOGE("${TAG_CORE_COMMON}", "Invalid number of gangs: %" PRIu8, id(gang_count));
           }
 
   - id: boot_sequence
@@ -166,33 +181,37 @@ script:
       # Extended by all modules
       - lambda: |-
           // Device identification
-          ESP_LOGCONFIG("core", "Device friendly name: ${friendly_name}");
+          ESP_LOGCONFIG("${TAG_CORE_COMMON}", "Device friendly name: ${friendly_name}");
-          ESP_LOGCONFIG("core", "Device name: ${name}");
+          ESP_LOGCONFIG("${TAG_CORE_COMMON}", "Device name: ${name}");
-          ESP_LOGCONFIG("core", "Device name (HA): %s", tx_device_name->state.c_str());
+          ESP_LOGCONFIG("${TAG_CORE_COMMON}", "Device name (HA): %s", tx_device_name->state.c_str());
-          ESP_LOGCONFIG("core", "Device hostname: %s", App.get_name().c_str());
+          ESP_LOGCONFIG("${TAG_CORE_COMMON}", "Device hostname: %s", App.get_name().c_str());
 
           dump_config_versions->execute();
 
           // Framework detection
           #ifdef USE_ARDUINO
-          ESP_LOGCONFIG("core", "Framework: Arduino");
+          ESP_LOGCONFIG("${TAG_CORE_COMMON}", "Framework: Arduino");
           #elif defined(USE_ESP_IDF)
-          ESP_LOGCONFIG("core", "Framework: ESP-IDF");
+          ESP_LOGCONFIG("${TAG_CORE_COMMON}", "Framework: ESP-IDF");
           #else
-          ESP_LOGW("core", "Framework: UNKNOWN");
+          ESP_LOGW("${TAG_CORE_COMMON}", "Framework: UNKNOWN");
           #endif
 
           // Model configuration
-          ESP_LOGCONFIG("core", "Model format (selected): %s", sl_tx_model_format->state.c_str());
+          ESP_LOGCONFIG("${TAG_CORE_COMMON}", "Model format (selected): %s",
-          ESP_LOGCONFIG("core", "Model format (detected): %s", id(is_us_model) ? "US" : "EU");
+                          sl_tx_model_format->state.c_str());
-          ESP_LOGCONFIG("core", "Gangs (selected): %s", sl_tx_model_gang->state.c_str());
+          ESP_LOGCONFIG("${TAG_CORE_COMMON}", "Model format (detected): %s",
-          ESP_LOGCONFIG("core", "Gangs (detected): %" PRIu8 "-Gang%s", id(gang_count), id(gang_count) > 1 ? "s" : "");
+                          id(is_us_model) ? "US" : "EU");
+          ESP_LOGCONFIG("${TAG_CORE_COMMON}", "Gangs (selected): %s",
+                          sl_tx_model_gang->state.c_str());
+          ESP_LOGCONFIG("${TAG_CORE_COMMON}", "Gangs (detected): %" PRIu8 "-Gang%s",
+                          id(gang_count), id(gang_count) > 1 ? "s" : "");
 
           // System state
           if (bs_pending_restart->state)
-            ESP_LOGW("core", "Pending restart: YES");
+            ESP_LOGW("${TAG_CORE_COMMON}", "Pending restart: YES");
           else
-            ESP_LOGCONFIG("core", "Pending restart: No");
+            ESP_LOGCONFIG("${TAG_CORE_COMMON}", "Pending restart: No");
 
   - id: dump_config_caller
     mode: restart
@@ -217,10 +236,10 @@ script:
     then:
       - lambda: |-
           // Version information
-          ESP_LOGCONFIG("core", "TX Ultimate firmware version: ${version}");
+          ESP_LOGCONFIG("${TAG_CORE_COMMON}", "TX Ultimate firmware version: ${version}");
           // ESPHome builder information
-          ESP_LOGCONFIG("core", "ESPHome builder: " ESPHOME_VERSION);
+          ESP_LOGCONFIG("${TAG_CORE_COMMON}", "ESPHome builder: " ESPHOME_VERSION);
-          ESP_LOGCONFIG("core", "ESPHome build timestamp: %s", App.get_compilation_time().c_str());
+          ESP_LOGCONFIG("${TAG_CORE_COMMON}", "ESPHome build timestamp: %s", App.get_compilation_time().c_str());
 
   - id: publish_device_info
     mode: restart
@@ -229,6 +248,16 @@ script:
           tx_fw_version->publish_state("${version}");
           tx_device_name->publish_state(App.get_name().c_str());
 
+  - id: restore_from_nvs
+    mode: single
+    then:
+      - select.set_index:
+          id: sl_tx_model_format
+          index: !lambda if (id(is_us_model)) return 1; else return 0;
+      - select.set_index:
+          id: sl_tx_model_gang
+          index: !lambda return (id(gang_count)-1);
+
 select:
   - id: sl_tx_model_format
     name: Model (Format)
@@ -238,7 +267,7 @@ select:
       - "${TX_MODEL_FORMAT_US_TEXT}"
     initial_option: "${TX_MODEL_FORMAT_EU_TEXT}"
     optimistic: true
-    restore_value: true
+    restore_value: false
     internal: false
     entity_category: config
     disabled_by_default: false
@@ -250,7 +279,6 @@ select:
             state: true
         - lambda: |-
             id(is_us_model) = (x == "${TX_MODEL_FORMAT_US_TEXT}");
-            ESP_LOGI("core", "New model selected: %s", id(is_us_model) ? "US" : "EU");
 
   - id: sl_tx_model_gang
     name: Model (Gang)
@@ -262,7 +290,7 @@ select:
       - "${TX_MODEL_4_GANG_TEXT}"
     initial_option: "${TX_MODEL_1_GANG_TEXT}"
     optimistic: true
-    restore_value: true
+    restore_value: false
     internal: false
     entity_category: config
     disabled_by_default: false
@@ -274,7 +302,6 @@ select:
             state: true
         - lambda: |-
             id(gang_count) = static_cast<uint8_t>(i) + 1;
-            ESP_LOGI("core", "New model selected: %" PRIu8 "-%s", id(gang_count), id(gang_count) > 1 ? "Gangs" : "Gang");
             tx_ultimate->set_gang_count(id(gang_count));
 
 text_sensor:
@@ -314,6 +341,9 @@ text_sensor:
           }
           return result;
 
+tx_ultimate_easy:
+  id: tx_ultimate
+
 wifi:
   id: wifi_component
 ...

ESPHome/TX-Ultimate-Easy-ESPHome_core_hw_buttons.yaml

@@ -36,6 +36,8 @@ substitutions:
   BUTTON_3_ID: '3'
   BUTTON_4_ID: '4'
 
+  TAG_CORE_HW_BUTTONS: core.hw.buttons
+
 binary_sensor:
   - &binary_sensor_button_base
     id: bs_button_2
@@ -63,6 +65,14 @@ esphome:
       - -D TX_ULTIMATE_EASY_CORE_HW_BUTTONS
 
 globals:
+  # Packed button actions - replaces 4 separate selects
+  - id: button_actions_packed
+    type: uint16_t
+    restore_value: true
+    initial_value: '4369'  # Binary: 0001000100010001 = all buttons set to option 1 (default action)
+    # Bit layout: [button4(4)][button3(4)][button2(4)][button1(4)]
+    # Each button uses 4 bits: 0=None, 1=Toggle, 2=Failsafe, 3-15=Reserved for future options
+
   - id: button_press_button
     type: uint8_t
     restore_value: false
@@ -125,7 +135,7 @@ script:
             {"count", std::to_string(count)},
             {"position", std::to_string(id(button_press_position))}
           });
-          ESP_LOGI("core_hw_buttons", "Button %" PRIu8 " action: '%s'", button, action.c_str());
+          ESP_LOGI("${TAG_CORE_HW_BUTTONS}", "Button %" PRIu8 " action: '%s'", button, action.c_str());
           if (action == "click") {
             switch (button) {
               case ${BUTTON_1_ID}:
@@ -211,37 +221,48 @@ script:
       - lambda: |-
           std::string gang_count_plural_suffix = id(gang_count) > 1 ? "s" : "";
           // Button's actions
-          ESP_LOGCONFIG("core_hw_buttons", "Button%s action%s:",
+          ESP_LOGCONFIG("${TAG_CORE_HW_BUTTONS}", "Button%s action%s:",
                         gang_count_plural_suffix.c_str(),
                         gang_count_plural_suffix.c_str());
-          ESP_LOGCONFIG("core_hw_buttons", "  Relay 1: %s", sl_button_1_action->has_state()
+          ESP_LOGCONFIG("${TAG_CORE_HW_BUTTONS}", "  Relay 1: %s", sl_button_1_action->has_state() ?
-                                                              ? sl_button_1_action->state.c_str()
+                                                                    sl_button_1_action->state.c_str() : "Unknown");
-                                                              : "Unknown");
           if (id(gang_count) >= 2)
-            ESP_LOGCONFIG("core_hw_buttons", "  Relay 2: %s", sl_button_2_action->has_state()
+            ESP_LOGCONFIG("${TAG_CORE_HW_BUTTONS}", "  Relay 2: %s", sl_button_2_action->has_state() ?
-                                                                ? sl_button_2_action->state.c_str()
+                                                                      sl_button_2_action->state.c_str() : "Unknown");
-                                                                : "Unknown");
           if (id(gang_count) >= 3)
-            ESP_LOGCONFIG("core_hw_buttons", "  Relay 3: %s", sl_button_3_action->has_state()
+            ESP_LOGCONFIG("${TAG_CORE_HW_BUTTONS}", "  Relay 3: %s", sl_button_3_action->has_state() ?
-                                                                ? sl_button_3_action->state.c_str()
+                                                                      sl_button_3_action->state.c_str() : "Unknown");
-                                                                : "Unknown");
           if (id(gang_count) >= 4)
-            ESP_LOGCONFIG("core_hw_buttons", "  Relay 4: %s", sl_button_4_action->has_state()
+            ESP_LOGCONFIG("${TAG_CORE_HW_BUTTONS}", "  Relay 4: %s", sl_button_4_action->has_state() ?
-                                                                ? sl_button_4_action->state.c_str()
+                                                                      sl_button_4_action->state.c_str() : "Unknown");
-                                                                : "Unknown");
 
   - id: !extend dump_config_list_packages
     then:
       - script.wait: dump_config
       - lambda: |-
           // Check for requirements
-          #if !defined(TX_ULTIMATE_EASY_CORE)
+          #if !defined(TX_ULTIMATE_EASY_CORE_COMMON)
-            #error "The package TX-Ultimate-Easy-ESPHome_core.yaml is required."
+            #error "The package TX-Ultimate-Easy-ESPHome_core_common.yaml is required."
           #endif
 
           // Identify itself
           ESP_LOGCONFIG(ESPHOME_PROJECT_NAME, "  - Core - Hardware - Buttons");
 
+  - id: !extend restore_from_nvs
+    then:
+      - select.set_index:
+          id: sl_button_1_action
+          index: !lambda return std::min((uint8_t)(id(button_actions_packed) & 0x0F), (uint8_t)2);
+      - select.set_index:
+          id: sl_button_2_action
+          index: !lambda return std::min((uint8_t)((id(button_actions_packed) >> 4) & 0x0F), (uint8_t)2);
+      - select.set_index:
+          id: sl_button_3_action
+          index: !lambda return std::min((uint8_t)((id(button_actions_packed) >> 8) & 0x0F), (uint8_t)2);
+      - select.set_index:
+          id: sl_button_4_action
+          index: !lambda return std::min((uint8_t)((id(button_actions_packed) >> 12) & 0x0F), (uint8_t)2);
+
   - id: !extend touch_on_multi_touch_release
     then:
       - script.execute: buttons_release
@@ -294,19 +315,20 @@ script:
               id(button_press_start_time) < current_time) {
             uint32_t press_duration  = current_time - id(button_press_start_time);
             // Handle overflow (optional, since it's unlikely to happen here)
-            ESP_LOGI("core_hw_buttons", "Button press duration: %" PRIu32 " ms", press_duration);
+            ESP_LOGI("${TAG_CORE_HW_BUTTONS}", "Button press duration: %" PRIu32 " ms", press_duration);
             if (press_duration < ${BUTTON_CLICK_MIN_LENGTH}) {
-              ESP_LOGW("core_hw_buttons", "Ignoring button press (too short)");
+              ESP_LOGW("${TAG_CORE_HW_BUTTONS}", "Ignoring button press (too short)");
             } else if (press_duration >= ${BUTTON_CLICK_MIN_LENGTH} and
                         press_duration <= ${BUTTON_CLICK_MAX_LENGTH}) { // Short/normal click
               button_click_event->execute(id(button_press_button), id(click_counter));
             } else if (press_duration >= ${BUTTON_LONG_PRESS_DELAY} and press_duration <= ${BUTTON_PRESS_TIMEOUT}) {
               button_action->execute(id(button_press_button), "long_press", 1);
             } else if (press_duration > ${BUTTON_PRESS_TIMEOUT}) { // Timeout or invalid
-              ESP_LOGW("core_hw_buttons", "Button press cancelled or timed out after ${BUTTON_PRESS_TIMEOUT} ms");
+              ESP_LOGW("${TAG_CORE_HW_BUTTONS}",
+                        "Button press cancelled or timed out after ${BUTTON_PRESS_TIMEOUT} ms");
             }
           } else {
-            ESP_LOGW("core_hw_buttons", "Press event timestamp not recorded yet");
+            ESP_LOGW("${TAG_CORE_HW_BUTTONS}", "Press event timestamp not recorded yet");
           }
           id(button_press_start_time) = 0;
 
@@ -329,11 +351,16 @@ select:
       - "${BUTTON_1_ACTION_FAILSAFE_TEXT}"
     initial_option: "${BUTTON_1_ACTION_TEXT}"
     optimistic: true
-    restore_value: true
+    restore_value: false
     internal: true
     entity_category: config
     disabled_by_default: false
     icon: mdi:dip-switch
+    on_value:
+      then:
+        - lambda: |-
+            id(button_actions_packed) = (id(button_actions_packed) & ~(0x0F << 0)) |
+                                        ((id(sl_button_1_action).active_index().value_or(1) & 0x0F) << 0);
 
   - id: sl_button_2_action
     name: Button 2 action
@@ -344,6 +371,11 @@ select:
       - "${BUTTON_2_ACTION_FAILSAFE_TEXT}"
     initial_option: "${BUTTON_2_ACTION_TEXT}"
     <<: *button_select_action_base
+    on_value:
+      then:
+        - lambda: |-
+            id(button_actions_packed) = (id(button_actions_packed) & ~(0x0F << 4)) |
+                                        ((id(sl_button_2_action).active_index().value_or(1) & 0x0F) << 4);
 
   - id: sl_button_3_action
     name: Button 3 action
@@ -354,6 +386,11 @@ select:
       - "${BUTTON_3_ACTION_FAILSAFE_TEXT}"
     initial_option: "${BUTTON_3_ACTION_TEXT}"
     <<: *button_select_action_base
+    on_value:
+      then:
+        - lambda: |-
+            id(button_actions_packed) = (id(button_actions_packed) & ~(0x0F << 8)) |
+                                        ((id(sl_button_3_action).active_index().value_or(1) & 0x0F) << 8);
 
   - id: sl_button_4_action
     name: Button 4 action
@@ -364,4 +401,9 @@ select:
       - "${BUTTON_4_ACTION_FAILSAFE_TEXT}"
     initial_option: "${BUTTON_4_ACTION_TEXT}"
     <<: *button_select_action_base
+    on_value:
+      then:
+        - lambda: |-
+            id(button_actions_packed) = (id(button_actions_packed) & ~(0x0F << 12)) |
+                                        ((id(sl_button_4_action).active_index().value_or(1) & 0x0F) << 12);
 ...

ESPHome/TX-Ultimate-Easy-ESPHome_core_hw_leds.yaml

@@ -29,19 +29,16 @@ substitutions:
   LIGHT_SIDES_RESTORE_MODE: RESTORE_DEFAULT_OFF
   LIGHT_INDIVIDUAL_RESTORE_MODE: RESTORE_DEFAULT_OFF
 
+  LIGHT_ATTRS_DEFAULT: '0x64FFFFFF'  # brightness=100, RGB=255,255,255
+  LIGHT_DUAL_ATTRS_DEFAULT: '0x64FFFFFF64FFFFFF'  # Both lights: brightness=100, RGB=255,255,255
+
+  TAG_CORE_HW_LEDS: core.hw.leds
+
 esphome:
   platformio_options:
     build_flags:
       - -D TX_ULTIMATE_EASY_CORE_HW_LEDS
 
-globals:
-  - id: gb_lights_1
-    type: std::vector<light::LightState*>
-    restore_value: false
-  - id: gb_lights_2
-    type: std::vector<light::LightState*>
-    restore_value: false
-
 light:
   # These lights are controlling the LEDs on the device
   - id: light_full
@@ -499,123 +496,129 @@ script:
       - lambda: |-
           std::string gang_count_plural_suffix = id(gang_count) > 1 ? "s" : "";
           // Relay's LEDs modes
-          ESP_LOGCONFIG("core_hw_leds", "Relay%s LEDs mode%s:",
+          ESP_LOGCONFIG("${TAG_CORE_HW_LEDS}", "Relay%s LEDs mode%s:",
                         gang_count_plural_suffix.c_str(),
                         gang_count_plural_suffix.c_str());
-          ESP_LOGCONFIG("core_hw_leds", "  Relay 1: %s", id(is_us_model)
+          ESP_LOGCONFIG("${TAG_CORE_HW_LEDS}", "  Relay 1: %s", id(is_us_model) ?
-                                                          ? sl_relay_1_light_mode_us->state.c_str()
+                                              sl_relay_1_light_mode_us->state.c_str() :
-                                                          : sl_relay_1_light_mode_eu->state.c_str());
+                                              sl_relay_1_light_mode_eu->state.c_str());
           if (id(gang_count) >= 2)
-            ESP_LOGCONFIG("core_hw_leds", "  Relay 2: %s", id(is_us_model)
+            ESP_LOGCONFIG("${TAG_CORE_HW_LEDS}", "  Relay 2: %s", id(is_us_model) ?
-                                                            ? sl_relay_2_light_mode_us->state.c_str()
+                                                sl_relay_2_light_mode_us->state.c_str() :
-                                                            : sl_relay_2_light_mode_eu->state.c_str());
+                                                sl_relay_2_light_mode_eu->state.c_str());
           if (id(gang_count) >= 3)
-            ESP_LOGCONFIG("core_hw_leds", "  Relay 3: %s", id(is_us_model)
+            ESP_LOGCONFIG("${TAG_CORE_HW_LEDS}", "  Relay 3: %s", id(is_us_model) ?
-                                                            ? sl_relay_3_light_mode_us->state.c_str()
+                                                sl_relay_3_light_mode_us->state.c_str() :
-                                                            : sl_relay_3_light_mode_eu->state.c_str());
+                                                sl_relay_3_light_mode_eu->state.c_str());
           if (id(gang_count) >= 4)
-            ESP_LOGCONFIG("core_hw_leds", "  Relay 4: %s", id(is_us_model)
+            ESP_LOGCONFIG("${TAG_CORE_HW_LEDS}", "  Relay 4: %s", id(is_us_model) ?
-                                                            ? sl_relay_4_light_mode_us->state.c_str()
+                                                sl_relay_4_light_mode_us->state.c_str() :
-                                                            : sl_relay_4_light_mode_eu->state.c_str());
+                                                sl_relay_4_light_mode_eu->state.c_str());
 
           // Transition times
-          ESP_LOGCONFIG("core_hw_leds", "Transition times:");
+          ESP_LOGCONFIG("${TAG_CORE_HW_LEDS}", "Transition times:");
-          ESP_LOGCONFIG("core_hw_leds", "  Default:     ${default_transition_length}");
+          ESP_LOGCONFIG("${TAG_CORE_HW_LEDS}", "  Default:     ${default_transition_length}");
           if (${LIGHT_TRANSITION_TURN_ON} > 0)
-            ESP_LOGCONFIG("core_hw_leds", "  Turning on:  ${LIGHT_TRANSITION_TURN_ON}ms");
+            ESP_LOGCONFIG("${TAG_CORE_HW_LEDS}", "  Turning on:  ${LIGHT_TRANSITION_TURN_ON}ms");
           else
-            ESP_LOGCONFIG("core_hw_leds", "  Turning on:  Disabled");
+            ESP_LOGCONFIG("${TAG_CORE_HW_LEDS}", "  Turning on:  Disabled");
           if (${LIGHT_TRANSITION_TURN_OFF} > 0)
-            ESP_LOGCONFIG("core_hw_leds", "  Turning off: ${LIGHT_TRANSITION_TURN_OFF}ms");
+            ESP_LOGCONFIG("${TAG_CORE_HW_LEDS}", "  Turning off: ${LIGHT_TRANSITION_TURN_OFF}ms");
           else
-            ESP_LOGCONFIG("core_hw_leds", "  Turning off: Disabled");
+            ESP_LOGCONFIG("${TAG_CORE_HW_LEDS}", "  Turning off: Disabled");
 
           // Restore modes
-          ESP_LOGCONFIG("core_hw_leds", "LED restore modes:");
+          ESP_LOGCONFIG("${TAG_CORE_HW_LEDS}", "LED restore modes:");
-          ESP_LOGCONFIG("core_hw_leds", "  Light - All: ${LIGHT_FULL_RESTORE_MODE}");
+          ESP_LOGCONFIG("${TAG_CORE_HW_LEDS}", "  Light - All: ${LIGHT_FULL_RESTORE_MODE}");
-          ESP_LOGCONFIG("core_hw_leds", "  Sides:       ${LIGHT_SIDES_RESTORE_MODE}");
+          ESP_LOGCONFIG("${TAG_CORE_HW_LEDS}", "  Sides:       ${LIGHT_SIDES_RESTORE_MODE}");
-          ESP_LOGCONFIG("core_hw_leds", "  Individual:  ${LIGHT_INDIVIDUAL_RESTORE_MODE}");
+          ESP_LOGCONFIG("${TAG_CORE_HW_LEDS}", "  Individual:  ${LIGHT_INDIVIDUAL_RESTORE_MODE}");
 
   - id: !extend dump_config_list_packages
     then:
       - script.wait: dump_config
       - lambda: |-
           // Check for requirements
-          #if !defined(TX_ULTIMATE_EASY_CORE)
+          #if !defined(TX_ULTIMATE_EASY_CORE_COMMON)
-            #error "The package TX-Ultimate-Easy-ESPHome_core.yaml is required."
+            #error "The package TX-Ultimate-Easy-ESPHome_core_common.yaml is required."
           #endif
 
           // Identify itself
           ESP_LOGCONFIG(ESPHOME_PROJECT_NAME, "  - Core - Hardware - LEDs");
 
-  - id: light_set_state
+  - id: light_attributes_restore
     mode: parallel
     parameters:
-      light_group: uint8_t
+      light_ptr: light::LightState*
-      light_index: uint8_t
+      attr_global_ptr: uint32_t*
-      state: bool
     then:
       - lambda: |-
-          static const uint32_t LIGHT_TRANSITION_TURN_ON = ${LIGHT_TRANSITION_TURN_ON};
+          tx_ultimate_easy::LightAttributes attrs = tx_ultimate_easy::unpack_light_attributes(*attr_global_ptr);
-          static const uint32_t LIGHT_TRANSITION_TURN_OFF = ${LIGHT_TRANSITION_TURN_OFF};
+          auto call = light_ptr->make_call();
-          static const uint8_t LIGHT_BRIGHTNESS_TURN_ON = ${LIGHT_BRIGHTNESS_TURN_ON};
+          call.set_brightness(attrs.brightness / 100.0f);
+          call.set_rgb(attrs.red / 255.0f, attrs.green / 255.0f, attrs.blue / 255.0f);
+          call.perform();
+          ESP_LOGI("${TAG_CORE_HW_LEDS}", "Restored light attributes: brightness=%d%%, RGB=(%d,%d,%d)",
+                                          attrs.brightness, attrs.red, attrs.green, attrs.blue);
 
-          const std::string light_mode_group_1 = id(is_us_model)
+  - id: light_attributes_restore_dual
-                                                  ? "${LIGHT_MODE_LEFT_TEXT}"
+    mode: parallel
-                                                  : "${LIGHT_MODE_BOTTOM_TEXT}";
+    parameters:
-          const std::string light_mode_group_2 = id(is_us_model)
+      light_ptr: light::LightState*
-                                                  ? "${LIGHT_MODE_RIGHT_TEXT}"
+      attr_global_ptr: uint64_t*
-                                                  : "${LIGHT_MODE_TOP_TEXT}";
+      group_index: uint8_t  # 1 or 2
+    then:
+      - lambda: |-
+          auto attrs_pair = tx_ultimate_easy::unpack_dual_light_attributes(*attr_global_ptr);
+          tx_ultimate_easy::LightAttributes attrs = (group_index == 1) ? attrs_pair.first : attrs_pair.second;
 
-          switch (light_group) {
+          auto call = light_ptr->make_call();
-            case 1:
+          call.set_brightness(attrs.brightness / 100.0f);
-              if (light_index >= id(gb_lights_1).size()) {
+          call.set_rgb(attrs.red / 255.0f, attrs.green / 255.0f, attrs.blue / 255.0f);
-                ESP_LOGE("core_hw_leds", "Invalid set with %s light for Relay %" PRIu8,
-                                          light_mode_group_1.c_str(), light_index+1);
-                return;
-              }
-              if (state and !id(gb_lights_1)[light_index]->current_values.is_on()) {
-                ESP_LOGI("core_hw_leds", "Turn-on %s light for Relay %" PRIu8,
-                                          light_mode_group_1.c_str(), light_index+1);
-                auto call = id(gb_lights_1)[light_index]->turn_on();
-                if (LIGHT_TRANSITION_TURN_ON > 0)
-                  call.set_transition_length(LIGHT_TRANSITION_TURN_ON);  // in ms
-                if (LIGHT_BRIGHTNESS_TURN_ON > 0 and LIGHT_BRIGHTNESS_TURN_ON <= 100)
-                  call.set_brightness(LIGHT_BRIGHTNESS_TURN_ON / 100.0f);
           call.perform();
-              } else if (!state and id(gb_lights_1)[light_index]->current_values.is_on()) {
+
-                ESP_LOGI("core_hw_leds", "Turn-off %s light for Relay %" PRIu8,
+  - id: light_attributes_save
-                                          light_mode_group_1.c_str(), light_index+1);
+    mode: parallel
-                auto call = id(gb_lights_1)[light_index]->turn_off();
+    parameters:
-                if (LIGHT_TRANSITION_TURN_OFF > 0)
+      light_ptr: light::LightState*
-                  call.set_transition_length(LIGHT_TRANSITION_TURN_OFF);  // in ms
+      attr_global_ptr: uint32_t*
-                call.perform();
+    then:
-              }
+      - lambda: |-
-              break;
+          auto current = light_ptr->current_values;
-            case 2:
+          tx_ultimate_easy::LightAttributes attrs = {
-              if (light_index >= id(gb_lights_2).size()) {
+            .brightness = uint8_t(current.get_brightness() * 100.0f),
-                ESP_LOGE("core_hw_leds", "Invalid set with %s light for Relay %" PRIu8,
+            .red = uint8_t(current.get_red() * 255.0f),
-                                          light_mode_group_2.c_str(), light_index+1);
+            .green = uint8_t(current.get_green() * 255.0f),
-                return;
+            .blue = uint8_t(current.get_blue() * 255.0f)
-              }
+          };
-              if (state and !id(gb_lights_2)[light_index]->current_values.is_on()) {
+
-                ESP_LOGI("core_hw_leds", "Turn-on %s light for Relay %" PRIu8,
+          *attr_global_ptr = tx_ultimate_easy::pack_light_attributes(attrs);
-                                          light_mode_group_2.c_str(), light_index+1);
+          ESP_LOGD("${TAG_CORE_HW_LEDS}", "Saved light attributes: brightness=%d%%, RGB=(%d,%d,%d)",
-                auto call = id(gb_lights_2)[light_index]->turn_on();
+                                          attrs.brightness, attrs.red, attrs.green, attrs.blue);
-                if (LIGHT_TRANSITION_TURN_ON > 0)
+
-                  call.set_transition_length(LIGHT_TRANSITION_TURN_ON);  // in ms
+  - id: light_attributes_save_dual
-                if (LIGHT_BRIGHTNESS_TURN_ON > 0 and LIGHT_BRIGHTNESS_TURN_ON <= 100)
+    mode: parallel
-                  call.set_brightness(LIGHT_BRIGHTNESS_TURN_ON / 100.0f);
+    parameters:
-                call.perform();
+      light_ptr: light::LightState*
-              } else if (!state and id(gb_lights_2)[light_index]->current_values.is_on()) {
+      attr_global_ptr: uint64_t*
-                ESP_LOGI("core_hw_leds", "Turn-off %s light for Relay %" PRIu8,
+      group_index: uint8_t  # 1 or 2 (which group within the dual pack)
-                                          light_mode_group_2.c_str(), light_index+1);
+    then:
-                auto call = id(gb_lights_2)[light_index]->turn_off();
+      - lambda: |-
-                if (LIGHT_TRANSITION_TURN_OFF > 0)
+          auto current = light_ptr->current_values;
-                  call.set_transition_length(LIGHT_TRANSITION_TURN_OFF);  // in ms
+          tx_ultimate_easy::LightAttributes new_attrs = {
-                call.perform();
+            .brightness = uint8_t(current.get_brightness() * 100.0f),
-              }
+            .red = uint8_t(current.get_red() * 255.0f),
-              break;
+            .green = uint8_t(current.get_green() * 255.0f),
+            .blue = uint8_t(current.get_blue() * 255.0f)
+          };
+
+          // Unpack existing dual attributes
+          auto existing = tx_ultimate_easy::unpack_dual_light_attributes(*attr_global_ptr);
+
+          // Update the appropriate group
+          if (group_index == 1) {
+            *attr_global_ptr = tx_ultimate_easy::pack_dual_light_attributes(new_attrs, existing.second);
+          } else {
+            *attr_global_ptr = tx_ultimate_easy::pack_dual_light_attributes(existing.first, new_attrs);
           }
 
 select:

ESPHome/TX-Ultimate-Easy-ESPHome_core_hw_touch.yaml

@@ -14,6 +14,8 @@
 substitutions:
   TOUCH_POSITION_MAX_VALUE: '10'  # Maximum touch position value returned by the touch pad via uart
 
+  TAG_CORE_HW_TOUCH: core.hw.touch
+
 binary_sensor:
   - &bs_button_event_template
     id: bs_button_event_template
@@ -203,15 +205,6 @@ esphome:
     build_flags:
       - -D TX_ULTIMATE_EASY_CORE_HW_TOUCH
 
-external_components:
-  - source:
-      type: git
-      url: https://github.com/edwardtfn/TX-Ultimate-Easy
-      ref: v${version}
-    refresh: 1h
-    components:
-      - tx_ultimate_easy
-
 number:
   - id: nr_touch_duration
     name: Touch event duration
@@ -293,18 +286,18 @@ script:
       - lambda: |-
           // Touch panel's state
           if (sw_touch_panel_power->state)
-            ESP_LOGCONFIG("core_hw_touch", "Touch panel - Power: On");
+            ESP_LOGCONFIG("${TAG_CORE_HW_TOUCH}", "Touch panel - Power: On");
           else
-            ESP_LOGW("core_hw_touch", "Touch panel - Power: OFF");
+            ESP_LOGW("${TAG_CORE_HW_TOUCH}", "Touch panel - Power: OFF");
-          ESP_LOGCONFIG("core_hw_touch", "Touch event duration: %.0fms", nr_touch_duration->state);
+          ESP_LOGCONFIG("${TAG_CORE_HW_TOUCH}", "Touch event duration: %.0fms", nr_touch_duration->state);
 
   - id: !extend dump_config_list_packages
     then:
       - script.wait: dump_config
       - lambda: |-
           // Check for requirements
-          #if !defined(TX_ULTIMATE_EASY_CORE)
+          #if !defined(TX_ULTIMATE_EASY_CORE_COMMON)
-            #error "The package TX-Ultimate-Easy-ESPHome_core.yaml is required."
+            #error "The package TX-Ultimate-Easy-ESPHome_core_common.yaml is required."
           #endif
 
           // Identify itself
@@ -373,16 +366,15 @@ switch:
     entity_category: config
 
 tx_ultimate_easy:
-  id: tx_ultimate
   uart: uart_touch
 
   on_long_touch_release:
     - lambda: |-
         const uint8_t touch_position = static_cast<uint8_t>(touch.x);
         if (touch_position > ${TOUCH_POSITION_MAX_VALUE}) {  // Check for valid range
-          ESP_LOGE("core_hw_touch", "Invalid long-touch position: %" PRIu8, touch_position);
+          ESP_LOGE("${TAG_CORE_HW_TOUCH}", "Invalid long-touch position: %" PRIu8, touch_position);
         } else {
-          ESP_LOGI("core_hw_touch", "Long-touch released at position %" PRIu8, touch_position);
+          ESP_LOGI("${TAG_CORE_HW_TOUCH}", "Long-touch released at position %" PRIu8, touch_position);
         }
 
   on_multi_touch_release:
@@ -397,7 +389,7 @@ tx_ultimate_easy:
             action: release
             position: !lambda return std::to_string(touch.x);
       - lambda: |-
-          ESP_LOGI("core_hw_touch", "Multi-touch released");
+          ESP_LOGI("${TAG_CORE_HW_TOUCH}", "Multi-touch released");
           touch_on_multi_touch_release->execute();
 
   on_press:
@@ -405,15 +397,16 @@ tx_ultimate_easy:
       - lambda: |-
           const uint8_t position = static_cast<uint8_t>(touch.x);
           if (position > ${TOUCH_POSITION_MAX_VALUE}) {  // Check for valid range
-            ESP_LOGE("core_hw_touch", "Invalid touch position: %" PRIu8, position);
+            ESP_LOGE("${TAG_CORE_HW_TOUCH}", "Invalid touch position: %" PRIu8, position);
           } else {
-            ESP_LOGI("core_hw_touch", "Pressed at position %" PRIu8, position);
+            ESP_LOGI("${TAG_CORE_HW_TOUCH}", "Pressed at position %" PRIu8, position);
             touch_on_press->execute(static_cast<uint8_t>(touch.button), position);
           }
 
   on_release:
     then:
-      - lambda: ESP_LOGI("core_hw_touch", "Released");
+      - lambda: |-
+          ESP_LOGI("${TAG_CORE_HW_TOUCH}", "Released");
       - script.execute: touch_on_release
 
   on_swipe_left:
@@ -437,7 +430,7 @@ tx_ultimate_easy:
                 return "down";
             position: !lambda return std::to_string(touch.x);
       - lambda: |-
-          ESP_LOGI("core_hw_touch", "Swipe %s",
+          ESP_LOGI("${TAG_CORE_HW_TOUCH}", "Swipe %s",
                     (sl_tx_model_format->state == "${TX_MODEL_FORMAT_EU_TEXT}") ? "left" : "down");
           touch_swipe_left->execute();
 
@@ -462,15 +455,15 @@ tx_ultimate_easy:
                 return "up";
             position: !lambda return std::to_string(touch.x);
       - lambda: |-
-          ESP_LOGI("core_hw_touch", "Swipe %s",
+          ESP_LOGI("${TAG_CORE_HW_TOUCH}", "Swipe %s",
                     (sl_tx_model_format->state == "${TX_MODEL_FORMAT_EU_TEXT}") ? "right" : "up");
           touch_swipe_right->execute();
 
   on_touch_event:
     - lambda: |-
-        ESP_LOGD("core_hw_touch", "Touch event:");
+        ESP_LOGD("${TAG_CORE_HW_TOUCH}", "Touch event:");
-        ESP_LOGD("core_hw_touch", "  State:    %i (%s)", touch.state, touch.state_str.c_str());
+        ESP_LOGD("${TAG_CORE_HW_TOUCH}", "  State:    %i (%s)", touch.state, touch.state_str.c_str());
-        ESP_LOGD("core_hw_touch", "  Position: %i", touch.x);
+        ESP_LOGD("${TAG_CORE_HW_TOUCH}", "  Position: %i", touch.x);
 
 uart:
   - id: uart_touch

ESPHome/TX-Ultimate-Easy-ESPHome_standard_hw_audio.yaml

@@ -14,6 +14,8 @@
 substitutions:
   SWITCH_AUDIO_AMPLIFIER_RESTORE_MODE: RESTORE_DEFAULT_ON
 
+  TAG_STD_HW_AUDIO: std.hw.audio
+
 esphome:
   platformio_options:
     build_flags:
@@ -30,8 +32,8 @@ script:
       - script.wait: dump_config
       - lambda: |-
           // Check for requirements
-          #if !defined(TX_ULTIMATE_EASY_CORE)
+          #if !defined(TX_ULTIMATE_EASY_CORE_COMMON)
-            #error "The package TX-Ultimate-Easy-ESPHome_core.yaml is required."
+            #error "The package TX-Ultimate-Easy-ESPHome_core_common.yaml is required."
           #endif
 
           // Identify itself

ESPHome/TX-Ultimate-Easy-ESPHome_standard_hw_speaker.yaml

@@ -16,6 +16,8 @@ substitutions:
   # d=32 (32nd note), o=5 (octave 5), b=100 (tempo 100)
   tone_volume_change: "scale_up:d=32,o=5,b=100:c,c#,d#,e,f#,g#,a#,b"  # Use "none" to disable sound
 
+  TAG_STD_HW_SPEAKER: std.hw.speaker
+
 packages:
   standard_hw_audio: !include TX-Ultimate-Easy-ESPHome_standard_hw_audio.yaml
 
@@ -31,7 +33,7 @@ api:
         - lambda: |-
             rtttl_speaker->stop();
             if (speaker_volume->state > 0) {
-              ESP_LOGI("standard_speaker", "Play tone: '%s'", tone.c_str());
+              ESP_LOGI("${TAG_STD_HW_SPEAKER}", "Play tone: '%s'", tone.c_str());
               rtttl_speaker->play(tone.c_str());
             }
 
@@ -76,8 +78,8 @@ script:
       - script.wait: dump_config
       - lambda: |-
           // Check for requirements
-          #if !defined(TX_ULTIMATE_EASY_CORE)
+          #if !defined(TX_ULTIMATE_EASY_CORE_COMMON)
-            #error "The package TX-Ultimate-Easy-ESPHome_core.yaml is required."
+            #error "The package TX-Ultimate-Easy-ESPHome_core_common.yaml is required."
           #endif
           #if !defined(TX_ULTIMATE_EASY_STANDARD_HW_AUDIO)
             #error "The package TX-Ultimate-Easy-ESPHome_standard_hw_audio.yaml is required."

ESPHome/TX-Ultimate-Easy-ESPHome_standard_hw_vibration.yaml

@@ -14,6 +14,8 @@
 substitutions:
   vibration_max_duration: 2s
 
+  TAG_STD_HW_VIBRATION: std.hw.vibration
+
 binary_sensor:
   - id: bs_vibrating
     name: Vibrating
@@ -62,24 +64,24 @@ script:
     then:
       - lambda: |-
           // Configuration
-          ESP_LOGCONFIG("standard_hw_vibration", "Touch - Vibration feedback: %s",
+          ESP_LOGCONFIG("${TAG_STD_HW_VIBRATION}", "Touch - Vibration feedback: %s",
                         sl_touch_vibration_feedback->state.c_str());
-          ESP_LOGCONFIG("standard_hw_vibration", "Vibrate duration: %.0fms", nr_vibrating_duration->state);
+          ESP_LOGCONFIG("${TAG_STD_HW_VIBRATION}", "Vibrate duration: %.0fms", nr_vibrating_duration->state);
-          ESP_LOGCONFIG("standard_hw_vibration", "Vibrate max duration: ${vibration_max_duration}");
+          ESP_LOGCONFIG("${TAG_STD_HW_VIBRATION}", "Vibrate max duration: ${vibration_max_duration}");
 
           // State
           if (bs_vibrating->state)
-            ESP_LOGW("standard_hw_vibration", "Vibrating now: YES");
+            ESP_LOGW("${TAG_STD_HW_VIBRATION}", "Vibrating now: YES");
           else
-            ESP_LOGCONFIG("standard_hw_vibration", "Vibrating now: No");
+            ESP_LOGCONFIG("${TAG_STD_HW_VIBRATION}", "Vibrating now: No");
 
   - id: !extend dump_config_list_packages
     then:
       - script.wait: dump_config
       - lambda: |-
           // Check for requirements
-          #if !defined(TX_ULTIMATE_EASY_CORE)
+          #if !defined(TX_ULTIMATE_EASY_CORE_COMMON)
-            #error "The package TX-Ultimate-Easy-ESPHome_core.yaml is required."
+            #error "The package TX-Ultimate-Easy-ESPHome_core_common.yaml is required."
           #endif
 
           // Identify itself

ESPHome/TX-Ultimate-Easy-ESPHome_standard_media_player.yaml

@@ -11,6 +11,9 @@
 ##### - For normal system use, modifications to this file are NOT required.                    #####
 ####################################################################################################
 ---
+substitutions:
+  TAG_STD_MEDIA_PLAYER: "std.media-player"
+
 packages:
   standard_hw_speaker: !include TX-Ultimate-Easy-ESPHome_standard_hw_speaker.yaml
 
@@ -54,7 +57,8 @@ media_player:
             id(persistent_media_player_volume) = static_cast<uint8_t>(mp_media_player->volume * 100.0f);
             if (id(persistent_media_player_volume) != id(last_media_player_volume)) {
               id(last_media_player_volume) = id(persistent_media_player_volume);
-              ESP_LOGD("media_player_volume", "Media player volume changed to %" PRIu8 "%%, updating number entity", id(persistent_media_player_volume));
+              ESP_LOGD("${TAG_STD_MEDIA_PLAYER}", "Media player volume changed to %" PRIu8 "%%, updating number entity",
+                                                  id(persistent_media_player_volume));
             }
 
 script:
@@ -66,17 +70,18 @@ script:
     then:
       - lambda: |-
           // Volume sync configuration
-          ESP_LOGCONFIG("standard_media_player", "Media Player Volume Sync:");
+          ESP_LOGCONFIG("${TAG_STD_MEDIA_PLAYER}", "Media Player Volume Sync:");
-          ESP_LOGCONFIG("standard_media_player", "  Persistent volume: %" PRIu8 "%", id(persistent_media_player_volume));
+          ESP_LOGCONFIG("${TAG_STD_MEDIA_PLAYER}", "  Persistent volume: %" PRIu8 "%",
-          ESP_LOGCONFIG("standard_media_player", "  Current volume: %.1f%%", mp_media_player->volume * 100.0f);
+                                                    id(persistent_media_player_volume));
+          ESP_LOGCONFIG("${TAG_STD_MEDIA_PLAYER}", "  Current volume: %.1f%%", mp_media_player->volume * 100.0f);
 
   - id: !extend dump_config_list_packages
     then:
       - script.wait: dump_config
       - lambda: |-
           // Check for requirements
-          #if !defined(TX_ULTIMATE_EASY_CORE)
+          #if !defined(TX_ULTIMATE_EASY_CORE_COMMON)
-            #error "The package TX-Ultimate-Easy-ESPHome_core.yaml is required."
+            #error "The package TX-Ultimate-Easy-ESPHome_core_common.yaml is required."
           #endif  // TX_ULTIMATE_EASY_CORE
           #if !defined(TX_ULTIMATE_EASY_STANDARD_HW_SPEAKER)
             #error "The package TX-Ultimate-Easy-ESPHome_standard_hw_speaker.yaml is required."
@@ -94,7 +99,8 @@ script:
           volume: !lambda return id(persistent_media_player_volume) / 100.0f;
       - lambda: |-
           id(last_media_player_volume) = id(persistent_media_player_volume);
-          ESP_LOGI("media_player_volume", "Initial volume sync: %.1f%% (restored from persistence)", id(persistent_media_player_volume));
+          ESP_LOGI("${TAG_STD_MEDIA_PLAYER}", "Initial volume sync: %.1f%% (restored from persistence)",
+                                              id(persistent_media_player_volume));
 
 speaker:
   - platform: mixer

README.md

@@ -161,7 +161,7 @@ Follow these steps to get your TX Ultimate device up and running with ESPHome.
    packages:
      remote_package:
        url: https://github.com/edwardtfn/TX-Ultimate-Easy
-       ref: stable  # Or you can specify a version, like `ref: v2024.12.6` or `ref: latest` to the latest non-stable
+       ref: main  # Or you can specify a version, like `ref: v2024.12.6` or `ref: latest`
        refresh: 5min
        files:
          - ESPHome/TX-Ultimate-Easy-ESPHome_core.yaml      # Core (essential) packages
@@ -225,7 +225,7 @@ Here's an example of the advanced configuration:
 packages:
   remote_package:
     url: https://github.com/edwardtfn/TX-Ultimate-Easy
-    ref: stable  # Or you can specify a version, like `ref: v2024.12.6` or `ref: latest` to the latest non-stable
+    ref: main  # Or you can specify a version, like `ref: v2024.12.6` or `ref: latest`
     refresh: 5min
     files:
       # Core (essential) packages
@@ -348,7 +348,7 @@ If the device isn't discovered automatically:
    - Button actions
 3. Optional: Configure advanced features
    - LED behaviors
-   - Touch sensitivity
+   - Touch duration
    - Haptic feedback
    - Audio feedback
 4. Test your configuration:
@@ -374,7 +374,7 @@ After installation, you can:
 
 TX Ultimate Easy offers extensive configuration options:
 
-- Touch panel sensitivity and gestures
+- Touch panel gestures
 - LED colors, patterns, and behaviors
 - Relay modes and functions
 - Audio and haptic feedback settings

components/tx_ultimate_easy/tx_ultimate_easy_light.cpp

@@ -0,0 +1,58 @@
+// tx_ultimate_easy_light.cpp
+
+#ifdef TX_ULTIMATE_EASY_CORE_HW_LEDS
+
+#include "esphome/core/log.h"
+#include "tx_ultimate_easy_light.h"
+#include <cinttypes>
+#include <string>
+
+namespace esphome {
+    namespace tx_ultimate_easy {
+
+        // Log tag
+        static const char *TAG = "tx_ultimate_easy.light";
+
+        // Constant definitions
+        const LightAttributes LIGHT_ATTRS_DEFAULT = {100, 255, 255, 255};
+        const uint32_t LIGHT_ATTRS_DEFAULT_PACKED = 0x64FFFFFF;
+        const uint64_t DEFAULT_DUAL_LIGHT_ATTRS_PACKED = 0x64FFFFFF64FFFFFF;
+
+        // Function implementations
+        uint32_t pack_light_attributes(const LightAttributes& attr) {
+            return (uint32_t(std::min(attr.brightness, uint8_t(100))) << 24) |
+                (uint32_t(attr.red) << 16) |
+                (uint32_t(attr.green) << 8) |
+                (uint32_t(attr.blue));
+        }
+
+        LightAttributes unpack_light_attributes(uint32_t packed) {
+            return {
+                .brightness = std::min(uint8_t((packed >> 24) & 0xFF), uint8_t(100)),
+                .red = uint8_t((packed >> 16) & 0xFF),
+                .green = uint8_t((packed >> 8) & 0xFF),
+                .blue = uint8_t(packed & 0xFF)
+            };
+        }
+
+        uint64_t pack_dual_light_attributes(const LightAttributes& group1_attrs, const LightAttributes& group2_attrs) {
+            uint32_t group1_packed = pack_light_attributes(group1_attrs);
+            uint32_t group2_packed = pack_light_attributes(group2_attrs);
+            
+            return (uint64_t(group2_packed) << 32) | uint64_t(group1_packed);
+        }
+        
+        std::pair<LightAttributes, LightAttributes> unpack_dual_light_attributes(uint64_t packed) {
+            uint32_t group1_packed = uint32_t(packed & 0xFFFFFFFF);          // Lower 32 bits
+            uint32_t group2_packed = uint32_t((packed >> 32) & 0xFFFFFFFF);  // Upper 32 bits
+            
+            return std::make_pair(
+                unpack_light_attributes(group1_packed),
+                unpack_light_attributes(group2_packed)
+            );
+        }
+
+    } // namespace tx_ultimate_easy
+} // namespace esphome
+
+#endif  // TX_ULTIMATE_EASY_CORE_HW_LEDS

components/tx_ultimate_easy/tx_ultimate_easy_light.h

@@ -0,0 +1,116 @@
+// tx_ultimate_easy_light.h
+
+#pragma once
+
+#ifdef TX_ULTIMATE_EASY_CORE_HW_LEDS
+
+#include "esphome/core/automation.h"
+#include "esphome/core/component.h"
+#include "esphome/components/uart/uart.h"
+#include "esphome/components/uart/uart_component.h"
+#include "esphome/components/binary_sensor/binary_sensor.h"
+#include "esphome/components/switch/switch.h"
+#include "esphome/components/light/addressable_light.h"
+#include <array>
+
+namespace esphome {
+    namespace tx_ultimate_easy {
+        /**
+        * @brief Light attributes structure for storing color and brightness data.
+        * 
+        * This structure represents the visual attributes of a light without the state (on/off).
+        * It's designed to be packed efficiently into a 32-bit integer for NVS storage.
+        * RGB components use the full 8-bit range (0-255) while brightness uses percentage (0-100).
+        */
+        struct LightAttributes {
+            uint8_t brightness;  ///< Light brightness percentage (0-100, where 100 = full brightness)
+            uint8_t red;         ///< Red color component (0-255)
+            uint8_t green;       ///< Green color component (0-255)  
+            uint8_t blue;        ///< Blue color component (0-255)
+        };
+
+        /**
+        * @brief Packs LightAttributes structure into a 32-bit integer for storage.
+        * 
+        * Bit layout: [brightness(8)][red(8)][green(8)][blue(8)]
+        * This allows efficient storage in ESPHome globals with restore_value support.
+        * Note: Brightness values > 100 will be clamped to 100 during packing.
+        * 
+        * @param attr The LightAttributes structure to pack
+        * @return uint32_t Packed representation suitable for NVS storage
+        * 
+        * @example
+        * LightAttributes attrs = {75, 255, 128, 64};
+        * uint32_t packed = pack_light_attributes(attrs);  // Returns 0x4BFF8040
+        */
+        uint32_t pack_light_attributes(const LightAttributes& attr);
+
+        /**
+        * @brief Unpacks a 32-bit integer back into LightAttributes structure.
+        * 
+        * Reverses the packing operation to extract individual color and brightness values.
+        * Brightness values > 100 in the packed data will be clamped to 100.
+        * 
+        * @param packed The packed 32-bit representation
+        * @return LightAttributes The unpacked structure with individual components
+        * 
+        * @example
+        * uint32_t packed = 0x4BFF8040;
+        * LightAttributes attrs = unpack_light_attributes(packed);
+        * // attrs.brightness = 75, attrs.red = 255, attrs.green = 128, attrs.blue = 64
+        */
+        LightAttributes unpack_light_attributes(uint32_t packed);
+
+        /**
+        * @brief Default light attributes for initialization.
+        * 
+        * Provides sensible defaults for new lights:
+        * - Brightness: 100 (full brightness)
+        * - Red: 255 (full intensity)
+        * - Green: 255 (full intensity) 
+        * - Blue: 255 (full intensity)
+        * Result: Pure white color at full brightness
+        */
+        extern const LightAttributes LIGHT_ATTRS_DEFAULT;
+
+        /**
+        * @brief Pre-packed version of DEFAULT_LIGHT_ATTRS for convenience.
+        * 
+        * This constant contains LIGHT_ATTRS_DEFAULT already packed into uint32_t format,
+        * suitable for direct use in ESPHome YAML initial_value fields.
+        * 
+        * Value: 0x64FFFFFF (brightness=100, RGB=255,255,255)
+        */
+        extern const uint32_t LIGHT_ATTRS_DEFAULT_PACKED;
+
+        /**
+        * @brief Packs two LightAttributes into a single uint64_t for dual light storage.
+        * 
+        * Bit layout: [group2_light(32)][group1_light(32)]
+        * Each light uses 32 bits: [brightness(8)][red(8)][green(8)][blue(8)]
+        * 
+        * @param group1_attrs First light attributes (stored in lower 32 bits)
+        * @param group2_attrs Second light attributes (stored in upper 32 bits)
+        * @return uint64_t Packed representation suitable for NVS storage
+        */
+        uint64_t pack_dual_light_attributes(const LightAttributes& group1_attrs, const LightAttributes& group2_attrs);
+
+        /**
+        * @brief Unpacks uint64_t back into two LightAttributes structures.
+        * 
+        * @param packed The packed 64-bit representation
+        * @return std::pair<LightAttributes, LightAttributes> Pair of (group1, group2) attributes
+        */
+        std::pair<LightAttributes, LightAttributes> unpack_dual_light_attributes(uint64_t packed);
+        
+        /**
+        * @brief Pre-packed version of dual default attributes for convenience.
+        * 
+        * Value: 0x64FFFFFF64FFFFFF (both lights: brightness=100, RGB=255,255,255)
+        */
+        extern const uint64_t DEFAULT_DUAL_LIGHT_ATTRS_PACKED;
+
+    } // namespace tx_ultimate_easy
+} // namespace esphome
+
+#endif  // TX_ULTIMATE_EASY_CORE_HW_LEDS

components/tx_ultimate_easy/tx_ultimate_easy_touch.cpp

@@ -1,13 +1,18 @@
-// tx_ultimate_easy.cpp
+// tx_ultimate_easy_touch.cpp
+
+#ifdef TX_ULTIMATE_EASY_CORE_HW_TOUCH
 
 #include "esphome/core/log.h"
-#include "tx_ultimate_easy.h"
+#include "tx_ultimate_easy_touch.h"
 #include <cinttypes>
 #include <string>
 
 namespace esphome {
     namespace tx_ultimate_easy {
 
+        // Log tag
+        static const char *TAG = "tx_ultimate_easy.touch";
+
         void TxUltimateEasy::setup() {
             ESP_LOGI(TAG, "TX Ultimate Easy is initialized");
         }
@@ -69,9 +74,9 @@ namespace esphome {
             if (this->gang_count_ == 1)
                 return 1;
 
-            //Calculate button number Change to round up insted of truncate (integer division)
+            // Calculate button number Change to round up instead of truncate (integer division)
             const uint8_t width = (TOUCH_MAX_POSITION + gang_count_) / this->gang_count_;  // Width of each button region
-            if (width < 1)  // Invalid width - and prevents division by zero removed "width > gang_count_" issue with 2 gang 
+            if (width < 1)  // Invalid width - and prevents division by zero 
                 return 0;
             const uint8_t button = std::min(
                 static_cast<uint8_t>((position / width) + 1), // Convert position to button index
@@ -141,8 +146,36 @@ namespace esphome {
             switch (uart_received_bytes[4]) {
                 case TOUCH_STATE_RELEASE:
                 case TOUCH_STATE_MULTI_TOUCH:
+                    return uart_received_bytes[5];
+
                 case TOUCH_STATE_SWIPE_LEFT:
                 case TOUCH_STATE_SWIPE_RIGHT:
+                    // uart_received_bytes[5] indicates swipe direction:
+                    // 12 = find last touch position (scan right to left)
+                    // 13 = find first touch position (scan left to right)
+                    // Bytes 6-7 contain a 10-bit bitmap of touch positions:
+                    // Byte 7: bits 0-7 represent positions 1-8
+                    // Byte 6: bits 0-1 represent positions 9-10
+                    switch (uart_received_bytes[5]) {
+                        case 12:
+                            for (uint8_t i = 10; i > 0; i--) {
+                                if (i > 8
+                                    ? uart_received_bytes[6] & (1 << (i - 9))
+                                    : uart_received_bytes[7] & (1 << (i - 1))) {
+                                    return i;
+                                }
+                            }
+                            break;
+                        case 13:
+                            for (uint8_t i = 1; i <= 10; i++) {
+                                if (i > 8
+                                    ? uart_received_bytes[6] & (1 << (i - 9))
+                                    : uart_received_bytes[7] & (1 << (i - 1))) {
+                                    return i;
+                                }
+                            }
+                            break;
+                    }
                     return uart_received_bytes[5];
 
                 default:
@@ -152,8 +185,10 @@ namespace esphome {
 
         int TxUltimateEasy::get_touch_state(const std::array<int, UART_RECEIVED_BYTES_SIZE> &uart_received_bytes) {
             int state = uart_received_bytes[4];
-            if (state == TOUCH_STATE_PRESS && uart_received_bytes[5] != 0) state = TOUCH_STATE_RELEASE;
+            if (state == TOUCH_STATE_PRESS && uart_received_bytes[5] != 0)
-            if (state == TOUCH_STATE_RELEASE && uart_received_bytes[5] == TOUCH_STATE_MULTI_TOUCH) state = TOUCH_STATE_MULTI_TOUCH;
+                state = TOUCH_STATE_RELEASE;
+            if (state == TOUCH_STATE_RELEASE && uart_received_bytes[5] == TOUCH_STATE_MULTI_TOUCH)
+                state = TOUCH_STATE_MULTI_TOUCH;
             if (state == TOUCH_STATE_SWIPE) {
                 state = (uart_received_bytes[5] == TOUCH_STATE_SWIPE_RIGHT) ? TOUCH_STATE_SWIPE_RIGHT : 
                         (uart_received_bytes[5] == TOUCH_STATE_SWIPE_LEFT) ? TOUCH_STATE_SWIPE_LEFT : state;
@@ -195,3 +230,5 @@ namespace esphome {
 
     } // namespace tx_ultimate_easy
 } // namespace esphome
+
+#endif  // TX_ULTIMATE_EASY_CORE_HW_TOUCH

components/tx_ultimate_easy/tx_ultimate_easy_touch.h

@@ -1,7 +1,9 @@
-// tx_ultimate_easy.h
+// tx_ultimate_easy_touch.h
 
 #pragma once
 
+#ifdef TX_ULTIMATE_EASY_CORE_HW_TOUCH
+
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/components/uart/uart.h"
@@ -31,9 +33,6 @@ namespace esphome {
         constexpr int VALID_DATA_BYTE_2 = 0x01;
         constexpr int VALID_DATA_BYTE_3 = 0x02;
 
-        // Log tag
-        static const char *TAG = "tx_ultimate_easy";
-
         struct TouchPoint {
             uint8_t button = 0;
             int8_t x = -1;
@@ -84,3 +83,5 @@ namespace esphome {
 
     } // namespace tx_ultimate_easy
 } // namespace esphome
+
+#endif  // TX_ULTIMATE_EASY_CORE_HW_TOUCH

versioning/VERSION

@@ -1 +1 @@
-2025.8.1
+2025.8.2

versioning/VERSION_YAML

@@ -1 +1 @@
-version: 2025.8.1
+version: 2025.8.2dev