From 9bcb4d7177a2fb06e123afc56f2ece13f2dfb912 Mon Sep 17 00:00:00 2001 From: Sleeper85 Date: Sun, 28 Jun 2026 00:09:39 +0200 Subject: [PATCH] New yambms_id format --- YamBMS_LP_DEMO.yaml | 17 +- YamBMS_LP_PVbrain2.yaml | 17 +- YamBMS_Local_Packages_example.yaml | 17 +- YamBMS_RP_BMS_BASEN_RS485.yaml | 17 +- YamBMS_RP_BMS_DEYE_CAN.yaml | 17 +- YamBMS_RP_BMS_EG4_RS485.yaml | 17 +- YamBMS_RP_BMS_Ecoworthy_RS485.yaml | 17 +- YamBMS_RP_BMS_JBD.yaml | 17 +- YamBMS_RP_BMS_JK-B_RS485_Modbus.yaml | 17 +- YamBMS_RP_BMS_JK-PB_RS485_Modbus.yaml | 17 +- YamBMS_RP_BMS_JK_BLE.yaml | 17 +- YamBMS_RP_BMS_JK_UART_4G-GPS.yaml | 17 +- YamBMS_RP_BMS_PACE_RS485_Modbus.yaml | 17 +- YamBMS_RP_BMS_SEPLOS_V1_V2_RS485_Modbus.yaml | 17 +- ...RP_BMS_SEPLOS_V3_RS485_Modbus_sniffer.yaml | 17 +- YamBMS_RP_Balancer.yaml | 17 +- YamBMS_RP_DEMO.yaml | 17 +- YamBMS_RP_Ethernet_board.yaml | 17 +- YamBMS_RP_HA_Display.yaml | 13 +- YamBMS_RP_PVbrain2.yaml | 17 +- YamBMS_Remote_Packages_example.yaml | 17 +- ...MS_Remote_Packages_example_dev_branch.yaml | 17 +- packages/bms/bms_combine.yaml | 94 +- packages/shunt/shunt_combine.yaml | 28 +- packages/yambms/yambms_auto_ccl.yaml | 34 +- packages/yambms/yambms_auto_cvl.yaml | 44 +- packages/yambms/yambms_auto_dcl.yaml | 28 +- packages/yambms/yambms_auto_eoc.yaml | 140 +-- packages/yambms/yambms_auto_float.yaml | 46 +- packages/yambms/yambms_auto_soc_limit.yaml | 130 +-- packages/yambms/yambms_auto_temp_ccl_dcl.yaml | 56 +- packages/yambms/yambms_canbus.yaml | 190 +-- packages/yambms/yambms_core.yaml | 1028 ++++++++--------- packages/yambms/yambms_rs485_pylon.yaml | 48 +- packages/yambms/yambms_service.yaml | 26 +- packages/yambms/yambms_web_server.yaml | 74 +- yambms_custom.yaml | 28 +- 37 files changed, 1218 insertions(+), 1146 deletions(-) diff --git a/YamBMS_LP_DEMO.yaml b/YamBMS_LP_DEMO.yaml index 2b2037f..fcab672 100644 --- a/YamBMS_LP_DEMO.yaml +++ b/YamBMS_LP_DEMO.yaml @@ -1,4 +1,4 @@ -# Updated : 2026.03.24 +# Updated : 2026.06.27 # Version : 1.7.0 # GitHub : https://github.com/Sleeper85/esphome-yambms @@ -68,7 +68,7 @@ substitutions: # | YamBMS Settings | # +--------------------------------------+ # Please read the cut-off charging logic README to understand how the YamBMS works - yambms_id: 'yambms_demo' # Must begin with a letter and cannot contain spaces + yambms_id: '1' # Number without spaces yambms_name: 'YamBMS Demo' # Prefix for YamBMS entities yambms_update_interval: '1s' # Input numbers can be displayed as a slider or an input box, options are 'slider' or 'box'. @@ -406,11 +406,14 @@ packages: # +------------------------------------------------------------------------------+ - # | >>> Config and Custom Local Packages + # | >>> Add your custom packages below # +------------------------------------------------------------------------------+ - # Local Packages intended for creating custom codes - # or sharing settings between several main.yaml - - # yambms_config: !include yambms_config.yaml + # Custom packages # yambms_custom: !include yambms_custom.yaml + +# +------------------------------------------------------------------------------+ +# | >>> Add your custom YAML below +# +----- -------------------------------------------------------------------------+ + +# Custom YAML diff --git a/YamBMS_LP_PVbrain2.yaml b/YamBMS_LP_PVbrain2.yaml index 99819db..ba5691f 100644 --- a/YamBMS_LP_PVbrain2.yaml +++ b/YamBMS_LP_PVbrain2.yaml @@ -1,4 +1,4 @@ -# Updated : 2026.03.24 +# Updated : 2026.06.27 # Version : 1.7.0 # GitHub : https://github.com/Sleeper85/esphome-yambms @@ -68,7 +68,7 @@ substitutions: # | YamBMS Settings | # +--------------------------------------+ # Please read the cut-off charging logic README to understand how the YamBMS works - yambms_id: 'yambms1' # Must begin with a letter and cannot contain spaces + yambms_id: '1' # Number without spaces yambms_name: 'YamBMS 1' # Prefix for YamBMS entities yambms_update_interval: '1s' # Input numbers can be displayed as a slider or an input box, options are 'slider' or 'box'. @@ -299,11 +299,14 @@ packages: # +------------------------------------------------------------------------------+ - # | >>> Config and Custom Local Packages + # | >>> Add your custom packages below # +------------------------------------------------------------------------------+ - # Local Packages intended for creating custom codes - # or sharing settings between several main.yaml - - # yambms_config: !include yambms_config.yaml + # Custom packages # yambms_custom: !include yambms_custom.yaml + +# +------------------------------------------------------------------------------+ +# | >>> Add your custom YAML below +# +----- -------------------------------------------------------------------------+ + +# Custom YAML diff --git a/YamBMS_Local_Packages_example.yaml b/YamBMS_Local_Packages_example.yaml index 594202f..ed3945a 100644 --- a/YamBMS_Local_Packages_example.yaml +++ b/YamBMS_Local_Packages_example.yaml @@ -1,4 +1,4 @@ -# Updated : 2026.03.24 +# Updated : 2026.06.27 # Version : 1.7.0 # GitHub : https://github.com/Sleeper85/esphome-yambms @@ -68,7 +68,7 @@ substitutions: # | YamBMS Settings | # +--------------------------------------+ # Please read the cut-off charging logic README to understand how the YamBMS works - yambms_id: 'yambms1' # Must begin with a letter and cannot contain spaces + yambms_id: '1' # Number without spaces yambms_name: 'YamBMS 1' # Prefix for YamBMS entities yambms_update_interval: '1s' # Input numbers can be displayed as a slider or an input box, options are 'slider' or 'box'. @@ -328,11 +328,14 @@ packages: # +------------------------------------------------------------------------------+ - # | >>> Config and Custom Local Packages + # | >>> Add your custom packages below # +------------------------------------------------------------------------------+ - # Local Packages intended for creating custom codes - # or sharing settings between several main.yaml - - # yambms_config: !include yambms_config.yaml + # Custom packages # yambms_custom: !include yambms_custom.yaml + +# +------------------------------------------------------------------------------+ +# | >>> Add your custom YAML below +# +----- -------------------------------------------------------------------------+ + +# Custom YAML diff --git a/YamBMS_RP_BMS_BASEN_RS485.yaml b/YamBMS_RP_BMS_BASEN_RS485.yaml index 7cd80b2..57a8c75 100644 --- a/YamBMS_RP_BMS_BASEN_RS485.yaml +++ b/YamBMS_RP_BMS_BASEN_RS485.yaml @@ -1,4 +1,4 @@ -# Updated : 2026.03.24 +# Updated : 2026.06.27 # Version : 1.7.0 # GitHub : https://github.com/Sleeper85/esphome-yambms @@ -68,7 +68,7 @@ substitutions: # | YamBMS Settings | # +--------------------------------------+ # Please read the cut-off charging logic README to understand how the YamBMS works - yambms_id: 'yambms1' # Must begin with a letter and cannot contain spaces + yambms_id: '1' # Number without spaces yambms_name: 'YamBMS 1' # Prefix for YamBMS entities yambms_update_interval: '1s' # Input numbers can be displayed as a slider or an input box, options are 'slider' or 'box'. @@ -347,11 +347,14 @@ packages: # +------------------------------------------------------------------------------+ - # | >>> Config and Custom Local Packages + # | >>> Add your custom packages below # +------------------------------------------------------------------------------+ - # Local Packages intended for creating custom codes - # or sharing settings between several main.yaml - - # yambms_config: !include yambms_config.yaml + # Custom packages # yambms_custom: !include yambms_custom.yaml + +# +------------------------------------------------------------------------------+ +# | >>> Add your custom YAML below +# +----- -------------------------------------------------------------------------+ + +# Custom YAML diff --git a/YamBMS_RP_BMS_DEYE_CAN.yaml b/YamBMS_RP_BMS_DEYE_CAN.yaml index 2558c23..f1c9b2b 100644 --- a/YamBMS_RP_BMS_DEYE_CAN.yaml +++ b/YamBMS_RP_BMS_DEYE_CAN.yaml @@ -1,4 +1,4 @@ -# Updated : 2026.03.24 +# Updated : 2026.06.27 # Version : 1.7.0 # GitHub : https://github.com/Sleeper85/esphome-yambms @@ -68,7 +68,7 @@ substitutions: # | YamBMS Settings | # +--------------------------------------+ # Please read the cut-off charging logic README to understand how the YamBMS works - yambms_id: 'yambms1' # Must begin with a letter and cannot contain spaces + yambms_id: '1' # Number without spaces yambms_name: 'YamBMS 1' # Prefix for YamBMS entities yambms_update_interval: '1s' # Input numbers can be displayed as a slider or an input box, options are 'slider' or 'box'. @@ -356,11 +356,14 @@ packages: # +------------------------------------------------------------------------------+ - # | >>> Config and Custom Local Packages + # | >>> Add your custom packages below # +------------------------------------------------------------------------------+ - # Local Packages intended for creating custom codes - # or sharing settings between several main.yaml - - # yambms_config: !include yambms_config.yaml + # Custom packages # yambms_custom: !include yambms_custom.yaml + +# +------------------------------------------------------------------------------+ +# | >>> Add your custom YAML below +# +----- -------------------------------------------------------------------------+ + +# Custom YAML diff --git a/YamBMS_RP_BMS_EG4_RS485.yaml b/YamBMS_RP_BMS_EG4_RS485.yaml index b0f54ee..8edd6f0 100644 --- a/YamBMS_RP_BMS_EG4_RS485.yaml +++ b/YamBMS_RP_BMS_EG4_RS485.yaml @@ -1,4 +1,4 @@ -# Updated : 2026.03.24 +# Updated : 2026.06.27 # Version : 1.7.0 # GitHub : https://github.com/Sleeper85/esphome-yambms @@ -68,7 +68,7 @@ substitutions: # | YamBMS Settings | # +--------------------------------------+ # Please read the cut-off charging logic README to understand how the YamBMS works - yambms_id: 'yambms1' # Must begin with a letter and cannot contain spaces + yambms_id: '1' # Number without spaces yambms_name: 'YamBMS 1' # Prefix for YamBMS entities yambms_update_interval: '1s' # Input numbers can be displayed as a slider or an input box, options are 'slider' or 'box'. @@ -353,11 +353,14 @@ packages: # +------------------------------------------------------------------------------+ - # | >>> Config and Custom Local Packages + # | >>> Add your custom packages below # +------------------------------------------------------------------------------+ - # Local Packages intended for creating custom codes - # or sharing settings between several main.yaml - - # yambms_config: !include yambms_config.yaml + # Custom packages # yambms_custom: !include yambms_custom.yaml + +# +------------------------------------------------------------------------------+ +# | >>> Add your custom YAML below +# +----- -------------------------------------------------------------------------+ + +# Custom YAML diff --git a/YamBMS_RP_BMS_Ecoworthy_RS485.yaml b/YamBMS_RP_BMS_Ecoworthy_RS485.yaml index 750c108..d9bfef5 100644 --- a/YamBMS_RP_BMS_Ecoworthy_RS485.yaml +++ b/YamBMS_RP_BMS_Ecoworthy_RS485.yaml @@ -1,4 +1,4 @@ -# Updated : 2026.03.24 +# Updated : 2026.06.27 # Version : 1.7.0 # GitHub : https://github.com/Sleeper85/esphome-yambms @@ -68,7 +68,7 @@ substitutions: # | YamBMS Settings | # +--------------------------------------+ # Please read the cut-off charging logic README to understand how the YamBMS works - yambms_id: 'yambms1' # Must begin with a letter and cannot contain spaces + yambms_id: '1' # Number without spaces yambms_name: 'YamBMS 1' # Prefix for YamBMS entities yambms_update_interval: '1s' # Input numbers can be displayed as a slider or an input box, options are 'slider' or 'box'. @@ -353,11 +353,14 @@ packages: # +------------------------------------------------------------------------------+ - # | >>> Config and Custom Local Packages + # | >>> Add your custom packages below # +------------------------------------------------------------------------------+ - # Local Packages intended for creating custom codes - # or sharing settings between several main.yaml - - # yambms_config: !include yambms_config.yaml + # Custom packages # yambms_custom: !include yambms_custom.yaml + +# +------------------------------------------------------------------------------+ +# | >>> Add your custom YAML below +# +----- -------------------------------------------------------------------------+ + +# Custom YAML diff --git a/YamBMS_RP_BMS_JBD.yaml b/YamBMS_RP_BMS_JBD.yaml index 1ac3ebe..b0d63b4 100644 --- a/YamBMS_RP_BMS_JBD.yaml +++ b/YamBMS_RP_BMS_JBD.yaml @@ -1,4 +1,4 @@ -# Updated : 2026.03.24 +# Updated : 2026.06.27 # Version : 1.7.0 # GitHub : https://github.com/Sleeper85/esphome-yambms @@ -68,7 +68,7 @@ substitutions: # | YamBMS Settings | # +--------------------------------------+ # Please read the cut-off charging logic README to understand how the YamBMS works - yambms_id: 'yambms1' # Must begin with a letter and cannot contain spaces + yambms_id: '1' # Number without spaces yambms_name: 'YamBMS 1' # Prefix for YamBMS entities yambms_update_interval: '1s' # Input numbers can be displayed as a slider or an input box, options are 'slider' or 'box'. @@ -363,11 +363,14 @@ packages: # +------------------------------------------------------------------------------+ - # | >>> Config and Custom Local Packages + # | >>> Add your custom packages below # +------------------------------------------------------------------------------+ - # Local Packages intended for creating custom codes - # or sharing settings between several main.yaml - - # yambms_config: !include yambms_config.yaml + # Custom packages # yambms_custom: !include yambms_custom.yaml + +# +------------------------------------------------------------------------------+ +# | >>> Add your custom YAML below +# +----- -------------------------------------------------------------------------+ + +# Custom YAML diff --git a/YamBMS_RP_BMS_JK-B_RS485_Modbus.yaml b/YamBMS_RP_BMS_JK-B_RS485_Modbus.yaml index b4e4f5a..c7152d5 100644 --- a/YamBMS_RP_BMS_JK-B_RS485_Modbus.yaml +++ b/YamBMS_RP_BMS_JK-B_RS485_Modbus.yaml @@ -1,4 +1,4 @@ -# Updated : 2026.03.24 +# Updated : 2026.06.27 # Version : 1.7.0 # GitHub : https://github.com/Sleeper85/esphome-yambms @@ -68,7 +68,7 @@ substitutions: # | YamBMS Settings | # +--------------------------------------+ # Please read the cut-off charging logic README to understand how the YamBMS works - yambms_id: 'yambms1' # Must begin with a letter and cannot contain spaces + yambms_id: '1' # Number without spaces yambms_name: 'YamBMS 1' # Prefix for YamBMS entities yambms_update_interval: '1s' # Input numbers can be displayed as a slider or an input box, options are 'slider' or 'box'. @@ -393,11 +393,14 @@ packages: # +------------------------------------------------------------------------------+ - # | >>> Config and Custom Local Packages + # | >>> Add your custom packages below # +------------------------------------------------------------------------------+ - # Local Packages intended for creating custom codes - # or sharing settings between several main.yaml - - # yambms_config: !include yambms_config.yaml + # Custom packages # yambms_custom: !include yambms_custom.yaml + +# +------------------------------------------------------------------------------+ +# | >>> Add your custom YAML below +# +----- -------------------------------------------------------------------------+ + +# Custom YAML diff --git a/YamBMS_RP_BMS_JK-PB_RS485_Modbus.yaml b/YamBMS_RP_BMS_JK-PB_RS485_Modbus.yaml index 92ceed7..b184ab8 100644 --- a/YamBMS_RP_BMS_JK-PB_RS485_Modbus.yaml +++ b/YamBMS_RP_BMS_JK-PB_RS485_Modbus.yaml @@ -1,4 +1,4 @@ -# Updated : 2026.03.24 +# Updated : 2026.06.27 # Version : 1.7.0 # GitHub : https://github.com/Sleeper85/esphome-yambms @@ -68,7 +68,7 @@ substitutions: # | YamBMS Settings | # +--------------------------------------+ # Please read the cut-off charging logic README to understand how the YamBMS works - yambms_id: 'yambms1' # Must begin with a letter and cannot contain spaces + yambms_id: '1' # Number without spaces yambms_name: 'YamBMS 1' # Prefix for YamBMS entities yambms_update_interval: '1s' # Input numbers can be displayed as a slider or an input box, options are 'slider' or 'box'. @@ -393,11 +393,14 @@ packages: # +------------------------------------------------------------------------------+ - # | >>> Config and Custom Local Packages + # | >>> Add your custom packages below # +------------------------------------------------------------------------------+ - # Local Packages intended for creating custom codes - # or sharing settings between several main.yaml - - # yambms_config: !include yambms_config.yaml + # Custom packages # yambms_custom: !include yambms_custom.yaml + +# +------------------------------------------------------------------------------+ +# | >>> Add your custom YAML below +# +----- -------------------------------------------------------------------------+ + +# Custom YAML diff --git a/YamBMS_RP_BMS_JK_BLE.yaml b/YamBMS_RP_BMS_JK_BLE.yaml index a6bec3c..127ad6a 100644 --- a/YamBMS_RP_BMS_JK_BLE.yaml +++ b/YamBMS_RP_BMS_JK_BLE.yaml @@ -1,4 +1,4 @@ -# Updated : 2026.03.24 +# Updated : 2026.06.27 # Version : 1.7.0 # GitHub : https://github.com/Sleeper85/esphome-yambms @@ -68,7 +68,7 @@ substitutions: # | YamBMS Settings | # +--------------------------------------+ # Please read the cut-off charging logic README to understand how the YamBMS works - yambms_id: 'yambms1' # Must begin with a letter and cannot contain spaces + yambms_id: '1' # Number without spaces yambms_name: 'YamBMS 1' # Prefix for YamBMS entities yambms_update_interval: '1s' # Input numbers can be displayed as a slider or an input box, options are 'slider' or 'box'. @@ -348,11 +348,14 @@ packages: # +------------------------------------------------------------------------------+ - # | >>> Config and Custom Local Packages + # | >>> Add your custom packages below # +------------------------------------------------------------------------------+ - # Local Packages intended for creating custom codes - # or sharing settings between several main.yaml - - # yambms_config: !include yambms_config.yaml + # Custom packages # yambms_custom: !include yambms_custom.yaml + +# +------------------------------------------------------------------------------+ +# | >>> Add your custom YAML below +# +----- -------------------------------------------------------------------------+ + +# Custom YAML diff --git a/YamBMS_RP_BMS_JK_UART_4G-GPS.yaml b/YamBMS_RP_BMS_JK_UART_4G-GPS.yaml index bde5617..64c3bee 100644 --- a/YamBMS_RP_BMS_JK_UART_4G-GPS.yaml +++ b/YamBMS_RP_BMS_JK_UART_4G-GPS.yaml @@ -1,4 +1,4 @@ -# Updated : 2026.03.24 +# Updated : 2026.06.27 # Version : 1.7.0 # GitHub : https://github.com/Sleeper85/esphome-yambms @@ -68,7 +68,7 @@ substitutions: # | YamBMS Settings | # +--------------------------------------+ # Please read the cut-off charging logic README to understand how the YamBMS works - yambms_id: 'yambms1' # Must begin with a letter and cannot contain spaces + yambms_id: '1' # Number without spaces yambms_name: 'YamBMS 1' # Prefix for YamBMS entities yambms_update_interval: '1s' # Input numbers can be displayed as a slider or an input box, options are 'slider' or 'box'. @@ -346,11 +346,14 @@ packages: # +------------------------------------------------------------------------------+ - # | >>> Config and Custom Local Packages + # | >>> Add your custom packages below # +------------------------------------------------------------------------------+ - # Local Packages intended for creating custom codes - # or sharing settings between several main.yaml - - # yambms_config: !include yambms_config.yaml + # Custom packages # yambms_custom: !include yambms_custom.yaml + +# +------------------------------------------------------------------------------+ +# | >>> Add your custom YAML below +# +----- -------------------------------------------------------------------------+ + +# Custom YAML diff --git a/YamBMS_RP_BMS_PACE_RS485_Modbus.yaml b/YamBMS_RP_BMS_PACE_RS485_Modbus.yaml index 2d59fcf..8cd4dd6 100644 --- a/YamBMS_RP_BMS_PACE_RS485_Modbus.yaml +++ b/YamBMS_RP_BMS_PACE_RS485_Modbus.yaml @@ -1,4 +1,4 @@ -# Updated : 2026.03.24 +# Updated : 2026.06.27 # Version : 1.7.0 # GitHub : https://github.com/Sleeper85/esphome-yambms @@ -68,7 +68,7 @@ substitutions: # | YamBMS Settings | # +--------------------------------------+ # Please read the cut-off charging logic README to understand how the YamBMS works - yambms_id: 'yambms1' # Must begin with a letter and cannot contain spaces + yambms_id: '1' # Number without spaces yambms_name: 'YamBMS 1' # Prefix for YamBMS entities yambms_update_interval: '1s' # Input numbers can be displayed as a slider or an input box, options are 'slider' or 'box'. @@ -343,11 +343,14 @@ packages: # +------------------------------------------------------------------------------+ - # | >>> Config and Custom Local Packages + # | >>> Add your custom packages below # +------------------------------------------------------------------------------+ - # Local Packages intended for creating custom codes - # or sharing settings between several main.yaml - - # yambms_config: !include yambms_config.yaml + # Custom packages # yambms_custom: !include yambms_custom.yaml + +# +------------------------------------------------------------------------------+ +# | >>> Add your custom YAML below +# +----- -------------------------------------------------------------------------+ + +# Custom YAML diff --git a/YamBMS_RP_BMS_SEPLOS_V1_V2_RS485_Modbus.yaml b/YamBMS_RP_BMS_SEPLOS_V1_V2_RS485_Modbus.yaml index 016e240..781c85d 100644 --- a/YamBMS_RP_BMS_SEPLOS_V1_V2_RS485_Modbus.yaml +++ b/YamBMS_RP_BMS_SEPLOS_V1_V2_RS485_Modbus.yaml @@ -1,4 +1,4 @@ -# Updated : 2026.03.24 +# Updated : 2026.06.27 # Version : 1.7.0 # GitHub : https://github.com/Sleeper85/esphome-yambms @@ -68,7 +68,7 @@ substitutions: # | YamBMS Settings | # +--------------------------------------+ # Please read the cut-off charging logic README to understand how the YamBMS works - yambms_id: 'yambms1' # Must begin with a letter and cannot contain spaces + yambms_id: '1' # Number without spaces yambms_name: 'YamBMS 1' # Prefix for YamBMS entities yambms_update_interval: '1s' # Input numbers can be displayed as a slider or an input box, options are 'slider' or 'box'. @@ -379,11 +379,14 @@ packages: # +------------------------------------------------------------------------------+ - # | >>> Config and Custom Local Packages + # | >>> Add your custom packages below # +------------------------------------------------------------------------------+ - # Local Packages intended for creating custom codes - # or sharing settings between several main.yaml - - # yambms_config: !include yambms_config.yaml + # Custom packages # yambms_custom: !include yambms_custom.yaml + +# +------------------------------------------------------------------------------+ +# | >>> Add your custom YAML below +# +----- -------------------------------------------------------------------------+ + +# Custom YAML diff --git a/YamBMS_RP_BMS_SEPLOS_V3_RS485_Modbus_sniffer.yaml b/YamBMS_RP_BMS_SEPLOS_V3_RS485_Modbus_sniffer.yaml index 3ec5105..7d1e65f 100644 --- a/YamBMS_RP_BMS_SEPLOS_V3_RS485_Modbus_sniffer.yaml +++ b/YamBMS_RP_BMS_SEPLOS_V3_RS485_Modbus_sniffer.yaml @@ -1,4 +1,4 @@ -# Updated : 2026.03.24 +# Updated : 2026.06.27 # Version : 1.7.0 # GitHub : https://github.com/Sleeper85/esphome-yambms @@ -68,7 +68,7 @@ substitutions: # | YamBMS Settings | # +--------------------------------------+ # Please read the cut-off charging logic README to understand how the YamBMS works - yambms_id: 'yambms1' # Must begin with a letter and cannot contain spaces + yambms_id: '1' # Number without spaces yambms_name: 'YamBMS 1' # Prefix for YamBMS entities yambms_update_interval: '1s' # Input numbers can be displayed as a slider or an input box, options are 'slider' or 'box'. @@ -378,11 +378,14 @@ packages: # +------------------------------------------------------------------------------+ - # | >>> Config and Custom Local Packages + # | >>> Add your custom packages below # +------------------------------------------------------------------------------+ - # Local Packages intended for creating custom codes - # or sharing settings between several main.yaml - - # yambms_config: !include yambms_config.yaml + # Custom packages # yambms_custom: !include yambms_custom.yaml + +# +------------------------------------------------------------------------------+ +# | >>> Add your custom YAML below +# +----- -------------------------------------------------------------------------+ + +# Custom YAML diff --git a/YamBMS_RP_Balancer.yaml b/YamBMS_RP_Balancer.yaml index 47353f1..f0682a7 100644 --- a/YamBMS_RP_Balancer.yaml +++ b/YamBMS_RP_Balancer.yaml @@ -1,4 +1,4 @@ -# Updated : 2026.03.24 +# Updated : 2026.06.27 # Version : 1.7.0 # GitHub : https://github.com/Sleeper85/esphome-yambms @@ -68,7 +68,7 @@ substitutions: # | YamBMS Settings | # +--------------------------------------+ # Please read the cut-off charging logic README to understand how the YamBMS works - yambms_id: 'yambms1' # Must begin with a letter and cannot contain spaces + yambms_id: '1' # Number without spaces yambms_name: 'YamBMS 1' # Prefix for YamBMS entities yambms_update_interval: '1s' # Input numbers can be displayed as a slider or an input box, options are 'slider' or 'box'. @@ -361,11 +361,14 @@ packages: # +------------------------------------------------------------------------------+ - # | >>> Config and Custom Local Packages + # | >>> Add your custom packages below # +------------------------------------------------------------------------------+ - # Local Packages intended for creating custom codes - # or sharing settings between several main.yaml - - # yambms_config: !include yambms_config.yaml + # Custom packages # yambms_custom: !include yambms_custom.yaml + +# +------------------------------------------------------------------------------+ +# | >>> Add your custom YAML below +# +----- -------------------------------------------------------------------------+ + +# Custom YAML diff --git a/YamBMS_RP_DEMO.yaml b/YamBMS_RP_DEMO.yaml index 415340f..c84dec7 100644 --- a/YamBMS_RP_DEMO.yaml +++ b/YamBMS_RP_DEMO.yaml @@ -1,4 +1,4 @@ -# Updated : 2026.03.24 +# Updated : 2026.06.27 # Version : 1.7.0 # GitHub : https://github.com/Sleeper85/esphome-yambms @@ -68,7 +68,7 @@ substitutions: # | YamBMS Settings | # +--------------------------------------+ # Please read the cut-off charging logic README to understand how the YamBMS works - yambms_id: 'yambms_demo' # Must begin with a letter and cannot contain spaces + yambms_id: '1' # Number without spaces yambms_name: 'YamBMS Demo' # Prefix for YamBMS entities yambms_update_interval: '1s' # Input numbers can be displayed as a slider or an input box, options are 'slider' or 'box'. @@ -393,11 +393,14 @@ packages: # +------------------------------------------------------------------------------+ - # | >>> Config and Custom Local Packages + # | >>> Add your custom packages below # +------------------------------------------------------------------------------+ - # Local Packages intended for creating custom codes - # or sharing settings between several main.yaml - - # yambms_config: !include yambms_config.yaml + # Custom packages # yambms_custom: !include yambms_custom.yaml + +# +------------------------------------------------------------------------------+ +# | >>> Add your custom YAML below +# +----- -------------------------------------------------------------------------+ + +# Custom YAML diff --git a/YamBMS_RP_Ethernet_board.yaml b/YamBMS_RP_Ethernet_board.yaml index 7a8fd56..2065b78 100644 --- a/YamBMS_RP_Ethernet_board.yaml +++ b/YamBMS_RP_Ethernet_board.yaml @@ -1,4 +1,4 @@ -# Updated : 2026.03.24 +# Updated : 2026.06.27 # Version : 1.7.0 # GitHub : https://github.com/Sleeper85/esphome-yambms @@ -68,7 +68,7 @@ substitutions: # | YamBMS Settings | # +--------------------------------------+ # Please read the cut-off charging logic README to understand how the YamBMS works - yambms_id: 'yambms1' # Must begin with a letter and cannot contain spaces + yambms_id: '1' # Number without spaces yambms_name: 'YamBMS 1' # Prefix for YamBMS entities yambms_update_interval: '1s' # Input numbers can be displayed as a slider or an input box, options are 'slider' or 'box'. @@ -291,11 +291,14 @@ packages: # +------------------------------------------------------------------------------+ - # | >>> Config and Custom Local Packages + # | >>> Add your custom packages below # +------------------------------------------------------------------------------+ - # Local Packages intended for creating custom codes - # or sharing settings between several main.yaml - - # yambms_config: !include yambms_config.yaml + # Custom packages # yambms_custom: !include yambms_custom.yaml + +# +------------------------------------------------------------------------------+ +# | >>> Add your custom YAML below +# +----- -------------------------------------------------------------------------+ + +# Custom YAML diff --git a/YamBMS_RP_HA_Display.yaml b/YamBMS_RP_HA_Display.yaml index 08939f1..a24555c 100644 --- a/YamBMS_RP_HA_Display.yaml +++ b/YamBMS_RP_HA_Display.yaml @@ -1,4 +1,4 @@ -# Updated : 2026.03.23 +# Updated : 2026.06.27 # Version : 1.7.0 # GitHub : https://github.com/Sleeper85/esphome-yambms @@ -152,7 +152,14 @@ packages: # +------------------------------------------------------------------------------+ - # | >>> Config and Custom Local Packages + # | >>> Add your custom packages below # +------------------------------------------------------------------------------+ - # Add your packages or YAML below \ No newline at end of file + # Custom packages + # yambms_custom: !include yambms_custom.yaml + +# +------------------------------------------------------------------------------+ +# | >>> Add your custom YAML below +# +----- -------------------------------------------------------------------------+ + +# Custom YAML diff --git a/YamBMS_RP_PVbrain2.yaml b/YamBMS_RP_PVbrain2.yaml index 043792b..1dd20e0 100644 --- a/YamBMS_RP_PVbrain2.yaml +++ b/YamBMS_RP_PVbrain2.yaml @@ -1,4 +1,4 @@ -# Updated : 2026.03.24 +# Updated : 2026.06.27 # Version : 1.7.0 # GitHub : https://github.com/Sleeper85/esphome-yambms @@ -68,7 +68,7 @@ substitutions: # | YamBMS Settings | # +--------------------------------------+ # Please read the cut-off charging logic README to understand how the YamBMS works - yambms_id: 'yambms1' # Must begin with a letter and cannot contain spaces + yambms_id: '1' # Number without spaces yambms_name: 'YamBMS 1' # Prefix for YamBMS entities yambms_update_interval: '1s' # Input numbers can be displayed as a slider or an input box, options are 'slider' or 'box'. @@ -302,11 +302,14 @@ packages: # +------------------------------------------------------------------------------+ - # | >>> Config and Custom Local Packages + # | >>> Add your custom packages below # +------------------------------------------------------------------------------+ - # Local Packages intended for creating custom codes - # or sharing settings between several main.yaml - - # yambms_config: !include yambms_config.yaml + # Custom packages # yambms_custom: !include yambms_custom.yaml + +# +------------------------------------------------------------------------------+ +# | >>> Add your custom YAML below +# +----- -------------------------------------------------------------------------+ + +# Custom YAML diff --git a/YamBMS_Remote_Packages_example.yaml b/YamBMS_Remote_Packages_example.yaml index 0400f6b..d630a0c 100644 --- a/YamBMS_Remote_Packages_example.yaml +++ b/YamBMS_Remote_Packages_example.yaml @@ -1,4 +1,4 @@ -# Updated : 2026.03.24 +# Updated : 2026.06.27 # Version : 1.7.0 # GitHub : https://github.com/Sleeper85/esphome-yambms @@ -68,7 +68,7 @@ substitutions: # | YamBMS Settings | # +--------------------------------------+ # Please read the cut-off charging logic README to understand how the YamBMS works - yambms_id: 'yambms1' # Must begin with a letter and cannot contain spaces + yambms_id: '1' # Number without spaces yambms_name: 'YamBMS 1' # Prefix for YamBMS entities yambms_update_interval: '1s' # Input numbers can be displayed as a slider or an input box, options are 'slider' or 'box'. @@ -322,11 +322,14 @@ packages: # +------------------------------------------------------------------------------+ - # | >>> Config and Custom Local Packages + # | >>> Add your custom packages below # +------------------------------------------------------------------------------+ - # Local Packages intended for creating custom codes - # or sharing settings between several main.yaml - - # yambms_config: !include yambms_config.yaml + # Custom packages # yambms_custom: !include yambms_custom.yaml + +# +------------------------------------------------------------------------------+ +# | >>> Add your custom YAML below +# +----- -------------------------------------------------------------------------+ + +# Custom YAML diff --git a/YamBMS_Remote_Packages_example_dev_branch.yaml b/YamBMS_Remote_Packages_example_dev_branch.yaml index 2c3c49a..684bc42 100644 --- a/YamBMS_Remote_Packages_example_dev_branch.yaml +++ b/YamBMS_Remote_Packages_example_dev_branch.yaml @@ -1,4 +1,4 @@ -# Updated : 2026.03.24 +# Updated : 2026.06.27 # Version : 1.7.0 # GitHub : https://github.com/Sleeper85/esphome-yambms @@ -68,7 +68,7 @@ substitutions: # | YamBMS Settings | # +--------------------------------------+ # Please read the cut-off charging logic README to understand how the YamBMS works - yambms_id: 'yambms1' # Must begin with a letter and cannot contain spaces + yambms_id: '1' # Number without spaces yambms_name: 'YamBMS 1' # Prefix for YamBMS entities yambms_update_interval: '1s' # Input numbers can be displayed as a slider or an input box, options are 'slider' or 'box'. @@ -322,11 +322,14 @@ packages: # +------------------------------------------------------------------------------+ - # | >>> Config and Custom Local Packages + # | >>> Add your custom packages below # +------------------------------------------------------------------------------+ - # Local Packages intended for creating custom codes - # or sharing settings between several main.yaml - - # yambms_config: !include yambms_config.yaml + # Custom packages # yambms_custom: !include yambms_custom.yaml + +# +------------------------------------------------------------------------------+ +# | >>> Add your custom YAML below +# +----- -------------------------------------------------------------------------+ + +# Custom YAML diff --git a/packages/bms/bms_combine.yaml b/packages/bms/bms_combine.yaml index f607379..1535ef8 100644 --- a/packages/bms/bms_combine.yaml +++ b/packages/bms/bms_combine.yaml @@ -1,4 +1,4 @@ -# Updated : 2026.02.02 +# Updated : 2026.06.27 # Version : 1.7.0 # GitHub : https://github.com/Sleeper85/esphome-yambms @@ -31,7 +31,7 @@ esphome: - priority: 600 then: # Shunt counter (total) - - lambda: id(${yambms_id}_var_bms_counter) += 1; + - lambda: id(yambms${yambms_id}_var_bms_counter) += 1; binary_sensor: # Indicates whether the BMS can be combined @@ -81,7 +81,7 @@ interval: // | STEP 1 - BMS combiner | // +-----------------------------------------------+ // BMS number to combine ? - if (id(${yambms_id}_var_to_combine_bms_number) == ${bms_id}) + if (id(yambms${yambms_id}_var_to_combine_bms_number) == ${bms_id}) { // The BMS can be combined ? if (id(bms${bms_id}_can_be_combined).state) @@ -92,7 +92,7 @@ interval: if (id(bms${bms_id}_combined_once) == false) { - id(${yambms_id}_var_total_installed_battery_capacity) += id(bms${bms_id}_battery_capacity).state; + id(yambms${yambms_id}_var_total_installed_battery_capacity) += id(bms${bms_id}_battery_capacity).state; id(bms${bms_id}_combined_once) = true; } @@ -103,7 +103,7 @@ interval: if (id(bms${bms_id}_combined) == false) { // To combine bms counter - id(${yambms_id}_var_to_combine_bms_counter) += 1; + id(yambms${yambms_id}_var_to_combine_bms_counter) += 1; // Combined id(bms${bms_id}_combined) = true; @@ -114,113 +114,113 @@ interval: // +-----------------------------------------------+ // Online bitmask - id(${yambms_id}_var_bms_online_bitmask) |= (1 << (${bms_id} - 1)); + id(yambms${yambms_id}_var_bms_online_bitmask) |= (1 << (${bms_id} - 1)); // Remember that we've seen this BMS online - id(${yambms_id}_var_bms_seen_online_bitmask) |= id(${yambms_id}_var_bms_online_bitmask); + id(yambms${yambms_id}_var_bms_seen_online_bitmask) |= id(yambms${yambms_id}_var_bms_online_bitmask); // YamBMS Errors Bitmask (16bit) if (id(bms${bms_id}_yambms_errors_bitmask).state > 0) { uint16_t errors_bitmask = id(bms${bms_id}_yambms_errors_bitmask).state; // errors_bitmask (16bit) - id(${yambms_id}_var_errors_bitmask) |= errors_bitmask; // OR bitwise - id(${yambms_id}_var_errors_bitmask_counter) += 1; // errors_bitmask_counter + id(yambms${yambms_id}_var_errors_bitmask) |= errors_bitmask; // OR bitwise + id(yambms${yambms_id}_var_errors_bitmask_counter) += 1; // errors_bitmask_counter } if (id(bms${bms_id}_charging_allowed).state) { // TOTAL charging_allowed_counter - id(${yambms_id}_var_charging_allowed_counter) += 1; + id(yambms${yambms_id}_var_charging_allowed_counter) += 1; // TOTAL max_charge_current - id(${yambms_id}_var_total_max_charge_current) += id(bms${bms_id}_max_charge_current).state; + id(yambms${yambms_id}_var_total_max_charge_current) += id(bms${bms_id}_max_charge_current).state; } // TOTAL bms_blocking_charge_counter - else id(${yambms_id}_var_bms_blocking_charge_counter) += 1; + else id(yambms${yambms_id}_var_bms_blocking_charge_counter) += 1; if (id(bms${bms_id}_discharging_allowed).state) { // TOTAL discharging_allowed_counter - id(${yambms_id}_var_discharging_allowed_counter) += 1; + id(yambms${yambms_id}_var_discharging_allowed_counter) += 1; // TOTAL max_discharge_current - id(${yambms_id}_var_total_max_discharge_current) += id(bms${bms_id}_max_discharge_current).state; + id(yambms${yambms_id}_var_total_max_discharge_current) += id(bms${bms_id}_max_discharge_current).state; // Limit to max. discharge current - if(id(${yambms_id}_var_total_max_discharge_current) > ${yambms_max_requested_discharge_current}) + if(id(yambms${yambms_id}_var_total_max_discharge_current) > ${yambms_max_requested_discharge_current}) { - id(${yambms_id}_var_total_max_discharge_current) = ${yambms_max_requested_discharge_current}; + id(yambms${yambms_id}_var_total_max_discharge_current) = ${yambms_max_requested_discharge_current}; } } // TOTAL bms_blocking_discharge_counter - else id(${yambms_id}_var_bms_blocking_discharge_counter) += 1; + else id(yambms${yambms_id}_var_bms_blocking_discharge_counter) += 1; // TOTAL total_voltage - id(${yambms_id}_var_bms_total_voltage) += id(bms${bms_id}_total_voltage).state; + id(yambms${yambms_id}_var_bms_total_voltage) += id(bms${bms_id}_total_voltage).state; // TOTAL current - id(${yambms_id}_var_bms_total_current) += id(bms${bms_id}_current).state; + id(yambms${yambms_id}_var_bms_total_current) += id(bms${bms_id}_current).state; // TOTAL power - id(${yambms_id}_var_bms_total_power) += id(bms${bms_id}_power).state; + id(yambms${yambms_id}_var_bms_total_power) += id(bms${bms_id}_power).state; // TOTAL battery_capacity - id(${yambms_id}_var_total_battery_capacity) += id(bms${bms_id}_battery_capacity).state; + id(yambms${yambms_id}_var_total_battery_capacity) += id(bms${bms_id}_battery_capacity).state; // TOTAL battery_capacity_remaining - id(${yambms_id}_var_total_battery_capacity_remaining) += id(bms${bms_id}_battery_capacity_remaining).state; + id(yambms${yambms_id}_var_total_battery_capacity_remaining) += id(bms${bms_id}_battery_capacity_remaining).state; // TOTAL SoC - // id(${yambms_id}_var_bms_total_soc) += id(bms${bms_id}_battery_soc).state; + // id(yambms${yambms_id}_var_bms_total_soc) += id(bms${bms_id}_battery_soc).state; // TOTAL SoH - id(${yambms_id}_var_bms_total_soh) += id(bms${bms_id}_battery_soh).state; + id(yambms${yambms_id}_var_bms_total_soh) += id(bms${bms_id}_battery_soh).state; // TOTAL charging_cycles - id(${yambms_id}_var_total_charging_cycles) += id(bms${bms_id}_charging_cycles).state; + id(yambms${yambms_id}_var_total_charging_cycles) += id(bms${bms_id}_charging_cycles).state; // TOTAL equalizing_counter - if (id(bms${bms_id}_equalizing).state) id(${yambms_id}_var_equalizing_counter) += 1; + if (id(bms${bms_id}_equalizing).state) id(yambms${yambms_id}_var_equalizing_counter) += 1; // MIN/MAX values // MAX balance_trigger_voltage - if (id(bms${bms_id}_balance_trigger_voltage).state > id(${yambms_id}_var_max_balance_trigger_voltage)) - id(${yambms_id}_var_max_balance_trigger_voltage) = id(bms${bms_id}_balance_trigger_voltage).state; + if (id(bms${bms_id}_balance_trigger_voltage).state > id(yambms${yambms_id}_var_max_balance_trigger_voltage)) + id(yambms${yambms_id}_var_max_balance_trigger_voltage) = id(bms${bms_id}_balance_trigger_voltage).state; // MIN min_cell_voltage // MIN min_voltage_cell (cell number) - if (id(bms${bms_id}_min_cell_voltage).state < id(${yambms_id}_var_min_cell_voltage)) + if (id(bms${bms_id}_min_cell_voltage).state < id(yambms${yambms_id}_var_min_cell_voltage)) { - id(${yambms_id}_var_min_cell_voltage) = id(bms${bms_id}_min_cell_voltage).state; - id(${yambms_id}_var_min_voltage_cell) = id(bms${bms_id}_min_voltage_cell).state + (${bms_id} * 100); + id(yambms${yambms_id}_var_min_cell_voltage) = id(bms${bms_id}_min_cell_voltage).state; + id(yambms${yambms_id}_var_min_voltage_cell) = id(bms${bms_id}_min_voltage_cell).state + (${bms_id} * 100); } // MAX max_cell_voltage // MAX max_voltage_cell (cell number) - if (id(bms${bms_id}_max_cell_voltage).state > id(${yambms_id}_var_max_cell_voltage)) + if (id(bms${bms_id}_max_cell_voltage).state > id(yambms${yambms_id}_var_max_cell_voltage)) { - id(${yambms_id}_var_max_cell_voltage) = id(bms${bms_id}_max_cell_voltage).state; - id(${yambms_id}_var_max_voltage_cell) = id(bms${bms_id}_max_voltage_cell).state + (${bms_id} * 100); + id(yambms${yambms_id}_var_max_cell_voltage) = id(bms${bms_id}_max_cell_voltage).state; + id(yambms${yambms_id}_var_max_voltage_cell) = id(bms${bms_id}_max_voltage_cell).state + (${bms_id} * 100); } // MIN cell_ovp - if (id(bms${bms_id}_cell_ovp).state < id(${yambms_id}_var_min_cell_ovp)) - id(${yambms_id}_var_min_cell_ovp) = id(bms${bms_id}_cell_ovp).state; + if (id(bms${bms_id}_cell_ovp).state < id(yambms${yambms_id}_var_min_cell_ovp)) + id(yambms${yambms_id}_var_min_cell_ovp) = id(bms${bms_id}_cell_ovp).state; // MAX cell_uvp - if (id(bms${bms_id}_cell_uvp).state > id(${yambms_id}_var_max_cell_uvp)) - id(${yambms_id}_var_max_cell_uvp) = id(bms${bms_id}_cell_uvp).state; + if (id(bms${bms_id}_cell_uvp).state > id(yambms${yambms_id}_var_max_cell_uvp)) + id(yambms${yambms_id}_var_max_cell_uvp) = id(bms${bms_id}_cell_uvp).state; // MIN temperature // MIN temperature_sensor - if (id(bms${bms_id}_min_temperature).state < id(${yambms_id}_var_min_temperature)) + if (id(bms${bms_id}_min_temperature).state < id(yambms${yambms_id}_var_min_temperature)) { - id(${yambms_id}_var_min_temperature) = id(bms${bms_id}_min_temperature).state; - id(${yambms_id}_var_min_temperature_sensor) = id(bms${bms_id}_min_temperature_sensor).state; + id(yambms${yambms_id}_var_min_temperature) = id(bms${bms_id}_min_temperature).state; + id(yambms${yambms_id}_var_min_temperature_sensor) = id(bms${bms_id}_min_temperature_sensor).state; } // MAX temperature // MAX temperature_sensor - if (id(bms${bms_id}_max_temperature).state > id(${yambms_id}_var_max_temperature)) + if (id(bms${bms_id}_max_temperature).state > id(yambms${yambms_id}_var_max_temperature)) { - id(${yambms_id}_var_max_temperature) = id(bms${bms_id}_max_temperature).state; - id(${yambms_id}_var_max_temperature_sensor) = id(bms${bms_id}_max_temperature_sensor).state; + id(yambms${yambms_id}_var_max_temperature) = id(bms${bms_id}_max_temperature).state; + id(yambms${yambms_id}_var_max_temperature_sensor) = id(bms${bms_id}_max_temperature_sensor).state; } } @@ -230,15 +230,15 @@ interval: else if (id(bms${bms_id}_combined) == true) { // To combine bms counter - id(${yambms_id}_var_to_combine_bms_counter) -= 1; + id(yambms${yambms_id}_var_to_combine_bms_counter) -= 1; // Uncombined id(bms${bms_id}_combined) = false; // Remove from bitmask - id(${yambms_id}_var_bms_online_bitmask) &= ~(1 << (${bms_id} - 1)); + id(yambms${yambms_id}_var_bms_online_bitmask) &= ~(1 << (${bms_id} - 1)); } // Increment the counter for next BMS processing - id(${yambms_id}_var_to_combine_bms_number)++; + id(yambms${yambms_id}_var_to_combine_bms_number)++; } diff --git a/packages/shunt/shunt_combine.yaml b/packages/shunt/shunt_combine.yaml index 5ce3040..4f32522 100644 --- a/packages/shunt/shunt_combine.yaml +++ b/packages/shunt/shunt_combine.yaml @@ -1,4 +1,4 @@ -# Updated : 2026.02.01 +# Updated : 2026.06.27 # Version : 1.7.0 # GitHub : https://github.com/Sleeper85/esphome-yambms @@ -37,7 +37,7 @@ esphome: - priority: 600 then: # Shunt counter (total) - - lambda: id(${yambms_id}_var_shunt_counter) += 1; + - lambda: id(yambms${yambms_id}_var_shunt_counter) += 1; switch: # Combine enable/disable Switch @@ -89,7 +89,7 @@ interval: // | STEP 1 - Shunt combiner | // +-----------------------------------------------+ // Shunt number to combine ? - if (id(${yambms_id}_var_to_combine_shunt_number) == ${shunt_id}) + if (id(yambms${yambms_id}_var_to_combine_shunt_number) == ${shunt_id}) { // The Shunt can be combined ? if (id(shunt${shunt_id}_can_be_combined).state) @@ -103,13 +103,13 @@ interval: if (!bms_id) continue; // Ignore BMS that we've not seen online yet - if ((id(${yambms_id}_var_bms_seen_online_bitmask) & (1 << (bms_id - 1))) == 0) + if ((id(yambms${yambms_id}_var_bms_seen_online_bitmask) & (1 << (bms_id - 1))) == 0) { continue; } // Check if BMS is online - if ((id(${yambms_id}_var_bms_online_bitmask) & (1 << (bms_id - 1))) == 0) + if ((id(yambms${yambms_id}_var_bms_online_bitmask) & (1 << (bms_id - 1))) == 0) { bms_offline = bms_id; break; @@ -129,10 +129,10 @@ interval: if (id(shunt${shunt_id}_combined) == false) { // To combine shunt counter - id(${yambms_id}_var_to_combine_shunt_counter) += 1; + id(yambms${yambms_id}_var_to_combine_shunt_counter) += 1; // Shunt use (replace BMS infos) - id(${yambms_id}_var_shunt_use) = true; + id(yambms${yambms_id}_var_shunt_use) = true; // Combined id(shunt${shunt_id}_combined) = true; @@ -143,13 +143,13 @@ interval: // +-----------------------------------------------+ // TOTAL voltage - id(${yambms_id}_var_shunt_total_voltage) += id(shunt${shunt_id}_voltage).state; + id(yambms${yambms_id}_var_shunt_total_voltage) += id(shunt${shunt_id}_voltage).state; // TOTAL current - id(${yambms_id}_var_shunt_total_current) += id(shunt${shunt_id}_current).state; + id(yambms${yambms_id}_var_shunt_total_current) += id(shunt${shunt_id}_current).state; // TOTAL power - id(${yambms_id}_var_shunt_total_power) += id(shunt${shunt_id}_power).state; + id(yambms${yambms_id}_var_shunt_total_power) += id(shunt${shunt_id}_power).state; // TOTAL soc - id(${yambms_id}_var_shunt_total_soc) += id(shunt${shunt_id}_soc).state; + id(yambms${yambms_id}_var_shunt_total_soc) += id(shunt${shunt_id}_soc).state; } @@ -159,15 +159,15 @@ interval: else if (id(shunt${shunt_id}_combined) == true) { // To combine shunt counter - id(${yambms_id}_var_to_combine_shunt_counter) -= 1; + id(yambms${yambms_id}_var_to_combine_shunt_counter) -= 1; // Shunt use (replace BMS infos) - if (id(${yambms_id}_var_to_combine_shunt_counter) == 0) id(${yambms_id}_var_shunt_use) = false; + if (id(yambms${yambms_id}_var_to_combine_shunt_counter) == 0) id(yambms${yambms_id}_var_shunt_use) = false; // Uncombined id(shunt${shunt_id}_combined) = false; } // Increment the counter for next Shunt processing - id(${yambms_id}_var_to_combine_shunt_number)++; + id(yambms${yambms_id}_var_to_combine_shunt_number)++; } \ No newline at end of file diff --git a/packages/yambms/yambms_auto_ccl.yaml b/packages/yambms/yambms_auto_ccl.yaml index b3e64f1..d94a928 100644 --- a/packages/yambms/yambms_auto_ccl.yaml +++ b/packages/yambms/yambms_auto_ccl.yaml @@ -1,5 +1,5 @@ -# Updated : 2026.03.23 -# Version : 1.3.2 +# Updated : 2026.06.27 +# Version : 1.3.3 # GitHub : https://github.com/Sleeper85/esphome-yambms # YamBMS ( Yet another multi-BMS Merging Solution ) @@ -22,7 +22,7 @@ esphome: - priority: -100.0 then: - lambda: |- - id(${yambms_id}_var_auto_ccl_functions_count)++; + id(yambms${yambms_id}_var_auto_ccl_functions_count)++; substitutions: # +--------------------------------------+ @@ -41,8 +41,8 @@ substitutions: switch: - platform: template name: "Automatic Charge Current" - id: ${yambms_id}_switch_auto_ccl - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_switch_auto_ccl + device_id: yambms_yambms${yambms_id} restore_mode: RESTORE_DEFAULT_OFF optimistic: true entity_category: config @@ -54,8 +54,8 @@ interval: # | Auto Charge Current Limit | # +------------------------------------------+ - lambda: |- - int cc_step = id(${yambms_id}_var_charge_current_step); - if (cc_step >= 1 && cc_step < id(${yambms_id}_var_auto_ccl_functions_count) + 1) + int cc_step = id(yambms${yambms_id}_var_charge_current_step); + if (cc_step >= 1 && cc_step < id(yambms${yambms_id}_var_auto_ccl_functions_count) + 1) { ESP_LOGD("yambms_debug", "Entering Auto CCL..."); @@ -64,23 +64,23 @@ interval: static bool is_initialized = false; // Configuration - float max_current = id(${yambms_id}_max_charge_current).state; - auto& output_id = id(${yambms_id}_var_auto_ccl); + float max_current = id(yambms${yambms_id}_max_charge_current).state; + auto& output_id = id(yambms${yambms_id}_var_auto_ccl); float alpha = 0.15f; float min_amp_increase_step = 1.0f; // Define raw inputs - float max_cell_v = id(${yambms_id}_max_cell_voltage).state; - float cell_count = id(${yambms_id}_cell_count).state; - float cell_ovp_v = id(${yambms_id}_cell_ovp).state; - float bulk_v = id(${yambms_id}_bulk_voltage).state; - float float_v = id(${yambms_id}_float_voltage).state; + float max_cell_v = id(yambms${yambms_id}_max_cell_voltage).state; + float cell_count = id(yambms${yambms_id}_cell_count).state; + float cell_ovp_v = id(yambms${yambms_id}_cell_ovp).state; + float bulk_v = id(yambms${yambms_id}_bulk_voltage).state; + float float_v = id(yambms${yambms_id}_float_voltage).state; // Exit if critical data is missing if (isnan(max_current) || isnan(max_cell_v) || isnan(cell_count) || isnan(cell_ovp_v) || isnan(bulk_v) || isnan(float_v) || cell_count <= 0.0f) { output_id = 0.0f; - id(${yambms_id}_var_charge_current_step)++; + id(yambms${yambms_id}_var_charge_current_step)++; return; } @@ -92,7 +92,7 @@ interval: float delta = 0.0f; // Only calculate a reduction if the switch is on - if (id(${yambms_id}_switch_auto_ccl).state) { + if (id(yambms${yambms_id}_switch_auto_ccl).state) { if (max_cell_v > cell_high_v) { delta = -max_current; } else { @@ -147,5 +147,5 @@ interval: // Update global current_output = round(current_output * 10.0f) / 10.0f; output_id = current_output; - id(${yambms_id}_var_charge_current_step)++; + id(yambms${yambms_id}_var_charge_current_step)++; } diff --git a/packages/yambms/yambms_auto_cvl.yaml b/packages/yambms/yambms_auto_cvl.yaml index ba91aee..a637ca2 100644 --- a/packages/yambms/yambms_auto_cvl.yaml +++ b/packages/yambms/yambms_auto_cvl.yaml @@ -1,5 +1,5 @@ -# Updated : 2026.03.23 -# Version : 2.4.8 +# Updated : 2026.06.27 +# Version : 2.4.9 # GitHub : https://github.com/Sleeper85/esphome-yambms # YamBMS ( Yet another multi-BMS Merging Solution ) @@ -20,8 +20,8 @@ switch: - platform: template name: "Automatic Charge Voltage" - id: ${yambms_id}_switch_auto_cvl - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_switch_auto_cvl + device_id: yambms_yambms${yambms_id} restore_mode: RESTORE_DEFAULT_OFF optimistic: true entity_category: config @@ -29,8 +29,8 @@ switch: number: - platform: template name: "Auto CVL Kp Term" - id: ${yambms_id}_auto_cvl_kp - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_auto_cvl_kp + device_id: yambms_yambms${yambms_id} step: 0.005 min_value: 0 max_value: 1 @@ -44,8 +44,8 @@ number: - platform: template name: "Auto CVL Ki Term" - id: ${yambms_id}_auto_cvl_ki - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_auto_cvl_ki + device_id: yambms_yambms${yambms_id} step: 0.05 min_value: 0 max_value: 5 @@ -59,8 +59,8 @@ number: - platform: template name: "Auto CVL Boost Charge V." - id: ${yambms_id}_auto_cvl_boost_charge_v - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_auto_cvl_boost_charge_v + device_id: yambms_yambms${yambms_id} step: 0.1 min_value: 0 max_value: 3 @@ -89,16 +89,16 @@ sensor: static float integral = 0.0; // Integral term initialization static float prev_integral = 0.0; // Prior Integral term initialization - float cell_count = id(${yambms_id}_cell_count).state; - float bulk_voltage = id(${yambms_id}_bulk_voltage).state; - float balance_delta = id(${yambms_id}_balance_trigger_voltage).state; - float max_cell_v = id(${yambms_id}_max_cell_voltage).state; - float min_CVL = id(${yambms_id}_float_voltage).state; // Minimum CVL + float cell_count = id(yambms${yambms_id}_cell_count).state; + float bulk_voltage = id(yambms${yambms_id}_bulk_voltage).state; + float balance_delta = id(yambms${yambms_id}_balance_trigger_voltage).state; + float max_cell_v = id(yambms${yambms_id}_max_cell_voltage).state; + float min_CVL = id(yambms${yambms_id}_float_voltage).state; // Minimum CVL float CVL = bulk_voltage; // Starting CVL float CVL_orig = bulk_voltage; // Starting CVL snapshot - float kp = id(${yambms_id}_auto_cvl_kp).state; // Proportional gain, adjust as needed - float ki = id(${yambms_id}_auto_cvl_ki).state; // Integral gain, adjust as needed + float kp = id(yambms${yambms_id}_auto_cvl_kp).state; // Proportional gain, adjust as needed + float ki = id(yambms${yambms_id}_auto_cvl_ki).state; // Integral gain, adjust as needed float dt = 1.0; // Time step, adjust based on update_interval float error = 0.0; // Starting error float output = 0.0; // Starting output @@ -106,17 +106,17 @@ sensor: // Check if values are available, if not return bulk voltage as CVL if (isnan(cell_count) || isnan(bulk_voltage) || isnan(balance_delta) || isnan(max_cell_v) || isnan(min_CVL) || cell_count <= 0) { - id(${yambms_id}_var_auto_cvl) = 0.0; + id(yambms${yambms_id}_var_auto_cvl) = 0.0; return bulk_voltage; } - float max_CVL = bulk_voltage + id(${yambms_id}_auto_cvl_boost_charge_v).state; // Maximum CVL + float max_CVL = bulk_voltage + id(yambms${yambms_id}_auto_cvl_boost_charge_v).state; // Maximum CVL float cell_bulk_v = (bulk_voltage / cell_count); float max_allowed_voltage = cell_bulk_v + balance_delta; // Check feature enabled - if (!id(${yambms_id}_switch_auto_cvl).state){ - id(${yambms_id}_var_auto_cvl) = 0.0; + if (!id(yambms${yambms_id}_switch_auto_cvl).state){ + id(yambms${yambms_id}_var_auto_cvl) = 0.0; prev_integral = 0.0; return bulk_voltage; } else { @@ -148,6 +148,6 @@ sensor: else { prev_integral = integral; } - id(${yambms_id}_var_auto_cvl) = CVL - CVL_orig; + id(yambms${yambms_id}_var_auto_cvl) = CVL - CVL_orig; return CVL - CVL_orig; } diff --git a/packages/yambms/yambms_auto_dcl.yaml b/packages/yambms/yambms_auto_dcl.yaml index dc594a6..c1e2f64 100644 --- a/packages/yambms/yambms_auto_dcl.yaml +++ b/packages/yambms/yambms_auto_dcl.yaml @@ -1,5 +1,5 @@ -# Updated : 2026.03.23 -# Version : 1.3.2 +# Updated : 2026.06.27 +# Version : 1.3.3 # GitHub : https://github.com/Sleeper85/esphome-yambms # YamBMS ( Yet another multi-BMS Merging Solution ) @@ -22,7 +22,7 @@ esphome: - priority: -100.0 then: - lambda: |- - id(${yambms_id}_var_auto_dcl_functions_count)++; + id(yambms${yambms_id}_var_auto_dcl_functions_count)++; substitutions: # +--------------------------------------+ @@ -42,8 +42,8 @@ substitutions: switch: - platform: template name: "Automatic Discharge Current" - id: ${yambms_id}_switch_auto_dcl - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_switch_auto_dcl + device_id: yambms_yambms${yambms_id} restore_mode: RESTORE_DEFAULT_OFF optimistic: true entity_category: config @@ -55,8 +55,8 @@ interval: # | Auto Discharge Current Limit | # +------------------------------------------+ - lambda: |- - int dc_step = id(${yambms_id}_var_discharge_current_step); - if (dc_step >= 1 && dc_step < id(${yambms_id}_var_auto_dcl_functions_count) + 1) + int dc_step = id(yambms${yambms_id}_var_discharge_current_step); + if (dc_step >= 1 && dc_step < id(yambms${yambms_id}_var_auto_dcl_functions_count) + 1) { ESP_LOGD("yambms_debug", "Entering Auto DCL..."); @@ -65,19 +65,19 @@ interval: static bool is_initialized = false; // Configuration - float max_current = id(${yambms_id}_max_discharge_current).state; - auto& output_id = id(${yambms_id}_var_auto_dcl); + float max_current = id(yambms${yambms_id}_max_discharge_current).state; + auto& output_id = id(yambms${yambms_id}_var_auto_dcl); float alpha = 0.15f; float min_amp_increase_step = 1.0f; // Define raw inputs - float min_cell_v = id(${yambms_id}_min_cell_voltage).state; - float cell_uvp_v = id(${yambms_id}_cell_uvp).state; + float min_cell_v = id(yambms${yambms_id}_min_cell_voltage).state; + float cell_uvp_v = id(yambms${yambms_id}_cell_uvp).state; // Exit if critical data is missing if (isnan(max_current) || isnan(min_cell_v) || isnan(cell_uvp_v)) { output_id = 0.0f; - id(${yambms_id}_var_discharge_current_step)++; + id(yambms${yambms_id}_var_discharge_current_step)++; return; } @@ -87,7 +87,7 @@ interval: float delta = 0.0f; // Only calculate a reduction if the switch is on - if (id(${yambms_id}_switch_auto_dcl).state) { + if (id(yambms${yambms_id}_switch_auto_dcl).state) { float knee_v = ${discharge_knee_v}; float low_diff = cell_low_v - knee_v; @@ -142,5 +142,5 @@ interval: // Update global current_output = round(current_output * 10.0f) / 10.0f; output_id = current_output; - id(${yambms_id}_var_discharge_current_step)++; + id(yambms${yambms_id}_var_discharge_current_step)++; } \ No newline at end of file diff --git a/packages/yambms/yambms_auto_eoc.yaml b/packages/yambms/yambms_auto_eoc.yaml index bc184a1..35654f7 100644 --- a/packages/yambms/yambms_auto_eoc.yaml +++ b/packages/yambms/yambms_auto_eoc.yaml @@ -1,5 +1,5 @@ -# Updated : 2026.03.23 -# Version : 1.1.9 +# Updated : 2026.06.27 +# Version : 1.2.0 # GitHub : https://github.com/Sleeper85/esphome-yambms # YamBMS ( Yet another multi-BMS Merging Solution ) @@ -32,13 +32,13 @@ esphome: - priority: -100.0 then: - lambda: |- - id(${yambms_id}_var_auto_ccl_functions_count)++; + id(yambms${yambms_id}_var_auto_ccl_functions_count)++; switch: - platform: template name: "Automatic EOC Current" - id: ${yambms_id}_switch_auto_eoc - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_switch_auto_eoc + device_id: yambms_yambms${yambms_id} restore_mode: RESTORE_DEFAULT_OFF optimistic: true entity_category: config @@ -46,8 +46,8 @@ switch: number: - platform: template name: "Auto EOC Target Hour" - id: ${yambms_id}_auto_eoc_target_hour - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_auto_eoc_target_hour + device_id: yambms_yambms${yambms_id} step: 1 min_value: 12 max_value: 23 @@ -61,8 +61,8 @@ number: - platform: template name: "Auto EOC Target Minute" - id: ${yambms_id}_auto_eoc_target_min - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_auto_eoc_target_min + device_id: yambms_yambms${yambms_id} step: 15 min_value: 0 max_value: 45 @@ -76,8 +76,8 @@ number: - platform: template name: "Auto EOC Correction" - id: ${yambms_id}_auto_eoc_correction - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_auto_eoc_correction + device_id: yambms_yambms${yambms_id} step: 1 min_value: -20 max_value: 20 @@ -91,8 +91,8 @@ number: - platform: template name: "Auto EOC Capacity Modifier" - id: ${yambms_id}_auto_eoc_modifier - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_auto_eoc_modifier + device_id: yambms_yambms${yambms_id} step: 1 min_value: -10 max_value: 0 @@ -106,8 +106,8 @@ number: - platform: template name: "Auto EOC Increase Stop Hours" - id: ${yambms_id}_auto_eoc_stop_hours - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_auto_eoc_stop_hours + device_id: yambms_yambms${yambms_id} step: 0.5 min_value: 0 max_value: 4 @@ -121,8 +121,8 @@ number: - platform: template name: "Auto EOC Increase Stop SoC" - id: ${yambms_id}_auto_eoc_stop_soc - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_auto_eoc_stop_soc + device_id: yambms_yambms${yambms_id} step: 1 min_value: 50 max_value: 100 @@ -140,8 +140,8 @@ text_sensor: # +--------------------------------------+ - platform: template name: "Auto EOC Status" - id: ${yambms_id}_auto_eoc_status - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_auto_eoc_status + device_id: yambms_yambms${yambms_id} update_interval: never icon: mdi:information-outline entity_category: diagnostic @@ -154,8 +154,8 @@ sensor: # The value will be updated every 3 minutes - platform: template name: "Auto EOC Current" - id: ${yambms_id}_auto_eoc_charging_current_filtered - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_auto_eoc_charging_current_filtered + device_id: yambms_yambms${yambms_id} unit_of_measurement: A device_class: current filters: @@ -173,32 +173,32 @@ interval: # +------------------------------------------+ - lambda: |- // Check if we are in the correct step - int cc_step = id(${yambms_id}_var_charge_current_step); - if ((cc_step < 1) || (cc_step >= (id(${yambms_id}_var_auto_ccl_functions_count) + 1))) { + int cc_step = id(yambms${yambms_id}_var_charge_current_step); + if ((cc_step < 1) || (cc_step >= (id(yambms${yambms_id}_var_auto_ccl_functions_count) + 1))) { return; } ESP_LOGD("yambms_debug", "Entering Auto EOC..."); // Check if enabled - if (!id(${yambms_id}_switch_auto_eoc).state || - !id(${yambms_id}_battery_capacity).has_state() || - !id(${yambms_id}_battery_capacity_remaining).has_state() || - !id(${yambms_id}_max_charge_current).has_state()) { + if (!id(yambms${yambms_id}_switch_auto_eoc).state || + !id(yambms${yambms_id}_battery_capacity).has_state() || + !id(yambms${yambms_id}_battery_capacity_remaining).has_state() || + !id(yambms${yambms_id}_max_charge_current).has_state()) { // Auto EOC Charging disabled - id(${yambms_id}_var_auto_eoc) = 0; - id(${yambms_id}_auto_eoc_charging_current_filtered).publish_state(NAN); - id(${yambms_id}_auto_eoc_status).publish_state("Stop: Disabled"); - id(${yambms_id}_var_charge_current_step)++; + id(yambms${yambms_id}_var_auto_eoc) = 0; + id(yambms${yambms_id}_auto_eoc_charging_current_filtered).publish_state(NAN); + id(yambms${yambms_id}_auto_eoc_status).publish_state("Stop: Disabled"); + id(yambms${yambms_id}_var_charge_current_step)++; return; } // Check if Float is active - if (id(${yambms_id}_charging_instruction).state == "Float") { - id(${yambms_id}_var_auto_eoc) = 0; - id(${yambms_id}_auto_eoc_charging_current_filtered).publish_state(NAN); - id(${yambms_id}_auto_eoc_status).publish_state("Stop: Float"); - id(${yambms_id}_var_charge_current_step)++; + if (id(yambms${yambms_id}_charging_instruction).state == "Float") { + id(yambms${yambms_id}_var_auto_eoc) = 0; + id(yambms${yambms_id}_auto_eoc_charging_current_filtered).publish_state(NAN); + id(yambms${yambms_id}_auto_eoc_status).publish_state("Stop: Float"); + id(yambms${yambms_id}_var_charge_current_step)++; return; } @@ -207,7 +207,7 @@ interval: uint32_t current_ms = millis(); if ((current_ms - last_execution_ms) < 60000) { - id(${yambms_id}_var_charge_current_step)++; + id(yambms${yambms_id}_var_charge_current_step)++; return; } @@ -217,16 +217,16 @@ interval: const auto current_time = id(my_time).now(); if (!current_time.is_valid()) { ESP_LOGW("yambms_auto_eoc", "Time not valid"); - id(${yambms_id}_var_auto_eoc) = 0; - id(${yambms_id}_auto_eoc_charging_current_filtered).publish_state(NAN); - id(${yambms_id}_auto_eoc_status).publish_state("Stop: Time not valid"); - id(${yambms_id}_var_charge_current_step)++; + id(yambms${yambms_id}_var_auto_eoc) = 0; + id(yambms${yambms_id}_auto_eoc_charging_current_filtered).publish_state(NAN); + id(yambms${yambms_id}_auto_eoc_status).publish_state("Stop: Time not valid"); + id(yambms${yambms_id}_var_charge_current_step)++; return; } // Get target time - const int target_hour = id(${yambms_id}_auto_eoc_target_hour).state; - const int target_minute = id(${yambms_id}_auto_eoc_target_min).state; + const int target_hour = id(yambms${yambms_id}_auto_eoc_target_hour).state; + const int target_minute = id(yambms${yambms_id}_auto_eoc_target_min).state; // Create target timestamp auto target_time = current_time; @@ -239,36 +239,36 @@ interval: const float hours_left = (target_time.timestamp - current_time.timestamp) / 3600.0; if (hours_left <= 0) { - id(${yambms_id}_var_auto_eoc) = 0; - id(${yambms_id}_auto_eoc_charging_current_filtered).publish_state(NAN); - id(${yambms_id}_auto_eoc_status).publish_state("Stop: Target time passed"); - id(${yambms_id}_var_charge_current_step)++; + id(yambms${yambms_id}_var_auto_eoc) = 0; + id(yambms${yambms_id}_auto_eoc_charging_current_filtered).publish_state(NAN); + id(yambms${yambms_id}_auto_eoc_status).publish_state("Stop: Target time passed"); + id(yambms${yambms_id}_var_charge_current_step)++; return; } // Check if we stop increasing the charge current bool stop_increasing = false; - if (id(${yambms_id}_battery_soc).has_state() && (id(${yambms_id}_battery_soc).state >= id(${yambms_id}_auto_eoc_stop_soc).state)) { + if (id(yambms${yambms_id}_battery_soc).has_state() && (id(yambms${yambms_id}_battery_soc).state >= id(yambms${yambms_id}_auto_eoc_stop_soc).state)) { ESP_LOGD("yambms_auto_eoc", "Stopping charge current increase, SoC is above threshold"); stop_increasing = true; - } else if (hours_left <= id(${yambms_id}_auto_eoc_stop_hours).state) { + } else if (hours_left <= id(yambms${yambms_id}_auto_eoc_stop_hours).state) { ESP_LOGD("yambms_auto_eoc", "Stopping charge current increase, hours left is below threshold"); stop_increasing = true; } // Get battery capacity - auto battery_capacity = id(${yambms_id}_battery_capacity).state; + auto battery_capacity = id(yambms${yambms_id}_battery_capacity).state; // Apply negative capacity modifier - battery_capacity += (battery_capacity * (id(${yambms_id}_auto_eoc_modifier).state / 100.0)); + battery_capacity += (battery_capacity * (id(yambms${yambms_id}_auto_eoc_modifier).state / 100.0)); // Check if Auto SoC Limit is active int auto_soc_limit = 0; - if (id(${yambms_id}_switch_auto_soc_limit).state && - id(${yambms_id}_auto_soc_limit_status).has_state()) { + if (id(yambms${yambms_id}_switch_auto_soc_limit).state && + id(yambms${yambms_id}_auto_soc_limit_status).has_state()) { // Check status, if Run, remove Auto SoC limit difference from battery capacity - if (id(${yambms_id}_auto_soc_limit_status).state.starts_with("Run")) { - auto_soc_limit = id(${yambms_id}_auto_soc_limit).state; + if (id(yambms${yambms_id}_auto_soc_limit_status).state.starts_with("Run")) { + auto_soc_limit = id(yambms${yambms_id}_auto_soc_limit).state; battery_capacity = (battery_capacity * auto_soc_limit) / 100.0; ESP_LOGD("yambms_auto_eoc", "Auto SoC Limit is active, adjusted battery capacity"); } else { @@ -277,24 +277,24 @@ interval: } // Calculate missing capacity - auto capacity_required = battery_capacity - id(${yambms_id}_battery_capacity_remaining).state; + auto capacity_required = battery_capacity - id(yambms${yambms_id}_battery_capacity_remaining).state; if (capacity_required < 0) { capacity_required = 0; } // Get active charge current, this will be our maximum charge current float auto_limit = std::min({ - id(${yambms_id}_var_auto_ccl), - id(${yambms_id}_var_auto_temperature_ccl) + id(yambms${yambms_id}_var_auto_ccl), + id(yambms${yambms_id}_var_auto_temperature_ccl) }); - float charge_current = round(id(${yambms_id}_max_charge_current).state + auto_limit); + float charge_current = round(id(yambms${yambms_id}_max_charge_current).state + auto_limit); // Calculate required charge current float required_charge_current = capacity_required / hours_left; // Apply charge current correction factor - const float correction_factor = (id(${yambms_id}_auto_eoc_correction).state / 100.0) + 1.0; + const float correction_factor = (id(yambms${yambms_id}_auto_eoc_correction).state / 100.0) + 1.0; required_charge_current *= correction_factor; // If the required charge current higher than the maximum charge current, return 0 to indicate @@ -303,26 +303,26 @@ interval: if (required_charge_current >= charge_current) { required_charge_current = 0; return_value = NAN; - id(${yambms_id}_auto_eoc_status).publish_state("Stop: Current above limit"); + id(yambms${yambms_id}_auto_eoc_status).publish_state("Stop: Current above limit"); } else { // The value is valid, return it return_value = required_charge_current; // Check if filtered charging current is available - if (id(${yambms_id}_auto_eoc_charging_current_filtered).has_state()) { - const float filtered_charge_current = id(${yambms_id}_auto_eoc_charging_current_filtered).state; + if (id(yambms${yambms_id}_auto_eoc_charging_current_filtered).has_state()) { + const float filtered_charge_current = id(yambms${yambms_id}_auto_eoc_charging_current_filtered).state; // Check if current is increasing and we should stop if (stop_increasing && (required_charge_current > filtered_charge_current)) { // Return previous filtered charge current return_value = filtered_charge_current; - id(${yambms_id}_auto_eoc_status).publish_state("Run: Current increase stopped"); + id(yambms${yambms_id}_auto_eoc_status).publish_state("Run: Current increase stopped"); } else if (auto_soc_limit) { // Update status to running with Auto SoC Limit - id(${yambms_id}_auto_eoc_status).publish_state("Run: Auto SoC Limit " + std::to_string(auto_soc_limit) + "%"); + id(yambms${yambms_id}_auto_eoc_status).publish_state("Run: Auto SoC Limit " + std::to_string(auto_soc_limit) + "%"); } else { // Update status to running - id(${yambms_id}_auto_eoc_status).publish_state("Run"); + id(yambms${yambms_id}_auto_eoc_status).publish_state("Run"); } // Use filtered charge current for calculations @@ -333,11 +333,11 @@ interval: // Limit required charge current to maximum charge current if ((required_charge_current > 0.0f) && (required_charge_current < charge_current)) { // Calculate negative difference to charge current - id(${yambms_id}_var_auto_eoc) = round(required_charge_current - charge_current); + id(yambms${yambms_id}_var_auto_eoc) = round(required_charge_current - charge_current); } else { - id(${yambms_id}_var_auto_eoc) = 0; + id(yambms${yambms_id}_var_auto_eoc) = 0; } - id(${yambms_id}_auto_eoc_charging_current_filtered).publish_state(return_value); + id(yambms${yambms_id}_auto_eoc_charging_current_filtered).publish_state(return_value); - id(${yambms_id}_var_charge_current_step)++; + id(yambms${yambms_id}_var_charge_current_step)++; diff --git a/packages/yambms/yambms_auto_float.yaml b/packages/yambms/yambms_auto_float.yaml index 6f9aaa5..dcc9c83 100644 --- a/packages/yambms/yambms_auto_float.yaml +++ b/packages/yambms/yambms_auto_float.yaml @@ -1,5 +1,5 @@ -# Updated : 2026.03.23 -# Version : 1.1.6 +# Updated : 2026.06.27 +# Version : 1.1.7 # GitHub : https://github.com/Sleeper85/esphome-yambms # YamBMS ( Yet another multi-BMS Merging Solution ) @@ -20,8 +20,8 @@ select: - platform: template name: "Automatic Float Voltage" - id: ${yambms_id}_auto_float_mode - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_auto_float_mode + device_id: yambms_yambms${yambms_id} options: - "Disabled" - "Follow" @@ -38,8 +38,8 @@ select: number: - platform: template name: "Auto Float Voltage Step" - id: ${yambms_id}_auto_float_step_v - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_auto_float_step_v + device_id: yambms_yambms${yambms_id} step: 0.1 min_value: 0.1 max_value: 0.5 @@ -53,8 +53,8 @@ number: - platform: template name: "Auto Float Update Interval" - id: ${yambms_id}_auto_float_interval - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_auto_float_interval + device_id: yambms_yambms${yambms_id} step: 1 min_value: 1 max_value: 10 @@ -69,21 +69,21 @@ number: sensor: # Filter total voltage (max) - platform: template - id: ${yambms_id}_auto_float_total_v - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_auto_float_total_v + device_id: yambms_yambms${yambms_id} update_interval: 30s filters: - max: window_size: 4 - lambda: return id(${yambms_id}_total_voltage).state; + lambda: return id(yambms${yambms_id}_total_voltage).state; # +--------------------------------------+ # | Auto Float Voltage Control | # +--------------------------------------+ - platform: template name: "Auto Float Voltage" - id: ${yambms_id}_auto_float_v - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_auto_float_v + device_id: yambms_yambms${yambms_id} update_interval: 60s # Keep this at 60s, otherwise "Auto Float Update Interval" won't work! unit_of_measurement: V device_class: voltage @@ -92,12 +92,12 @@ sensor: - round: 1 lambda: |- // Variables - const auto mode = id(${yambms_id}_auto_float_mode).active_index(); // Mode: 0 - Disabled, 1 - Follow, 2 - Immediately - const float bulk_v = id(${yambms_id}_bulk_voltage).state; // Bulk voltage - const float target_float_v = id(${yambms_id}_float_voltage).state; // Target float voltage - const float step_v = id(${yambms_id}_auto_float_step_v).state; // Voltage step for each decrement - const float max_total_v = id(${yambms_id}_auto_float_total_v).state; // Total voltage (mean and max) - const auto update_interval = id(${yambms_id}_auto_float_interval).state; // Update interval in minutes + const auto mode = id(yambms${yambms_id}_auto_float_mode).active_index(); // Mode: 0 - Disabled, 1 - Follow, 2 - Immediately + const float bulk_v = id(yambms${yambms_id}_bulk_voltage).state; // Bulk voltage + const float target_float_v = id(yambms${yambms_id}_float_voltage).state; // Target float voltage + const float step_v = id(yambms${yambms_id}_auto_float_step_v).state; // Voltage step for each decrement + const float max_total_v = id(yambms${yambms_id}_auto_float_total_v).state; // Total voltage (mean and max) + const auto update_interval = id(yambms${yambms_id}_auto_float_interval).state; // Update interval in minutes static float float_v = bulk_v; // Initialize float voltage static uint8_t time_count = 0; // Interval counter bool decrement = false; @@ -106,11 +106,11 @@ sensor: if ((mode == 0) || (bulk_v <= target_float_v)) { // Return Float voltage - id(${yambms_id}_var_auto_float) = 0; + id(yambms${yambms_id}_var_auto_float) = 0; return target_float_v; } // Auto Float enabled + Floating - else if (id(${yambms_id}_var_charge_status) == "Float") + else if (id(yambms${yambms_id}_var_charge_status) == "Float") { // Check update interval if (++time_count >= (uint8_t)update_interval) @@ -119,7 +119,7 @@ sensor: if (mode == 1) { // Check battery voltage and wait for the battery voltage to reach current float voltage - if ((id(${yambms_id}_total_voltage).state > 0) && (max_total_v <= float_v)) decrement = true; + if ((id(yambms${yambms_id}_total_voltage).state > 0) && (max_total_v <= float_v)) decrement = true; } // Immediately mode : Start immediately else if (mode == 2) decrement = true; @@ -142,7 +142,7 @@ sensor: } // Store difference for CVL calculation - id(${yambms_id}_var_auto_float) = float_v - target_float_v; + id(yambms${yambms_id}_var_auto_float) = float_v - target_float_v; // Return Auto Float voltage return float_v; diff --git a/packages/yambms/yambms_auto_soc_limit.yaml b/packages/yambms/yambms_auto_soc_limit.yaml index c1e9390..1366b2a 100644 --- a/packages/yambms/yambms_auto_soc_limit.yaml +++ b/packages/yambms/yambms_auto_soc_limit.yaml @@ -1,5 +1,5 @@ -# Updated : 2026.03.23 -# Version : 1.1.4 +# Updated : 2026.06.27 +# Version : 1.1.5 # GitHub : https://github.com/Sleeper85/esphome-yambms # YamBMS ( Yet another multi-BMS Merging Solution ) @@ -22,11 +22,11 @@ esphome: - priority: -100.0 then: - lambda: |- - id(${yambms_id}_var_auto_ccl_functions_count)++; + id(yambms${yambms_id}_var_auto_ccl_functions_count)++; globals: # Target SoC was reached flag - - id: ${yambms_id}_var_auto_soc_target_reached + - id: yambms${yambms_id}_var_auto_soc_target_reached type: bool restore_value: no initial_value: 'false' @@ -34,8 +34,8 @@ globals: switch: - platform: template name: "Automatic SoC Limit" - id: ${yambms_id}_switch_auto_soc_limit - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_switch_auto_soc_limit + device_id: yambms_yambms${yambms_id} restore_mode: RESTORE_DEFAULT_OFF optimistic: true entity_category: config @@ -43,8 +43,8 @@ switch: number: - platform: template name: "Auto SoC Limit" - id: ${yambms_id}_auto_soc_limit - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_auto_soc_limit + device_id: yambms_yambms${yambms_id} step: 5 min_value: 40 max_value: 95 @@ -59,11 +59,11 @@ number: then: - lambda: |- // Reset target reached flag - id(${yambms_id}_var_auto_soc_target_reached) = false; + id(yambms${yambms_id}_var_auto_soc_target_reached) = false; - platform: template name: "Auto SoC Limit Hysteresis" - id: ${yambms_id}_auto_soc_hysteresis - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_auto_soc_hysteresis + device_id: yambms_yambms${yambms_id} step: 5 min_value: 5 max_value: 40 @@ -78,11 +78,11 @@ number: then: - lambda: |- // Reset target reached flag - id(${yambms_id}_var_auto_soc_target_reached) = false; + id(yambms${yambms_id}_var_auto_soc_target_reached) = false; - platform: template name: "Auto SoC Limit CCL" - id: ${yambms_id}_auto_soc_ccl - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_auto_soc_ccl + device_id: yambms_yambms${yambms_id} step: 1 min_value: 0 max_value: 10 @@ -97,13 +97,13 @@ number: then: - lambda: |- // Reset target reached flag - id(${yambms_id}_var_auto_soc_target_reached) = false; + id(yambms${yambms_id}_var_auto_soc_target_reached) = false; select: - platform: template name: "Auto SoC Limit Mode" - id: ${yambms_id}_auto_soc_limit_mode - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_auto_soc_limit_mode + device_id: yambms_yambms${yambms_id} options: - "Float" - "CCL" @@ -116,7 +116,7 @@ select: then: - lambda: |- // Reset target reached flag - id(${yambms_id}_var_auto_soc_target_reached) = false; + id(yambms${yambms_id}_var_auto_soc_target_reached) = false; text_sensor: # +--------------------------------------+ @@ -124,8 +124,8 @@ text_sensor: # +--------------------------------------+ - platform: template name: "Auto SoC Limit Status" - id: ${yambms_id}_auto_soc_limit_status - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_auto_soc_limit_status + device_id: yambms_yambms${yambms_id} update_interval: never icon: mdi:information-outline entity_category: diagnostic @@ -138,42 +138,42 @@ interval: # +------------------------------------------+ - lambda: |- // Check if we are in the correct step - int cc_step = id(${yambms_id}_var_charge_current_step); - if ((cc_step < 1) || (cc_step >= (id(${yambms_id}_var_auto_ccl_functions_count) + 1))) { + int cc_step = id(yambms${yambms_id}_var_charge_current_step); + if ((cc_step < 1) || (cc_step >= (id(yambms${yambms_id}_var_auto_ccl_functions_count) + 1))) { return; } ESP_LOGD("yambms_debug", "Entering Auto SoC Limit..."); // Check if enabled - if (!id(${yambms_id}_switch_auto_soc_limit).state || - !id(${yambms_id}_battery_soc).has_state() || - !id(${yambms_id}_max_charge_current).has_state()) { + if (!id(yambms${yambms_id}_switch_auto_soc_limit).state || + !id(yambms${yambms_id}_battery_soc).has_state() || + !id(yambms${yambms_id}_max_charge_current).has_state()) { // Auto SoC Charging disabled - id(${yambms_id}_var_auto_soc_limit) = 0; - id(${yambms_id}_auto_soc_limit_status).publish_state("Stop: Disabled"); - id(${yambms_id}_var_auto_soc_target_reached) = false; - id(${yambms_id}_var_charge_current_step)++; + id(yambms${yambms_id}_var_auto_soc_limit) = 0; + id(yambms${yambms_id}_auto_soc_limit_status).publish_state("Stop: Disabled"); + id(yambms${yambms_id}_var_auto_soc_target_reached) = false; + id(yambms${yambms_id}_var_charge_current_step)++; return; } // Check if Force Bulk is active - if (id(${yambms_id}_switch_force_bulk).state) { + if (id(yambms${yambms_id}_switch_force_bulk).state) { // If Force Bulk is active, we should not limit charge current or switch to Float - id(${yambms_id}_var_auto_soc_limit) = 0; - id(${yambms_id}_auto_soc_limit_status).publish_state("Stop: Force Bulk active"); - id(${yambms_id}_var_auto_soc_target_reached) = false; - id(${yambms_id}_var_charge_current_step)++; + id(yambms${yambms_id}_var_auto_soc_limit) = 0; + id(yambms${yambms_id}_auto_soc_limit_status).publish_state("Stop: Force Bulk active"); + id(yambms${yambms_id}_var_auto_soc_target_reached) = false; + id(yambms${yambms_id}_var_charge_current_step)++; return; } // Check if Rebulk Days is active - if (id(${yambms_id}_var_rebulk_days_active)) { + if (id(yambms${yambms_id}_var_rebulk_days_active)) { // If Rebulk Days is active, we should not limit charge current or switch to Float - id(${yambms_id}_var_auto_soc_limit) = 0; - id(${yambms_id}_auto_soc_limit_status).publish_state("Stop: Rebulk Days active"); - id(${yambms_id}_var_auto_soc_target_reached) = false; - id(${yambms_id}_var_charge_current_step)++; + id(yambms${yambms_id}_var_auto_soc_limit) = 0; + id(yambms${yambms_id}_auto_soc_limit_status).publish_state("Stop: Rebulk Days active"); + id(yambms${yambms_id}_var_auto_soc_target_reached) = false; + id(yambms${yambms_id}_var_charge_current_step)++; return; } @@ -182,71 +182,71 @@ interval: uint32_t current_ms = millis(); if ((current_ms - last_execution_ms) < 60000) { - id(${yambms_id}_var_charge_current_step)++; + id(yambms${yambms_id}_var_charge_current_step)++; return; } last_execution_ms = current_ms; // Only work in Bulk or Float mode - if (id(${yambms_id}_var_charge_status) != "Bulk" && id(${yambms_id}_var_charge_status) != "Float") { - id(${yambms_id}_var_auto_soc_limit) = 0; - id(${yambms_id}_auto_soc_limit_status).publish_state("Stop: Not in Bulk/Float"); - id(${yambms_id}_var_auto_soc_target_reached) = false; - id(${yambms_id}_var_charge_current_step)++; + if (id(yambms${yambms_id}_var_charge_status) != "Bulk" && id(yambms${yambms_id}_var_charge_status) != "Float") { + id(yambms${yambms_id}_var_auto_soc_limit) = 0; + id(yambms${yambms_id}_auto_soc_limit_status).publish_state("Stop: Not in Bulk/Float"); + id(yambms${yambms_id}_var_auto_soc_target_reached) = false; + id(yambms${yambms_id}_var_charge_current_step)++; return; } // Check if target SoC was already reached - int soc = id(${yambms_id}_battery_soc).state; - int target_soc = id(${yambms_id}_auto_soc_limit).state; + int soc = id(yambms${yambms_id}_battery_soc).state; + int target_soc = id(yambms${yambms_id}_auto_soc_limit).state; - if (id(${yambms_id}_var_auto_soc_target_reached)) { + if (id(yambms${yambms_id}_var_auto_soc_target_reached)) { // If target was reached but SoC has dropped below target - hysteresis, allow increasing charge current again - int soc_hysteresis = target_soc - id(${yambms_id}_auto_soc_hysteresis).state; + int soc_hysteresis = target_soc - id(yambms${yambms_id}_auto_soc_hysteresis).state; if (soc <= soc_hysteresis) { ESP_LOGD("yambms_debug", "Auto SoC Limit: Activating again, SoC dropped below target - hysteresis"); - id(${yambms_id}_var_auto_soc_target_reached) = false; - id(${yambms_id}_var_auto_soc_limit) = 0; - id(${yambms_id}_auto_soc_limit_status).publish_state("Run"); + id(yambms${yambms_id}_var_auto_soc_target_reached) = false; + id(yambms${yambms_id}_var_auto_soc_limit) = 0; + id(yambms${yambms_id}_auto_soc_limit_status).publish_state("Run"); } else { - id(${yambms_id}_auto_soc_limit_status).publish_state("Wait: Reactivating at " + std::to_string(soc_hysteresis) + "%"); + id(yambms${yambms_id}_auto_soc_limit_status).publish_state("Wait: Reactivating at " + std::to_string(soc_hysteresis) + "%"); } - id(${yambms_id}_var_charge_current_step)++; + id(yambms${yambms_id}_var_charge_current_step)++; return; } // Check if target SoC is reached or exceeded if (soc >= target_soc) { - id(${yambms_id}_var_auto_soc_target_reached) = true; - id(${yambms_id}_auto_soc_limit_status).publish_state("Stop: SoC limit reached"); + id(yambms${yambms_id}_var_auto_soc_target_reached) = true; + id(yambms${yambms_id}_auto_soc_limit_status).publish_state("Stop: SoC limit reached"); ESP_LOGD("yambms_debug", "Auto SoC Limit: Target SoC reached"); // Get mode - const auto mode = id(${yambms_id}_auto_soc_limit_mode).active_index(); + const auto mode = id(yambms${yambms_id}_auto_soc_limit_mode).active_index(); if (mode == 0) { // Float mode ESP_LOGD("yambms_debug", "Auto SoC Limit: Applying Float mode"); - id(${yambms_id}_var_charge_status) = "Float"; - id(${yambms_id}_var_auto_soc_limit) = 0; + id(yambms${yambms_id}_var_charge_status) = "Float"; + id(yambms${yambms_id}_var_auto_soc_limit) = 0; } else if (mode == 1) { // CCL mode ESP_LOGD("yambms_debug", "Auto SoC Limit: Applying CCL mode"); - id(${yambms_id}_var_auto_soc_limit) = -(id(${yambms_id}_max_charge_current).state - id(${yambms_id}_auto_soc_ccl).state); + id(yambms${yambms_id}_var_auto_soc_limit) = -(id(yambms${yambms_id}_max_charge_current).state - id(yambms${yambms_id}_auto_soc_ccl).state); } else if (mode == 2) { // Float + CCL mode ESP_LOGD("yambms_debug", "Auto SoC Limit: Applying Float + CCL mode"); - id(${yambms_id}_var_charge_status) = "Float"; - id(${yambms_id}_var_auto_soc_limit) = -(id(${yambms_id}_max_charge_current).state - id(${yambms_id}_auto_soc_ccl).state); + id(yambms${yambms_id}_var_charge_status) = "Float"; + id(yambms${yambms_id}_var_auto_soc_limit) = -(id(yambms${yambms_id}_max_charge_current).state - id(yambms${yambms_id}_auto_soc_ccl).state); } else { // Default case (should not happen) ESP_LOGD("yambms_debug", "Auto SoC Limit: Unknown mode"); } } else { - id(${yambms_id}_auto_soc_limit_status).publish_state("Run"); - id(${yambms_id}_var_auto_soc_limit) = 0; + id(yambms${yambms_id}_auto_soc_limit_status).publish_state("Run"); + id(yambms${yambms_id}_var_auto_soc_limit) = 0; } - id(${yambms_id}_var_charge_current_step)++; + id(yambms${yambms_id}_var_charge_current_step)++; diff --git a/packages/yambms/yambms_auto_temp_ccl_dcl.yaml b/packages/yambms/yambms_auto_temp_ccl_dcl.yaml index 2c7d00c..32e7eb9 100644 --- a/packages/yambms/yambms_auto_temp_ccl_dcl.yaml +++ b/packages/yambms/yambms_auto_temp_ccl_dcl.yaml @@ -1,5 +1,5 @@ -# Updated : 2026.03.23 -# Version : 1.1.7 +# Updated : 2026.06.27 +# Version : 1.1.8 # GitHub : https://github.com/Sleeper85/esphome-yambms # YamBMS ( Yet another multi-BMS Merging Solution ) @@ -29,8 +29,8 @@ esphome: - priority: -100.0 then: - lambda: |- - id(${yambms_id}_var_auto_ccl_functions_count)++; - id(${yambms_id}_var_auto_dcl_functions_count)++; + id(yambms${yambms_id}_var_auto_ccl_functions_count)++; + id(yambms${yambms_id}_var_auto_dcl_functions_count)++; globals: - id: charging_table @@ -44,8 +44,8 @@ globals: switch: - platform: template name: "Temperature-based Current Limitation" - id: ${yambms_id}_switch_temperature_based_current_limitation - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_switch_temperature_based_current_limitation + device_id: yambms_yambms${yambms_id} restore_mode: RESTORE_DEFAULT_ON optimistic: true entity_category: config @@ -57,34 +57,34 @@ interval: # | Auto Temperature CCL | # +------------------------------------------+ - lambda: |- - int cc_step = id(${yambms_id}_var_charge_current_step); - if (cc_step >= 1 && cc_step < id(${yambms_id}_var_auto_ccl_functions_count) + 1) + int cc_step = id(yambms${yambms_id}_var_charge_current_step); + if (cc_step >= 1 && cc_step < id(yambms${yambms_id}_var_auto_ccl_functions_count) + 1) { ESP_LOGD("yambms_debug", "Entering Auto Temp. CCL..."); // Configuration auto& rate_table = id(charging_table); - float max_current = id(${yambms_id}_max_charge_current).state; - auto& output_id = id(${yambms_id}_var_auto_temperature_ccl); + float max_current = id(yambms${yambms_id}_max_charge_current).state; + auto& output_id = id(yambms${yambms_id}_var_auto_temperature_ccl); float alpha = 0.05f; // Check switch enabled - if (!id(${yambms_id}_switch_temperature_based_current_limitation).state) { + if (!id(yambms${yambms_id}_switch_temperature_based_current_limitation).state) { output_id = 0.0f; - id(${yambms_id}_var_charge_current_step)++; + id(yambms${yambms_id}_var_charge_current_step)++; ESP_LOGD("yambms_debug", "Auto Temp. CCL : Disabled => Exit"); return; } // Define raw inputs - float raw_min = id(${yambms_id}_min_temperature).state; - float raw_max = id(${yambms_id}_max_temperature).state; - float batt_capacity = id(${yambms_id}_battery_capacity).state; + float raw_min = id(yambms${yambms_id}_min_temperature).state; + float raw_max = id(yambms${yambms_id}_max_temperature).state; + float batt_capacity = id(yambms${yambms_id}_battery_capacity).state; // Exit if critical data is missing if (isnan(raw_min) || isnan(raw_max) || isnan(batt_capacity) || batt_capacity <= 0.0f) { output_id = 0.0f; - id(${yambms_id}_var_charge_current_step)++; + id(yambms${yambms_id}_var_charge_current_step)++; ESP_LOGD("yambms_debug", "Auto Temp. CCL : Critical data is missing => Exit"); return; } @@ -129,41 +129,41 @@ interval: // Update global output_id = delta; - id(${yambms_id}_var_charge_current_step)++; + id(yambms${yambms_id}_var_charge_current_step)++; } # +------------------------------------------+ # | Auto Temperature DCL | # +------------------------------------------+ - lambda: |- - int dc_step = id(${yambms_id}_var_discharge_current_step); - if (dc_step >= 1 && dc_step < id(${yambms_id}_var_auto_dcl_functions_count) + 1) + int dc_step = id(yambms${yambms_id}_var_discharge_current_step); + if (dc_step >= 1 && dc_step < id(yambms${yambms_id}_var_auto_dcl_functions_count) + 1) { ESP_LOGD("yambms_debug", "Entering Auto Temp. DCL..."); // Configuration auto& rate_table = id(discharging_table); - float max_current = id(${yambms_id}_max_discharge_current).state; - auto& output_id = id(${yambms_id}_var_auto_temperature_dcl); + float max_current = id(yambms${yambms_id}_max_discharge_current).state; + auto& output_id = id(yambms${yambms_id}_var_auto_temperature_dcl); float alpha = 0.05f; // Check switch enabled - if (!id(${yambms_id}_switch_temperature_based_current_limitation).state) { + if (!id(yambms${yambms_id}_switch_temperature_based_current_limitation).state) { output_id = 0.0f; - id(${yambms_id}_var_discharge_current_step)++; + id(yambms${yambms_id}_var_discharge_current_step)++; ESP_LOGD("yambms_debug", "Auto Temp. DCL : Disabled => Exit"); return; } // Define raw inputs - float raw_min = id(${yambms_id}_min_temperature).state; - float raw_max = id(${yambms_id}_max_temperature).state; - float batt_capacity = id(${yambms_id}_battery_capacity).state; + float raw_min = id(yambms${yambms_id}_min_temperature).state; + float raw_max = id(yambms${yambms_id}_max_temperature).state; + float batt_capacity = id(yambms${yambms_id}_battery_capacity).state; // Exit if critical data is missing if (isnan(raw_min) || isnan(raw_max) || isnan(batt_capacity) || batt_capacity <= 0.0f) { output_id = 0.0f; - id(${yambms_id}_var_discharge_current_step)++; + id(yambms${yambms_id}_var_discharge_current_step)++; ESP_LOGD("yambms_debug", "Auto Temp. DCL : Critical data is missing => Exit"); return; } @@ -208,5 +208,5 @@ interval: // Update global output_id = delta; - id(${yambms_id}_var_discharge_current_step)++; + id(yambms${yambms_id}_var_discharge_current_step)++; } diff --git a/packages/yambms/yambms_canbus.yaml b/packages/yambms/yambms_canbus.yaml index cd0778e..1886002 100644 --- a/packages/yambms/yambms_canbus.yaml +++ b/packages/yambms/yambms_canbus.yaml @@ -1,5 +1,5 @@ -# Updated : 2026.03.23 -# Version : 2.5.5 +# Updated : 2026.06.27 +# Version : 2.5.6 # GitHub : https://github.com/Sleeper85/esphome-yambms # YamBMS ( Yet another multi-BMS Merging Solution ) @@ -190,14 +190,14 @@ interval: then: - lambda: |- // Save CANBUS options - id(${yambms_id}_var_inverter_bms_name) = id(canbus${canbus_id}_bms_name).current_option(); - id(${yambms_id}_var_inverter_protocol) = id(canbus${canbus_id}_protocol).current_option(); + id(yambms${yambms_id}_var_inverter_bms_name) = id(canbus${canbus_id}_bms_name).current_option(); + id(yambms${yambms_id}_var_inverter_protocol) = id(canbus${canbus_id}_protocol).current_option(); - interval: 30s then: - lambda: |- // Test inverter 0x305 ACK - if (id(canbus${canbus_id}_send_canbus_data) == false && id(${yambms_id}_var_initialized) == true) + if (id(canbus${canbus_id}_send_canbus_data) == false && id(yambms${yambms_id}_var_initialized) == true) { id(canbus${canbus_id}_send_canbus_data) = true; // Sending CANBUS frames allowed id(canbus${canbus_id}_script_canbus_link_timer).execute(); // Restart CANBUS link timer @@ -210,8 +210,8 @@ interval: condition: lambda: |- if ((id(canbus${canbus_id}_send_canbus_data) == true) && - (id(${yambms_id}_var_initialized) == true) && - (id(${yambms_id}_bms_combined).state > 0)) + (id(yambms${yambms_id}_var_initialized) == true) && + (id(yambms${yambms_id}_bms_combined).state > 0)) { int index = id(canbus${canbus_id}_can_frame_index); @@ -348,14 +348,14 @@ interval: uint8_t can_mesg[8]; - can_mesg[0] = uint16_t(id(${yambms_id}_requested_charge_voltage).state * 10) & 0xff; - can_mesg[1] = uint16_t(id(${yambms_id}_requested_charge_voltage).state * 10) >> 8 & 0xff; - can_mesg[2] = uint16_t(id(${yambms_id}_requested_charge_current).state * 10) & 0xff; - can_mesg[3] = uint16_t(id(${yambms_id}_requested_charge_current).state * 10) >> 8 & 0xff; - can_mesg[4] = uint16_t(id(${yambms_id}_requested_discharge_current).state * 10) & 0xff; - can_mesg[5] = uint16_t(id(${yambms_id}_requested_discharge_current).state * 10) >> 8 & 0xff; - can_mesg[6] = uint16_t(id(${yambms_id}_requested_discharge_voltage).state * 10) & 0xff; - can_mesg[7] = uint16_t(id(${yambms_id}_requested_discharge_voltage).state * 10) >> 8 & 0xff; + can_mesg[0] = uint16_t(id(yambms${yambms_id}_requested_charge_voltage).state * 10) & 0xff; + can_mesg[1] = uint16_t(id(yambms${yambms_id}_requested_charge_voltage).state * 10) >> 8 & 0xff; + can_mesg[2] = uint16_t(id(yambms${yambms_id}_requested_charge_current).state * 10) & 0xff; + can_mesg[3] = uint16_t(id(yambms${yambms_id}_requested_charge_current).state * 10) >> 8 & 0xff; + can_mesg[4] = uint16_t(id(yambms${yambms_id}_requested_discharge_current).state * 10) & 0xff; + can_mesg[5] = uint16_t(id(yambms${yambms_id}_requested_discharge_current).state * 10) >> 8 & 0xff; + can_mesg[6] = uint16_t(id(yambms${yambms_id}_requested_discharge_voltage).state * 10) & 0xff; + can_mesg[7] = uint16_t(id(yambms${yambms_id}_requested_discharge_voltage).state * 10) >> 8 & 0xff; ESP_LOGI("canbus", "send can_id: 0x351 hex: %x %x %x %x %x %x %x %x", can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]); return {can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]}; @@ -375,22 +375,22 @@ interval: uint8_t can_mesg[8]; - can_mesg[0] = uint16_t(id(${yambms_id}_battery_soc).state) & 0xff; - can_mesg[1] = uint16_t(id(${yambms_id}_battery_soc).state) >> 8 & 0xff; - can_mesg[2] = uint16_t(id(${yambms_id}_battery_soh).state) & 0xff; - can_mesg[3] = uint16_t(id(${yambms_id}_battery_soh).state) >> 8 & 0xff; - can_mesg[4] = uint16_t(id(${yambms_id}_battery_soc).state * 100) & 0xff; - can_mesg[5] = uint16_t(id(${yambms_id}_battery_soc).state * 100) >> 8 & 0xff; - can_mesg[6] = uint16_t(id(${yambms_id}_battery_capacity_remaining).state * 10) & 0xff; - can_mesg[7] = uint16_t(id(${yambms_id}_battery_capacity_remaining).state * 10) >> 8 & 0xff; + can_mesg[0] = uint16_t(id(yambms${yambms_id}_battery_soc).state) & 0xff; + can_mesg[1] = uint16_t(id(yambms${yambms_id}_battery_soc).state) >> 8 & 0xff; + can_mesg[2] = uint16_t(id(yambms${yambms_id}_battery_soh).state) & 0xff; + can_mesg[3] = uint16_t(id(yambms${yambms_id}_battery_soh).state) >> 8 & 0xff; + can_mesg[4] = uint16_t(id(yambms${yambms_id}_battery_soc).state * 100) & 0xff; + can_mesg[5] = uint16_t(id(yambms${yambms_id}_battery_soc).state * 100) >> 8 & 0xff; + can_mesg[6] = uint16_t(id(yambms${yambms_id}_battery_capacity_remaining).state * 10) & 0xff; + can_mesg[7] = uint16_t(id(yambms${yambms_id}_battery_capacity_remaining).state * 10) >> 8 & 0xff; // LuxPower // Byte [04:05] : Max Cell Voltage (1 mV) // Byte [06:07] : Min Cell voltage (1 mV) if (id(canbus${canbus_id}_protocol).active_index() == 5) { - int min_cell_voltage_i = id(${yambms_id}_min_cell_voltage).state * 1000.0; - int max_cell_voltage_i = id(${yambms_id}_max_cell_voltage).state * 1000.0; + int min_cell_voltage_i = id(yambms${yambms_id}_min_cell_voltage).state * 1000.0; + int max_cell_voltage_i = id(yambms${yambms_id}_max_cell_voltage).state * 1000.0; can_mesg[4] = max_cell_voltage_i & 0xff; can_mesg[5] = max_cell_voltage_i >> 8 & 0xff; can_mesg[6] = min_cell_voltage_i & 0xff; @@ -415,14 +415,14 @@ interval: uint8_t can_mesg[8]; - can_mesg[0] = uint16_t(id(${yambms_id}_total_voltage).state * 100) & 0xff; - can_mesg[1] = uint16_t(id(${yambms_id}_total_voltage).state * 100) >> 8 & 0xff; - can_mesg[2] = int16_t(id(${yambms_id}_current).state * 10) & 0xff; - can_mesg[3] = int16_t(id(${yambms_id}_current).state * 10) >> 8 & 0xff; - can_mesg[4] = int16_t(((id(${yambms_id}_min_temperature).state + id(${yambms_id}_max_temperature).state) / 2) * 10) & 0xff; - can_mesg[5] = int16_t(((id(${yambms_id}_min_temperature).state + id(${yambms_id}_max_temperature).state) / 2) * 10) >> 8 & 0xff; - can_mesg[6] = uint16_t(id(${yambms_id}_charging_cycles).state) & 0xff; - can_mesg[7] = uint16_t(id(${yambms_id}_charging_cycles).state) >> 8 & 0xff; + can_mesg[0] = uint16_t(id(yambms${yambms_id}_total_voltage).state * 100) & 0xff; + can_mesg[1] = uint16_t(id(yambms${yambms_id}_total_voltage).state * 100) >> 8 & 0xff; + can_mesg[2] = int16_t(id(yambms${yambms_id}_current).state * 10) & 0xff; + can_mesg[3] = int16_t(id(yambms${yambms_id}_current).state * 10) >> 8 & 0xff; + can_mesg[4] = int16_t(((id(yambms${yambms_id}_min_temperature).state + id(yambms${yambms_id}_max_temperature).state) / 2) * 10) & 0xff; + can_mesg[5] = int16_t(((id(yambms${yambms_id}_min_temperature).state + id(yambms${yambms_id}_max_temperature).state) / 2) * 10) >> 8 & 0xff; + can_mesg[6] = uint16_t(id(yambms${yambms_id}_charging_cycles).state) & 0xff; + can_mesg[7] = uint16_t(id(yambms${yambms_id}_charging_cycles).state) >> 8 & 0xff; // LuxPower // Byte [04:05] : Max cell temperature (0.1 °C) @@ -431,10 +431,10 @@ interval: if (id(canbus${canbus_id}_protocol).active_index() == 5) { // Added 0.1 °C safeguard to max temperature so that max and min values are never equal - can_mesg[4] = int16_t(id(${yambms_id}_max_temperature).state * 10 + 1) & 0xff; - can_mesg[5] = int16_t(id(${yambms_id}_max_temperature).state * 10 + 1) >> 8 & 0xff; - can_mesg[6] = int16_t(id(${yambms_id}_min_temperature).state * 10) & 0xff; - can_mesg[7] = int16_t(id(${yambms_id}_min_temperature).state * 10) >> 8 & 0xff; + can_mesg[4] = int16_t(id(yambms${yambms_id}_max_temperature).state * 10 + 1) & 0xff; + can_mesg[5] = int16_t(id(yambms${yambms_id}_max_temperature).state * 10 + 1) >> 8 & 0xff; + can_mesg[6] = int16_t(id(yambms${yambms_id}_min_temperature).state * 10) & 0xff; + can_mesg[7] = int16_t(id(yambms${yambms_id}_min_temperature).state * 10) >> 8 & 0xff; } ESP_LOGI("canbus", "send can_id: 0x356 hex: %x %x %x %x %x %x %x %x", can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]); @@ -449,8 +449,8 @@ interval: can_id: 0x359 data: !lambda |- uint8_t can_mesg[] = {0, 0, 0, 0, 0, 0, 0, 0}; - uint16_t errors_bitmask_alarm = id(${yambms_id}_errors_bitmask_alarm).state; - uint16_t errors_bitmask_warning = id(${yambms_id}_errors_bitmask_warning).state; + uint16_t errors_bitmask_alarm = id(yambms${yambms_id}_errors_bitmask_alarm).state; + uint16_t errors_bitmask_warning = id(yambms${yambms_id}_errors_bitmask_warning).state; // +---------------------------+ // | Alarm : byte 0 and 1 | @@ -494,7 +494,7 @@ interval: // | Flags : byte 4 to 7 | // +---------------------------+ - can_mesg[4] = id(${yambms_id}_bms_combined).state; // byte4 - Module in parallel (8bit uint max 255) + can_mesg[4] = id(yambms${yambms_id}_bms_combined).state; // byte4 - Module in parallel (8bit uint max 255) can_mesg[5] = 0x00; // byte5 - "P" 0x50 can_mesg[6] = 0x00; // byte6 - "N" 0x4E can_mesg[7] = 0x00; // byte7 @@ -503,8 +503,8 @@ interval: // Byte [05:06] : Battery Capacity (1 Ah) if (id(canbus${canbus_id}_protocol).active_index() == 5) { - can_mesg[5] = uint16_t(id(${yambms_id}_battery_capacity).state) & 0xff; - can_mesg[6] = uint16_t(id(${yambms_id}_battery_capacity).state) >> 8 & 0xff; + can_mesg[5] = uint16_t(id(yambms${yambms_id}_battery_capacity).state) & 0xff; + can_mesg[6] = uint16_t(id(yambms${yambms_id}_battery_capacity).state) >> 8 & 0xff; } ESP_LOGI("canbus", "send can_id: 0x359 hex: %x %x %x %x %x %x %x %x", can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]); @@ -529,19 +529,19 @@ interval: // Bit 3 : Request full charge // if () can_mesg[0] |= 0x8; // Bit 4 : Request force charge 2 (Deye will charge the battery from the grid to the charging voltage specified by the CAN bus and displays `Request Force Charge` on the screen) - if (id(${yambms_id}_requested_force_charge).state) can_mesg[0] |= 0x10; + if (id(yambms${yambms_id}_requested_force_charge).state) can_mesg[0] |= 0x10; // Bit 5 : Request force charge 1 (Deye will charge the battery from the grid to the charging voltage specified by the CAN bus and displays `Request Force Charge` on the screen) // if () can_mesg[0] |= 0x20; // Bit 6 : Discharge enable - if (id(${yambms_id}_discharging_instruction).state == true) can_mesg[0] |= 0x40; + if (id(yambms${yambms_id}_discharging_instruction).state == true) can_mesg[0] |= 0x40; // Bit 7 : Charge enable - if ((id(${yambms_id}_charging_instruction).state == "Bulk") || (id(${yambms_id}_charging_instruction).state == "Float")) can_mesg[0] |= 0x80; + if ((id(yambms${yambms_id}_charging_instruction).state == "Bulk") || (id(yambms${yambms_id}_charging_instruction).state == "Float")) can_mesg[0] |= 0x80; // LuxPower // Byte [02:03] : Cycle count (1 cycle) if (id(canbus${canbus_id}_protocol).active_index() == 5) { - can_mesg[2] = uint16_t(id(${yambms_id}_charging_cycles).state) & 0xff; - can_mesg[3] = uint16_t(id(${yambms_id}_charging_cycles).state) >> 8 & 0xff; + can_mesg[2] = uint16_t(id(yambms${yambms_id}_charging_cycles).state) & 0xff; + can_mesg[3] = uint16_t(id(yambms${yambms_id}_charging_cycles).state) >> 8 & 0xff; } ESP_LOGI("canbus", "send can_id: 0x35C hex: %x %x %x %x %x %x %x %x", can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]); @@ -559,8 +559,8 @@ interval: // https://github.com/dfch/BydCanProtocol uint8_t can_mesg[] = {0, 0, 0, 0, 0, 0, 0, 0}; - uint16_t errors_bitmask_alarm = id(${yambms_id}_errors_bitmask_alarm).state; - uint16_t errors_bitmask_warning = id(${yambms_id}_errors_bitmask_warning).state; + uint16_t errors_bitmask_alarm = id(yambms${yambms_id}_errors_bitmask_alarm).state; + uint16_t errors_bitmask_warning = id(yambms${yambms_id}_errors_bitmask_warning).state; // +---------------------------+ // | Alarm : byte 0 to 3 | @@ -626,8 +626,8 @@ interval: uint8_t can_mesg[] = {0, 0, 0, 0, 0, 0, 0, 0}; can_mesg[2] = 0x02; can_mesg[3] = 0x04; - can_mesg[4] = uint16_t(id(${yambms_id}_battery_capacity_remaining).state) & 0xff; - can_mesg[5] = uint16_t(id(${yambms_id}_battery_capacity_remaining).state) >> 8 & 0xff; + can_mesg[4] = uint16_t(id(yambms${yambms_id}_battery_capacity_remaining).state) & 0xff; + can_mesg[5] = uint16_t(id(yambms${yambms_id}_battery_capacity_remaining).state) >> 8 & 0xff; ESP_LOGI("canbus", "send can_id: 0x35F hex: %x %x %x %x %x %x %x %x", can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]); return {can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]}; @@ -645,16 +645,16 @@ interval: // Byte [04:05] : Max cell voltage (0.1 V) // Byte [06:07] : Min cell voltage (0.1 V) - int max_cell_voltage_i = id(${yambms_id}_max_cell_voltage).state * 100.0; - int min_cell_voltage_i = id(${yambms_id}_min_cell_voltage).state * 100.0; + int max_cell_voltage_i = id(yambms${yambms_id}_max_cell_voltage).state * 100.0; + int min_cell_voltage_i = id(yambms${yambms_id}_min_cell_voltage).state * 100.0; uint8_t can_mesg[8]; // Added 0.1 °C safeguard to max temperature so that max and min values are never equal - can_mesg[0] = int16_t(id(${yambms_id}_max_temperature).state * 10 + 1) & 0xff; - can_mesg[1] = int16_t(id(${yambms_id}_max_temperature).state * 10 + 1) >> 8 & 0xff; - can_mesg[2] = int16_t(id(${yambms_id}_min_temperature).state * 10) & 0xff; - can_mesg[3] = int16_t(id(${yambms_id}_min_temperature).state * 10) >> 8 & 0xff; + can_mesg[0] = int16_t(id(yambms${yambms_id}_max_temperature).state * 10 + 1) & 0xff; + can_mesg[1] = int16_t(id(yambms${yambms_id}_max_temperature).state * 10 + 1) >> 8 & 0xff; + can_mesg[2] = int16_t(id(yambms${yambms_id}_min_temperature).state * 10) & 0xff; + can_mesg[3] = int16_t(id(yambms${yambms_id}_min_temperature).state * 10) >> 8 & 0xff; can_mesg[4] = max_cell_voltage_i & 0xff; can_mesg[5] = max_cell_voltage_i >> 8 & 0xff; can_mesg[6] = min_cell_voltage_i & 0xff; @@ -678,14 +678,14 @@ interval: uint8_t can_mesg[8]; - can_mesg[0] = uint16_t(id(${yambms_id}_max_temperature_sensor).state) & 0xff; - can_mesg[1] = uint16_t(id(${yambms_id}_max_temperature_sensor).state) >> 8 & 0xff; - can_mesg[2] = uint16_t(id(${yambms_id}_min_temperature_sensor).state) & 0xff; - can_mesg[3] = uint16_t(id(${yambms_id}_min_temperature_sensor).state) >> 8 & 0xff; - can_mesg[4] = uint16_t(id(${yambms_id}_max_voltage_cell).state) & 0xff; - can_mesg[5] = uint16_t(id(${yambms_id}_max_voltage_cell).state) >> 8 & 0xff; - can_mesg[6] = uint16_t(id(${yambms_id}_min_voltage_cell).state) & 0xff; - can_mesg[7] = uint16_t(id(${yambms_id}_min_voltage_cell).state) >> 8 & 0xff; + can_mesg[0] = uint16_t(id(yambms${yambms_id}_max_temperature_sensor).state) & 0xff; + can_mesg[1] = uint16_t(id(yambms${yambms_id}_max_temperature_sensor).state) >> 8 & 0xff; + can_mesg[2] = uint16_t(id(yambms${yambms_id}_min_temperature_sensor).state) & 0xff; + can_mesg[3] = uint16_t(id(yambms${yambms_id}_min_temperature_sensor).state) >> 8 & 0xff; + can_mesg[4] = uint16_t(id(yambms${yambms_id}_max_voltage_cell).state) & 0xff; + can_mesg[5] = uint16_t(id(yambms${yambms_id}_max_voltage_cell).state) >> 8 & 0xff; + can_mesg[6] = uint16_t(id(yambms${yambms_id}_min_voltage_cell).state) & 0xff; + can_mesg[7] = uint16_t(id(yambms${yambms_id}_min_voltage_cell).state) >> 8 & 0xff; ESP_LOGI("canbus", "send can_id: 0x371 hex: %x %x %x %x %x %x %x %x", can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]); return {can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]}; @@ -704,10 +704,10 @@ interval: // Byte [06:07] : Nbr. of battery modules offline uint8_t can_mesg[] = {0, 0, 0, 0, 0, 0, 0, 0}; - can_mesg[0] = id(${yambms_id}_bms_combined).state; - can_mesg[2] = id(${yambms_id}_bms_blocking_charge).state; - can_mesg[4] = id(${yambms_id}_bms_blocking_discharge).state; - can_mesg[6] = (id(${yambms_id}_bms_count).state - id(${yambms_id}_bms_combined).state); + can_mesg[0] = id(yambms${yambms_id}_bms_combined).state; + can_mesg[2] = id(yambms${yambms_id}_bms_blocking_charge).state; + can_mesg[4] = id(yambms${yambms_id}_bms_blocking_discharge).state; + can_mesg[6] = (id(yambms${yambms_id}_bms_count).state - id(yambms${yambms_id}_bms_combined).state); ESP_LOGI("canbus", "send can_id: 0x372 hex: %x %x %x %x %x %x %x %x", can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]); return {can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]}; @@ -725,10 +725,10 @@ interval: // Byte [04:05] : Min cell temperature (1 Kelvin) // Byte [06:07] : Max cell temperature (1 Kelvin) - int min_cell_voltage_i = id(${yambms_id}_min_cell_voltage).state * 1000.0; - int max_cell_voltage_i = id(${yambms_id}_max_cell_voltage).state * 1000.0; - int min_temp_kelvin = id(${yambms_id}_min_temperature).state + 273.15; - int max_temp_kelvin = id(${yambms_id}_max_temperature).state + 273.15; + int min_cell_voltage_i = id(yambms${yambms_id}_min_cell_voltage).state * 1000.0; + int max_cell_voltage_i = id(yambms${yambms_id}_max_cell_voltage).state * 1000.0; + int min_temp_kelvin = id(yambms${yambms_id}_min_temperature).state + 273.15; + int max_temp_kelvin = id(yambms${yambms_id}_max_temperature).state + 273.15; uint8_t can_mesg[8]; can_mesg[0] = min_cell_voltage_i & 0xff; @@ -751,7 +751,7 @@ interval: canbus_id: ${canbus_node_id} can_id: 0x374 data: !lambda |- - int cell_id = id(${yambms_id}_min_voltage_cell).state; + int cell_id = id(yambms${yambms_id}_min_voltage_cell).state; // init 8 bytes char array values char can_mesg[] = {0, 0, 0, 0, 0, 0, 0, 0}; // save int cell_id to 8 bytes char array @@ -769,7 +769,7 @@ interval: canbus_id: ${canbus_node_id} can_id: 0x375 data: !lambda |- - int cell_id = id(${yambms_id}_max_voltage_cell).state; + int cell_id = id(yambms${yambms_id}_max_voltage_cell).state; // init 8 bytes char array values char can_mesg[] = {0, 0, 0, 0, 0, 0, 0, 0}; // save int cell_id to 8 bytes char array @@ -787,7 +787,7 @@ interval: canbus_id: ${canbus_node_id} can_id: 0x376 data: !lambda |- - int sensor_id = id(${yambms_id}_min_temperature_sensor).state; + int sensor_id = id(yambms${yambms_id}_min_temperature_sensor).state; // init 8 bytes char array values char can_mesg[] = {0, 0, 0, 0, 0, 0, 0, 0}; // save int sensor_id to 8 bytes char array @@ -805,7 +805,7 @@ interval: canbus_id: ${canbus_node_id} can_id: 0x377 data: !lambda |- - int sensor_id = id(${yambms_id}_max_temperature_sensor).state; + int sensor_id = id(yambms${yambms_id}_max_temperature_sensor).state; // init 8 bytes char array values char can_mesg[] = {0, 0, 0, 0, 0, 0, 0, 0}; // save int sensor_id to 8 bytes char array @@ -824,8 +824,8 @@ interval: can_id: 0x379 data: !lambda |- uint8_t can_mesg[] = {0, 0, 0, 0, 0, 0, 0, 0}; - can_mesg[0] = uint16_t(id(${yambms_id}_installed_battery_capacity).state) & 0xff; - can_mesg[1] = uint16_t(id(${yambms_id}_installed_battery_capacity).state) >> 8 & 0xff; + can_mesg[0] = uint16_t(id(yambms${yambms_id}_installed_battery_capacity).state) & 0xff; + can_mesg[1] = uint16_t(id(yambms${yambms_id}_installed_battery_capacity).state) >> 8 & 0xff; ESP_LOGI("canbus", "send can_id: 0x379 hex: %x %x %x %x %x %x %x %x", can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]); return {can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]}; @@ -852,7 +852,7 @@ interval: uint8_t can_mesg[] = {0, 0, 0, 0, 0, 0, 0, 0}; // Byte 0 : Force charge instruction - if (id(${yambms_id}_requested_force_charge).state) can_mesg[0] = 0xFF; + if (id(yambms${yambms_id}_requested_force_charge).state) can_mesg[0] = 0xFF; ESP_LOGI("canbus", "send can_id: 0x360 hex: %x %x %x %x %x %x %x %x", can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]); return {can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]}; @@ -881,8 +881,8 @@ interval: // Byte [04:05] : Max cell temperature (0.1 °C) // Byte [06:07] : Min cell temperature (0.1 °C) - int max_cell_voltage_i = id(${yambms_id}_max_cell_voltage).state * 100.0; - int min_cell_voltage_i = id(${yambms_id}_min_cell_voltage).state * 100.0; + int max_cell_voltage_i = id(yambms${yambms_id}_max_cell_voltage).state * 100.0; + int min_cell_voltage_i = id(yambms${yambms_id}_min_cell_voltage).state * 100.0; uint8_t can_mesg[8]; can_mesg[0] = max_cell_voltage_i & 0xff; @@ -890,10 +890,10 @@ interval: can_mesg[2] = min_cell_voltage_i & 0xff; can_mesg[3] = min_cell_voltage_i >> 8 & 0xff; // Added 0.1 °C safeguard to max temperature so that max and min values are never equal - can_mesg[4] = int16_t(id(${yambms_id}_max_temperature).state * 10 + 1) & 0xff; - can_mesg[5] = int16_t(id(${yambms_id}_max_temperature).state * 10 + 1) >> 8 & 0xff; - can_mesg[6] = int16_t(id(${yambms_id}_min_temperature).state * 10) & 0xff; - can_mesg[7] = int16_t(id(${yambms_id}_min_temperature).state * 10) >> 8 & 0xff; + can_mesg[4] = int16_t(id(yambms${yambms_id}_max_temperature).state * 10 + 1) & 0xff; + can_mesg[5] = int16_t(id(yambms${yambms_id}_max_temperature).state * 10 + 1) >> 8 & 0xff; + can_mesg[6] = int16_t(id(yambms${yambms_id}_min_temperature).state * 10) & 0xff; + can_mesg[7] = int16_t(id(yambms${yambms_id}_min_temperature).state * 10) >> 8 & 0xff; ESP_LOGI("canbus", "send can_id: 0x361 hex: %x %x %x %x %x %x %x %x", can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]); return {can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]}; @@ -927,11 +927,11 @@ interval: // Byte [04] : Number of battery modules total uint8_t can_mesg[] = {0, 0, 0, 0, 0, 0, 0, 0}; - can_mesg[0] = id(${yambms_id}_bms_combined).state; - can_mesg[1] = id(${yambms_id}_bms_blocking_charge).state; - can_mesg[2] = id(${yambms_id}_bms_blocking_discharge).state; - can_mesg[3] = (id(${yambms_id}_bms_count).state - id(${yambms_id}_bms_combined).state); - can_mesg[4] = id(${yambms_id}_bms_count).state; + can_mesg[0] = id(yambms${yambms_id}_bms_combined).state; + can_mesg[1] = id(yambms${yambms_id}_bms_blocking_charge).state; + can_mesg[2] = id(yambms${yambms_id}_bms_blocking_discharge).state; + can_mesg[3] = (id(yambms${yambms_id}_bms_count).state - id(yambms${yambms_id}_bms_combined).state); + can_mesg[4] = id(yambms${yambms_id}_bms_count).state; ESP_LOGI("canbus", "send can_id: 0x364 hex: %x %x %x %x %x %x %x %x", can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]); return {can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]}; @@ -949,10 +949,10 @@ interval: // Byte [02:03] = DCL : Discharge Limit Current (0.1 A) uint8_t can_mesg[] = {0, 0, 0, 0, 0, 0, 0, 0}; - can_mesg[0] = uint16_t(id(${yambms_id}_requested_charge_current).state * 10) & 0xff; - can_mesg[1] = uint16_t(id(${yambms_id}_requested_charge_current).state * 10) >> 8 & 0xff; - can_mesg[2] = uint16_t(id(${yambms_id}_requested_discharge_current).state * 10) & 0xff; - can_mesg[3] = uint16_t(id(${yambms_id}_requested_discharge_current).state * 10) >> 8 & 0xff; + can_mesg[0] = uint16_t(id(yambms${yambms_id}_requested_charge_current).state * 10) & 0xff; + can_mesg[1] = uint16_t(id(yambms${yambms_id}_requested_charge_current).state * 10) >> 8 & 0xff; + can_mesg[2] = uint16_t(id(yambms${yambms_id}_requested_discharge_current).state * 10) & 0xff; + can_mesg[3] = uint16_t(id(yambms${yambms_id}_requested_discharge_current).state * 10) >> 8 & 0xff; ESP_LOGI("canbus", "send can_id: 0x371 hex: %x %x %x %x %x %x %x %x", can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]); return {can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3], can_mesg[4], can_mesg[5], can_mesg[6], can_mesg[7]}; diff --git a/packages/yambms/yambms_core.yaml b/packages/yambms/yambms_core.yaml index c274abe..fe74822 100644 --- a/packages/yambms/yambms_core.yaml +++ b/packages/yambms/yambms_core.yaml @@ -1,4 +1,4 @@ -# Updated : 2026.03.23 +# Updated : 2026.06.27 # Version : 1.7.0 # GitHub : https://github.com/Sleeper85/esphome-yambms @@ -22,287 +22,287 @@ substitutions: globals: # BMS - - id: ${yambms_id}_var_bms_counter + - id: yambms${yambms_id}_var_bms_counter type: int restore_value: no initial_value: '0' - - id: ${yambms_id}_var_to_combine_bms_number + - id: yambms${yambms_id}_var_to_combine_bms_number type: int restore_value: no initial_value: '1' - - id: ${yambms_id}_var_to_combine_bms_counter + - id: yambms${yambms_id}_var_to_combine_bms_counter type: int restore_value: no initial_value: '0' - - id: ${yambms_id}_var_bms_online_bitmask + - id: yambms${yambms_id}_var_bms_online_bitmask type: int restore_value: no initial_value: '0' - - id: ${yambms_id}_var_bms_seen_online_bitmask + - id: yambms${yambms_id}_var_bms_seen_online_bitmask type: int restore_value: no initial_value: '0' - - id: ${yambms_id}_var_errors_bitmask_counter + - id: yambms${yambms_id}_var_errors_bitmask_counter type: int restore_value: no initial_value: '0' - - id: ${yambms_id}_var_errors_bitmask + - id: yambms${yambms_id}_var_errors_bitmask type: int restore_value: no initial_value: '0' - - id: ${yambms_id}_var_equalizing_counter + - id: yambms${yambms_id}_var_equalizing_counter type: int restore_value: no initial_value: '0' - - id: ${yambms_id}_var_charging_allowed_counter + - id: yambms${yambms_id}_var_charging_allowed_counter type: int restore_value: no initial_value: '0' - - id: ${yambms_id}_var_discharging_allowed_counter + - id: yambms${yambms_id}_var_discharging_allowed_counter type: int restore_value: no initial_value: '0' - - id: ${yambms_id}_var_bms_blocking_charge_counter + - id: yambms${yambms_id}_var_bms_blocking_charge_counter type: int restore_value: no initial_value: '0' - - id: ${yambms_id}_var_bms_blocking_discharge_counter + - id: yambms${yambms_id}_var_bms_blocking_discharge_counter type: int restore_value: no initial_value: '0' - - id: ${yambms_id}_var_min_voltage_cell + - id: yambms${yambms_id}_var_min_voltage_cell type: int restore_value: no initial_value: '0' - - id: ${yambms_id}_var_max_voltage_cell + - id: yambms${yambms_id}_var_max_voltage_cell type: int restore_value: no initial_value: '0' - - id: ${yambms_id}_var_min_cell_voltage + - id: yambms${yambms_id}_var_min_cell_voltage type: float restore_value: no initial_value: '5.0' - - id: ${yambms_id}_var_max_cell_voltage + - id: yambms${yambms_id}_var_max_cell_voltage type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_total_max_charge_current + - id: yambms${yambms_id}_var_total_max_charge_current type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_total_max_discharge_current + - id: yambms${yambms_id}_var_total_max_discharge_current type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_total_installed_battery_capacity + - id: yambms${yambms_id}_var_total_installed_battery_capacity type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_total_battery_capacity + - id: yambms${yambms_id}_var_total_battery_capacity type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_total_battery_capacity_remaining + - id: yambms${yambms_id}_var_total_battery_capacity_remaining type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_total_charging_cycles + - id: yambms${yambms_id}_var_total_charging_cycles type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_min_cell_ovp + - id: yambms${yambms_id}_var_min_cell_ovp type: float restore_value: no initial_value: '5.0' - - id: ${yambms_id}_var_max_cell_uvp + - id: yambms${yambms_id}_var_max_cell_uvp type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_max_balance_trigger_voltage + - id: yambms${yambms_id}_var_max_balance_trigger_voltage type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_min_temperature + - id: yambms${yambms_id}_var_min_temperature type: float restore_value: no initial_value: '100.0' - - id: ${yambms_id}_var_min_temperature_sensor + - id: yambms${yambms_id}_var_min_temperature_sensor type: int restore_value: no initial_value: '0' - - id: ${yambms_id}_var_max_temperature + - id: yambms${yambms_id}_var_max_temperature type: float restore_value: no initial_value: '-100.0' - - id: ${yambms_id}_var_max_temperature_sensor + - id: yambms${yambms_id}_var_max_temperature_sensor type: int restore_value: no initial_value: '0' - - id: ${yambms_id}_var_bms_total_voltage + - id: yambms${yambms_id}_var_bms_total_voltage type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_bms_total_current + - id: yambms${yambms_id}_var_bms_total_current type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_bms_total_power + - id: yambms${yambms_id}_var_bms_total_power type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_bms_total_soc + - id: yambms${yambms_id}_var_bms_total_soc type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_bms_total_soh + - id: yambms${yambms_id}_var_bms_total_soh type: float restore_value: no initial_value: '0.0' # Shunt - - id: ${yambms_id}_var_shunt_use + - id: yambms${yambms_id}_var_shunt_use type: bool restore_value: no initial_value: "false" - - id: ${yambms_id}_var_shunt_counter + - id: yambms${yambms_id}_var_shunt_counter type: int restore_value: no initial_value: '0' - - id: ${yambms_id}_var_to_combine_shunt_number + - id: yambms${yambms_id}_var_to_combine_shunt_number type: int restore_value: no initial_value: '1' - - id: ${yambms_id}_var_to_combine_shunt_counter + - id: yambms${yambms_id}_var_to_combine_shunt_counter type: int restore_value: no initial_value: '0' - - id: ${yambms_id}_var_shunt_total_voltage + - id: yambms${yambms_id}_var_shunt_total_voltage type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_shunt_total_current + - id: yambms${yambms_id}_var_shunt_total_current type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_shunt_total_power + - id: yambms${yambms_id}_var_shunt_total_power type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_shunt_total_soc + - id: yambms${yambms_id}_var_shunt_total_soc type: float restore_value: no initial_value: '0.0' # YamBMS - - id: ${yambms_id}_var_service + - id: yambms${yambms_id}_var_service type: bool restore_value: no initial_value: 'true' - - id: ${yambms_id}_var_initialized + - id: yambms${yambms_id}_var_initialized type: bool restore_value: no initial_value: 'false' - - id: ${yambms_id}_var_requested_ccl_init + - id: yambms${yambms_id}_var_requested_ccl_init type: bool restore_value: no initial_value: 'false' - - id: ${yambms_id}_var_requested_dcl_init + - id: yambms${yambms_id}_var_requested_dcl_init type: bool restore_value: no initial_value: 'false' - - id: ${yambms_id}_var_bms_charging_logic + - id: yambms${yambms_id}_var_bms_charging_logic type: bool restore_value: no initial_value: 'false' - - id: ${yambms_id}_var_force_float + - id: yambms${yambms_id}_var_force_float type: bool restore_value: no initial_value: 'false' - - id: ${yambms_id}_var_charge_status + - id: yambms${yambms_id}_var_charge_status type: std::string restore_value: no initial_value: '"Init"' - - id: ${yambms_id}_var_inverter_bms_name + - id: yambms${yambms_id}_var_inverter_bms_name type: std::string restore_value: no - - id: ${yambms_id}_var_inverter_protocol + - id: yambms${yambms_id}_var_inverter_protocol type: std::string restore_value: no - - id: ${yambms_id}_var_cell_nominal_v + - id: yambms${yambms_id}_var_cell_nominal_v type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_cell_min_charge_v + - id: yambms${yambms_id}_var_cell_min_charge_v type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_cell_max_charge_v + - id: yambms${yambms_id}_var_cell_max_charge_v type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_cell_max_discharge_v + - id: yambms${yambms_id}_var_cell_max_discharge_v type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_charge_current_step + - id: yambms${yambms_id}_var_charge_current_step type: int restore_value: no initial_value: '0' - - id: ${yambms_id}_var_discharge_current_step + - id: yambms${yambms_id}_var_discharge_current_step type: int restore_value: no initial_value: '0' - - id: ${yambms_id}_var_auto_ccl_functions_count + - id: yambms${yambms_id}_var_auto_ccl_functions_count type: int restore_value: no initial_value: '0' - - id: ${yambms_id}_var_auto_dcl_functions_count + - id: yambms${yambms_id}_var_auto_dcl_functions_count type: int restore_value: no initial_value: '0' - - id: ${yambms_id}_var_auto_cvl + - id: yambms${yambms_id}_var_auto_cvl type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_auto_ccl + - id: yambms${yambms_id}_var_auto_ccl type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_auto_dcl + - id: yambms${yambms_id}_var_auto_dcl type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_auto_temperature_ccl + - id: yambms${yambms_id}_var_auto_temperature_ccl type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_auto_temperature_dcl + - id: yambms${yambms_id}_var_auto_temperature_dcl type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_auto_ccl_soft_landing + - id: yambms${yambms_id}_var_auto_ccl_soft_landing type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_auto_eoc + - id: yambms${yambms_id}_var_auto_eoc type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_auto_float + - id: yambms${yambms_id}_var_auto_float type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_auto_soc_limit + - id: yambms${yambms_id}_var_auto_soc_limit type: float restore_value: no initial_value: '0.0' - - id: ${yambms_id}_var_eoc + - id: yambms${yambms_id}_var_eoc type: bool restore_value: no initial_value: 'false' - - id: ${yambms_id}_var_eoc_timestamp + - id: yambms${yambms_id}_var_eoc_timestamp type: time_t restore_value: true initial_value: '' - - id: ${yambms_id}_var_rebulk_days_active + - id: yambms${yambms_id}_var_rebulk_days_active type: bool restore_value: no initial_value: 'false' @@ -311,7 +311,7 @@ esphome: # The 'devices' block will merge into the main config's 'esphome' block. # The ID and Name are uniquely defined by the vars passed in the main config. devices: - - id: yambms_${yambms_id} + - id: yambms_yambms${yambms_id} name: "${yambms_name}" # Execute once @@ -325,37 +325,37 @@ esphome: if (${yambms_battery_chemistry} == 1) // LFP { // LFP - id(${yambms_id}_var_cell_nominal_v) = 3.20; - id(${yambms_id}_var_cell_min_charge_v) = 3.37; // Fully charged at rest - id(${yambms_id}_var_cell_max_charge_v) = 3.65; - id(${yambms_id}_var_cell_max_discharge_v) = 3.00; // Not used + id(yambms${yambms_id}_var_cell_nominal_v) = 3.20; + id(yambms${yambms_id}_var_cell_min_charge_v) = 3.37; // Fully charged at rest + id(yambms${yambms_id}_var_cell_max_charge_v) = 3.65; + id(yambms${yambms_id}_var_cell_max_discharge_v) = 3.00; // Not used } else if (${yambms_battery_chemistry} == 2) // Li-ion { // Li-ion - id(${yambms_id}_var_cell_nominal_v) = 3.60; - id(${yambms_id}_var_cell_min_charge_v) = 3.90; - id(${yambms_id}_var_cell_max_charge_v) = 4.20; - id(${yambms_id}_var_cell_max_discharge_v) = 3.20; // Not used + id(yambms${yambms_id}_var_cell_nominal_v) = 3.60; + id(yambms${yambms_id}_var_cell_min_charge_v) = 3.90; + id(yambms${yambms_id}_var_cell_max_charge_v) = 4.20; + id(yambms${yambms_id}_var_cell_max_discharge_v) = 3.20; // Not used } else if (${yambms_battery_chemistry} == 3) // LTO { // LTO - id(${yambms_id}_var_cell_nominal_v) = 2.40; - id(${yambms_id}_var_cell_min_charge_v) = 2.55; // Fully charged at rest - id(${yambms_id}_var_cell_max_charge_v) = 2.85; - id(${yambms_id}_var_cell_max_discharge_v) = 2.00; // Not used + id(yambms${yambms_id}_var_cell_nominal_v) = 2.40; + id(yambms${yambms_id}_var_cell_min_charge_v) = 2.55; // Fully charged at rest + id(yambms${yambms_id}_var_cell_max_charge_v) = 2.85; + id(yambms${yambms_id}_var_cell_max_discharge_v) = 2.00; // Not used } int cell_count = ${yambms_cell_count}; // Bulk V. - id(${yambms_id}_bulk_voltage).traits.set_min_value(round(cell_count * id(${yambms_id}_var_cell_min_charge_v) * 10) / 10); - id(${yambms_id}_bulk_voltage).traits.set_max_value(round(cell_count * id(${yambms_id}_var_cell_max_charge_v) * 10) / 10); + id(yambms${yambms_id}_bulk_voltage).traits.set_min_value(round(cell_count * id(yambms${yambms_id}_var_cell_min_charge_v) * 10) / 10); + id(yambms${yambms_id}_bulk_voltage).traits.set_max_value(round(cell_count * id(yambms${yambms_id}_var_cell_max_charge_v) * 10) / 10); // Float V. - id(${yambms_id}_float_voltage).traits.set_min_value(round(cell_count * (id(${yambms_id}_var_cell_min_charge_v) - 0.15) * 10) / 10); - id(${yambms_id}_float_voltage).traits.set_max_value(round(cell_count * (id(${yambms_id}_var_cell_min_charge_v) + 0.05) * 10) / 10); + id(yambms${yambms_id}_float_voltage).traits.set_min_value(round(cell_count * (id(yambms${yambms_id}_var_cell_min_charge_v) - 0.15) * 10) / 10); + id(yambms${yambms_id}_float_voltage).traits.set_max_value(round(cell_count * (id(yambms${yambms_id}_var_cell_min_charge_v) + 0.05) * 10) / 10); // Rebulk V. - id(${yambms_id}_rebulk_voltage).traits.set_min_value(round(cell_count * id(${yambms_id}_var_cell_nominal_v) * 10) / 10); - id(${yambms_id}_rebulk_voltage).traits.set_max_value(round(cell_count * id(${yambms_id}_var_cell_min_charge_v) * 10) / 10); + id(yambms${yambms_id}_rebulk_voltage).traits.set_min_value(round(cell_count * id(yambms${yambms_id}_var_cell_nominal_v) * 10) / 10); + id(yambms${yambms_id}_rebulk_voltage).traits.set_max_value(round(cell_count * id(yambms${yambms_id}_var_cell_min_charge_v) * 10) / 10); # YamBMS core lambda interval: @@ -366,18 +366,18 @@ interval: // | STEP 2 - YamBMS combiner | // +-----------------------------------------------+ // If all device have communicated their informations - int device_counter = (id(${yambms_id}_var_bms_counter) + id(${yambms_id}_var_shunt_counter)); - int processed_device_counter = (id(${yambms_id}_var_to_combine_bms_number) + id(${yambms_id}_var_to_combine_shunt_number)); + int device_counter = (id(yambms${yambms_id}_var_bms_counter) + id(yambms${yambms_id}_var_shunt_counter)); + int processed_device_counter = (id(yambms${yambms_id}_var_to_combine_bms_number) + id(yambms${yambms_id}_var_to_combine_shunt_number)); if ((device_counter + 2) == processed_device_counter) { ESP_LOGD("yambms_debug", "===> STEP 2 : Entering YamBMS combiner... <==="); // No combined BMS > YamBMS need to be re-initialized - if (id(${yambms_id}_var_to_combine_bms_counter) == 0) + if (id(yambms${yambms_id}_var_to_combine_bms_counter) == 0) { - id(${yambms_id}_var_initialized) = false; - id(${yambms_id}_var_requested_ccl_init) = false; - id(${yambms_id}_var_requested_dcl_init) = false; + id(yambms${yambms_id}_var_initialized) = false; + id(yambms${yambms_id}_var_requested_ccl_init) = false; + id(yambms${yambms_id}_var_requested_dcl_init) = false; } // +-----------------------------------------------+ @@ -386,17 +386,17 @@ interval: // Alarm // Alarm - all BMS are in alarm ? - if (id(${yambms_id}_var_errors_bitmask_counter) == id(${yambms_id}_var_bms_counter)) - id(${yambms_id}_errors_bitmask_alarm).publish_state(id(${yambms_id}_var_errors_bitmask)); + if (id(yambms${yambms_id}_var_errors_bitmask_counter) == id(yambms${yambms_id}_var_bms_counter)) + id(yambms${yambms_id}_errors_bitmask_alarm).publish_state(id(yambms${yambms_id}_var_errors_bitmask)); // At least one BMS is not in alarm - else id(${yambms_id}_errors_bitmask_alarm).publish_state(0); + else id(yambms${yambms_id}_errors_bitmask_alarm).publish_state(0); // Warning - id(${yambms_id}_errors_bitmask_warning).publish_state(id(${yambms_id}_var_errors_bitmask)); + id(yambms${yambms_id}_errors_bitmask_warning).publish_state(id(yambms${yambms_id}_var_errors_bitmask)); // BMS in alarms count - id(${yambms_id}_errors_bitmask_counter).publish_state(id(${yambms_id}_var_errors_bitmask_counter)); + id(yambms${yambms_id}_errors_bitmask_counter).publish_state(id(yambms${yambms_id}_var_errors_bitmask_counter)); // +-----------------------------------------------+ // | Voltage, Current, Power, SOC, SOH, Ch. Cycles | @@ -415,25 +415,25 @@ interval: // +-----------------------------------------------+ // | At least one BMS can be combined | // +-----------------------------------------------+ - if (id(${yambms_id}_var_to_combine_bms_counter) > 0) + if (id(yambms${yambms_id}_var_to_combine_bms_counter) > 0) { // MEAN total_voltage (Shunt/BMS) - if (id(${yambms_id}_var_shunt_use) == true) - total_voltage = (id(${yambms_id}_var_shunt_total_voltage) / id(${yambms_id}_var_to_combine_shunt_counter)); + if (id(yambms${yambms_id}_var_shunt_use) == true) + total_voltage = (id(yambms${yambms_id}_var_shunt_total_voltage) / id(yambms${yambms_id}_var_to_combine_shunt_counter)); else - total_voltage = (id(${yambms_id}_var_bms_total_voltage) / id(${yambms_id}_var_to_combine_bms_counter)); + total_voltage = (id(yambms${yambms_id}_var_bms_total_voltage) / id(yambms${yambms_id}_var_to_combine_bms_counter)); // TOTAL current (Shunt/BMS) - if (id(${yambms_id}_var_shunt_use) == true) - current = id(${yambms_id}_var_shunt_total_current); + if (id(yambms${yambms_id}_var_shunt_use) == true) + current = id(yambms${yambms_id}_var_shunt_total_current); else - current = id(${yambms_id}_var_bms_total_current); + current = id(yambms${yambms_id}_var_bms_total_current); // TOTAL power (Shunt/BMS) - if (id(${yambms_id}_var_shunt_use) == true) - power = round(id(${yambms_id}_var_shunt_total_power)); + if (id(yambms${yambms_id}_var_shunt_use) == true) + power = round(id(yambms${yambms_id}_var_shunt_total_power)); else - power = round(id(${yambms_id}_var_bms_total_power)); + power = round(id(yambms${yambms_id}_var_bms_total_power)); // battery_charging_power if (power > 0) @@ -444,61 +444,61 @@ interval: battery_discharging_power = power * -1; // Must be positive energy // MEAN Battery SOC (Shunt/BMS) - if (id(${yambms_id}_var_shunt_use) == true) - soc = round(id(${yambms_id}_var_shunt_total_soc) / id(${yambms_id}_var_to_combine_shunt_counter)); - else if (id(${yambms_id}_var_total_battery_capacity) > 0) - soc = round(id(${yambms_id}_var_total_battery_capacity_remaining) / id(${yambms_id}_var_total_battery_capacity) * 100); + if (id(yambms${yambms_id}_var_shunt_use) == true) + soc = round(id(yambms${yambms_id}_var_shunt_total_soc) / id(yambms${yambms_id}_var_to_combine_shunt_counter)); + else if (id(yambms${yambms_id}_var_total_battery_capacity) > 0) + soc = round(id(yambms${yambms_id}_var_total_battery_capacity_remaining) / id(yambms${yambms_id}_var_total_battery_capacity) * 100); // SOC manipulation - if (id(${yambms_id}_var_to_combine_bms_counter) == 0) soc = 0; // no BMS combined => sending 0% - else if ((soc > 98) && (id(${yambms_id}_var_eoc) == false)) soc = 98; // Useful for some inverters stopping charging when SoC reaches 100% + if (id(yambms${yambms_id}_var_to_combine_bms_counter) == 0) soc = 0; // no BMS combined => sending 0% + else if ((soc > 98) && (id(yambms${yambms_id}_var_eoc) == false)) soc = 98; // Useful for some inverters stopping charging when SoC reaches 100% // MEAN Battery SOH - soh = round(id(${yambms_id}_var_bms_total_soh) / id(${yambms_id}_var_to_combine_bms_counter)); + soh = round(id(yambms${yambms_id}_var_bms_total_soh) / id(yambms${yambms_id}_var_to_combine_bms_counter)); // MEAN charging_cycles - charging_cycles = round(id(${yambms_id}_var_total_charging_cycles) / id(${yambms_id}_var_to_combine_bms_counter)); + charging_cycles = round(id(yambms${yambms_id}_var_total_charging_cycles) / id(yambms${yambms_id}_var_to_combine_bms_counter)); } // Publishing sensors - id(${yambms_id}_total_voltage).publish_state(total_voltage); - id(${yambms_id}_current).publish_state(current); - id(${yambms_id}_power).publish_state(power); - id(${yambms_id}_battery_charging_power).publish_state(battery_charging_power); - id(${yambms_id}_battery_discharging_power).publish_state(battery_discharging_power); - id(${yambms_id}_battery_soc).publish_state(soc); - id(${yambms_id}_battery_soh).publish_state(soh); - id(${yambms_id}_charging_cycles).publish_state(charging_cycles); + id(yambms${yambms_id}_total_voltage).publish_state(total_voltage); + id(yambms${yambms_id}_current).publish_state(current); + id(yambms${yambms_id}_power).publish_state(power); + id(yambms${yambms_id}_battery_charging_power).publish_state(battery_charging_power); + id(yambms${yambms_id}_battery_discharging_power).publish_state(battery_discharging_power); + id(yambms${yambms_id}_battery_soc).publish_state(soc); + id(yambms${yambms_id}_battery_soh).publish_state(soh); + id(yambms${yambms_id}_charging_cycles).publish_state(charging_cycles); // +-----------------------------------------------+ // | TOTAL battery_capacity | // +-----------------------------------------------+ - float battery_capacity = id(${yambms_id}_var_total_battery_capacity); - id(${yambms_id}_battery_capacity).publish_state(round(battery_capacity)); + float battery_capacity = id(yambms${yambms_id}_var_total_battery_capacity); + id(yambms${yambms_id}_battery_capacity).publish_state(round(battery_capacity)); // +-----------------------------------------------+ // | TOTAL battery_capacity_remaining | // +-----------------------------------------------+ - float capacity_remaining = id(${yambms_id}_var_total_battery_capacity_remaining); + float capacity_remaining = id(yambms${yambms_id}_var_total_battery_capacity_remaining); - if (id(${yambms_id}_var_shunt_use) == true) + if (id(yambms${yambms_id}_var_shunt_use) == true) capacity_remaining = battery_capacity / 100 * soc; - id(${yambms_id}_battery_capacity_remaining).publish_state(round(capacity_remaining)); + id(yambms${yambms_id}_battery_capacity_remaining).publish_state(round(capacity_remaining)); // +-----------------------------------------------+ // | Max charge current | // +-----------------------------------------------+ - int cc_step = id(${yambms_id}_var_charge_current_step); + int cc_step = id(yambms${yambms_id}_var_charge_current_step); ESP_LOGD("yambms_debug", "Entering Max charge current..."); float max_charge_current = 0.0; - if (id(${yambms_id}_var_to_combine_bms_counter) > 0) + if (id(yambms${yambms_id}_var_to_combine_bms_counter) > 0) { - float max_charge_current_yambms = id(${yambms_id}_max_requested_charge_current).state; - float max_charge_current_bms = id(${yambms_id}_var_total_max_charge_current) * 0.9; + float max_charge_current_yambms = id(yambms${yambms_id}_max_requested_charge_current).state; + float max_charge_current_bms = id(yambms${yambms_id}_var_total_max_charge_current) * 0.9; if (max_charge_current_bms > max_charge_current_yambms) max_charge_current = max_charge_current_yambms; @@ -508,24 +508,24 @@ interval: ESP_LOGD("yambms_debug", "Max charge current YamBMS : %f A", max_charge_current_yambms); ESP_LOGD("yambms_debug", "Max charge current BMS : %f A", max_charge_current_bms); - if (cc_step == 0) id(${yambms_id}_var_charge_current_step) = 1; + if (cc_step == 0) id(yambms${yambms_id}_var_charge_current_step) = 1; } - id(${yambms_id}_max_charge_current).publish_state(round(max_charge_current)); + id(yambms${yambms_id}_max_charge_current).publish_state(round(max_charge_current)); ESP_LOGD("yambms_debug", "Max charge current : %f A", max_charge_current); // +-----------------------------------------------+ // | Max discharge current | // +-----------------------------------------------+ - int dc_step = id(${yambms_id}_var_discharge_current_step); + int dc_step = id(yambms${yambms_id}_var_discharge_current_step); ESP_LOGD("yambms_debug", "Entering Max discharge current..."); float max_discharge_current = 0.0; - if (id(${yambms_id}_var_to_combine_bms_counter) > 0) + if (id(yambms${yambms_id}_var_to_combine_bms_counter) > 0) { - float max_discharge_current_yambms = id(${yambms_id}_max_requested_discharge_current).state; - float max_discharge_current_bms = id(${yambms_id}_var_total_max_discharge_current) * 0.9; + float max_discharge_current_yambms = id(yambms${yambms_id}_max_requested_discharge_current).state; + float max_discharge_current_bms = id(yambms${yambms_id}_var_total_max_discharge_current) * 0.9; if (max_discharge_current_bms > max_discharge_current_yambms) max_discharge_current = max_discharge_current_yambms; @@ -535,165 +535,165 @@ interval: ESP_LOGD("yambms_debug", "Max discharge current YamBMS : %f A", max_discharge_current_yambms); ESP_LOGD("yambms_debug", "Max discharge current BMS : %f A", max_discharge_current_bms); - if (dc_step == 0) id(${yambms_id}_var_discharge_current_step) = 1; + if (dc_step == 0) id(yambms${yambms_id}_var_discharge_current_step) = 1; } - id(${yambms_id}_max_discharge_current).publish_state(round(max_discharge_current)); + id(yambms${yambms_id}_max_discharge_current).publish_state(round(max_discharge_current)); ESP_LOGD("yambms_debug", "Max discharge current : %f A", max_discharge_current); // +-----------------------------------------------+ // | MAX balance_trigger_voltage | // +-----------------------------------------------+ - id(${yambms_id}_balance_trigger_voltage).publish_state(id(${yambms_id}_var_max_balance_trigger_voltage)); + id(yambms${yambms_id}_balance_trigger_voltage).publish_state(id(yambms${yambms_id}_var_max_balance_trigger_voltage)); // +-----------------------------------------------+ // | MIN min_cell_voltage | // | MIN min_voltage_cell (cell number) | // +-----------------------------------------------+ - float min_cell_v = id(${yambms_id}_var_min_cell_voltage); - id(${yambms_id}_min_cell_voltage).publish_state(min_cell_v); - id(${yambms_id}_min_voltage_cell).publish_state(id(${yambms_id}_var_min_voltage_cell)); + float min_cell_v = id(yambms${yambms_id}_var_min_cell_voltage); + id(yambms${yambms_id}_min_cell_voltage).publish_state(min_cell_v); + id(yambms${yambms_id}_min_voltage_cell).publish_state(id(yambms${yambms_id}_var_min_voltage_cell)); // +-----------------------------------------------+ // | MAX max_cell_voltage | // | MAX max_voltage_cell (cell number) | // +-----------------------------------------------+ - float max_cell_v = id(${yambms_id}_var_max_cell_voltage); - id(${yambms_id}_max_cell_voltage).publish_state(max_cell_v); - id(${yambms_id}_max_voltage_cell).publish_state(id(${yambms_id}_var_max_voltage_cell)); + float max_cell_v = id(yambms${yambms_id}_var_max_cell_voltage); + id(yambms${yambms_id}_max_cell_voltage).publish_state(max_cell_v); + id(yambms${yambms_id}_max_voltage_cell).publish_state(id(yambms${yambms_id}_var_max_voltage_cell)); // +-----------------------------------------------+ // | delta_cell_voltage | // +-----------------------------------------------+ - id(${yambms_id}_delta_cell_voltage).publish_state(max_cell_v - min_cell_v); + id(yambms${yambms_id}_delta_cell_voltage).publish_state(max_cell_v - min_cell_v); // +-----------------------------------------------+ // | MIN cell_ovp | // +-----------------------------------------------+ - id(${yambms_id}_cell_ovp).publish_state(id(${yambms_id}_var_min_cell_ovp)); + id(yambms${yambms_id}_cell_ovp).publish_state(id(yambms${yambms_id}_var_min_cell_ovp)); // +-----------------------------------------------+ // | MAX cell_uvp | // +-----------------------------------------------+ - id(${yambms_id}_cell_uvp).publish_state(id(${yambms_id}_var_max_cell_uvp)); + id(yambms${yambms_id}_cell_uvp).publish_state(id(yambms${yambms_id}_var_max_cell_uvp)); // +-----------------------------------------------+ // | MIN temperature | // | MIN temperature_sensor | // +-----------------------------------------------+ - id(${yambms_id}_min_temperature).publish_state(id(${yambms_id}_var_min_temperature)); - id(${yambms_id}_min_temperature_sensor).publish_state(id(${yambms_id}_var_min_temperature_sensor)); + id(yambms${yambms_id}_min_temperature).publish_state(id(yambms${yambms_id}_var_min_temperature)); + id(yambms${yambms_id}_min_temperature_sensor).publish_state(id(yambms${yambms_id}_var_min_temperature_sensor)); // +-----------------------------------------------+ // | MAX temperature | // | MAX temperature_sensor | // +-----------------------------------------------+ - id(${yambms_id}_max_temperature).publish_state(id(${yambms_id}_var_max_temperature)); - id(${yambms_id}_max_temperature_sensor).publish_state(id(${yambms_id}_var_max_temperature_sensor)); + id(yambms${yambms_id}_max_temperature).publish_state(id(yambms${yambms_id}_var_max_temperature)); + id(yambms${yambms_id}_max_temperature_sensor).publish_state(id(yambms${yambms_id}_var_max_temperature_sensor)); // +-----------------------------------------------+ // | Equalizing state | // +-----------------------------------------------+ - if (id(${yambms_id}_var_equalizing_counter) > 0) - id(${yambms_id}_equalizing).publish_state(true); + if (id(yambms${yambms_id}_var_equalizing_counter) > 0) + id(yambms${yambms_id}_equalizing).publish_state(true); else - id(${yambms_id}_equalizing).publish_state(false); + id(yambms${yambms_id}_equalizing).publish_state(false); // +-----------------------------------------------+ // | Charging allowed | // +-----------------------------------------------+ - if (id(${yambms_id}_switch_charging).state && id(${yambms_id}_var_charging_allowed_counter) > 0) - id(${yambms_id}_charging_allowed).publish_state(true); + if (id(yambms${yambms_id}_switch_charging).state && id(yambms${yambms_id}_var_charging_allowed_counter) > 0) + id(yambms${yambms_id}_charging_allowed).publish_state(true); else - id(${yambms_id}_charging_allowed).publish_state(false); + id(yambms${yambms_id}_charging_allowed).publish_state(false); // +-----------------------------------------------+ // | Discharging allowed | // +-----------------------------------------------+ - if (id(${yambms_id}_switch_discharging).state && id(${yambms_id}_var_discharging_allowed_counter) > 0) - id(${yambms_id}_discharging_allowed).publish_state(true); + if (id(yambms${yambms_id}_switch_discharging).state && id(yambms${yambms_id}_var_discharging_allowed_counter) > 0) + id(yambms${yambms_id}_discharging_allowed).publish_state(true); else - id(${yambms_id}_discharging_allowed).publish_state(false); + id(yambms${yambms_id}_discharging_allowed).publish_state(false); // +-----------------------------------------------+ // | BMS count | // +-----------------------------------------------+ // BMS count total - id(${yambms_id}_bms_count).publish_state(id(${yambms_id}_var_bms_counter)); + id(yambms${yambms_id}_bms_count).publish_state(id(yambms${yambms_id}_var_bms_counter)); // BMS count combined - id(${yambms_id}_bms_combined).publish_state(id(${yambms_id}_var_to_combine_bms_counter)); + id(yambms${yambms_id}_bms_combined).publish_state(id(yambms${yambms_id}_var_to_combine_bms_counter)); // BMS count blocking charge - id(${yambms_id}_bms_blocking_charge).publish_state(id(${yambms_id}_var_bms_blocking_charge_counter)); + id(yambms${yambms_id}_bms_blocking_charge).publish_state(id(yambms${yambms_id}_var_bms_blocking_charge_counter)); // BMS count blocking discharge - id(${yambms_id}_bms_blocking_discharge).publish_state(id(${yambms_id}_var_bms_blocking_discharge_counter)); + id(yambms${yambms_id}_bms_blocking_discharge).publish_state(id(yambms${yambms_id}_var_bms_blocking_discharge_counter)); // +-----------------------------------------------+ // | Shunt count | // +-----------------------------------------------+ // Shunt count total - id(${yambms_id}_shunt_count).publish_state(id(${yambms_id}_var_shunt_counter)); + id(yambms${yambms_id}_shunt_count).publish_state(id(yambms${yambms_id}_var_shunt_counter)); // Shunt count combined - id(${yambms_id}_shunt_combined).publish_state(id(${yambms_id}_var_to_combine_shunt_counter)); + id(yambms${yambms_id}_shunt_combined).publish_state(id(yambms${yambms_id}_var_to_combine_shunt_counter)); // +-----------------------------------------------+ // | Global vars reset | // +-----------------------------------------------+ - id(${yambms_id}_var_errors_bitmask) = 0; - id(${yambms_id}_var_errors_bitmask_counter) = 0; - id(${yambms_id}_var_bms_total_voltage) = 0.0; - id(${yambms_id}_var_shunt_total_voltage) = 0.0; - id(${yambms_id}_var_bms_total_current) = 0.0; - id(${yambms_id}_var_shunt_total_current) = 0.0; - id(${yambms_id}_var_bms_total_power) = 0.0; - id(${yambms_id}_var_shunt_total_power) = 0.0; - id(${yambms_id}_var_bms_total_soc) = 0.0; - id(${yambms_id}_var_shunt_total_soc) = 0.0; - id(${yambms_id}_var_bms_total_soh) = 0.0; - id(${yambms_id}_var_total_battery_capacity) = 0.0; - id(${yambms_id}_var_total_battery_capacity_remaining) = 0.0; - id(${yambms_id}_var_total_max_charge_current) = 0.0; - id(${yambms_id}_var_total_max_discharge_current) = 0.0; - id(${yambms_id}_var_total_charging_cycles) = 0.0; - id(${yambms_id}_var_max_balance_trigger_voltage) = 0.0; - id(${yambms_id}_var_min_cell_voltage) = 5.0; - id(${yambms_id}_var_min_voltage_cell) = 0; - id(${yambms_id}_var_max_cell_voltage) = 0.0; - id(${yambms_id}_var_max_voltage_cell) = 0; - id(${yambms_id}_var_min_cell_ovp) = 5.0; - id(${yambms_id}_var_max_cell_uvp) = 0.0; - id(${yambms_id}_var_min_temperature) = 100.0; - id(${yambms_id}_var_min_temperature_sensor) = 0; - id(${yambms_id}_var_max_temperature) = -100.0; - id(${yambms_id}_var_max_temperature_sensor) = 0; - id(${yambms_id}_var_equalizing_counter) = 0; - id(${yambms_id}_var_charging_allowed_counter) = 0; - id(${yambms_id}_var_discharging_allowed_counter) = 0; - id(${yambms_id}_var_bms_blocking_charge_counter) = 0; - id(${yambms_id}_var_bms_blocking_discharge_counter) = 0; + id(yambms${yambms_id}_var_errors_bitmask) = 0; + id(yambms${yambms_id}_var_errors_bitmask_counter) = 0; + id(yambms${yambms_id}_var_bms_total_voltage) = 0.0; + id(yambms${yambms_id}_var_shunt_total_voltage) = 0.0; + id(yambms${yambms_id}_var_bms_total_current) = 0.0; + id(yambms${yambms_id}_var_shunt_total_current) = 0.0; + id(yambms${yambms_id}_var_bms_total_power) = 0.0; + id(yambms${yambms_id}_var_shunt_total_power) = 0.0; + id(yambms${yambms_id}_var_bms_total_soc) = 0.0; + id(yambms${yambms_id}_var_shunt_total_soc) = 0.0; + id(yambms${yambms_id}_var_bms_total_soh) = 0.0; + id(yambms${yambms_id}_var_total_battery_capacity) = 0.0; + id(yambms${yambms_id}_var_total_battery_capacity_remaining) = 0.0; + id(yambms${yambms_id}_var_total_max_charge_current) = 0.0; + id(yambms${yambms_id}_var_total_max_discharge_current) = 0.0; + id(yambms${yambms_id}_var_total_charging_cycles) = 0.0; + id(yambms${yambms_id}_var_max_balance_trigger_voltage) = 0.0; + id(yambms${yambms_id}_var_min_cell_voltage) = 5.0; + id(yambms${yambms_id}_var_min_voltage_cell) = 0; + id(yambms${yambms_id}_var_max_cell_voltage) = 0.0; + id(yambms${yambms_id}_var_max_voltage_cell) = 0; + id(yambms${yambms_id}_var_min_cell_ovp) = 5.0; + id(yambms${yambms_id}_var_max_cell_uvp) = 0.0; + id(yambms${yambms_id}_var_min_temperature) = 100.0; + id(yambms${yambms_id}_var_min_temperature_sensor) = 0; + id(yambms${yambms_id}_var_max_temperature) = -100.0; + id(yambms${yambms_id}_var_max_temperature_sensor) = 0; + id(yambms${yambms_id}_var_equalizing_counter) = 0; + id(yambms${yambms_id}_var_charging_allowed_counter) = 0; + id(yambms${yambms_id}_var_discharging_allowed_counter) = 0; + id(yambms${yambms_id}_var_bms_blocking_charge_counter) = 0; + id(yambms${yambms_id}_var_bms_blocking_discharge_counter) = 0; // The devices are once again authorized to communicate their informations - id(${yambms_id}_var_to_combine_bms_number) = 1; - id(${yambms_id}_var_to_combine_shunt_number) = 1; + id(yambms${yambms_id}_var_to_combine_bms_number) = 1; + id(yambms${yambms_id}_var_to_combine_shunt_number) = 1; } // +-----------------------------------------------+ // | STEP 3 - YamBMS Logic | // +-----------------------------------------------+ - if ((id(${yambms_id}_bms_combined).has_state()) && - (id(${yambms_id}_total_voltage).has_state()) && - (id(${yambms_id}_current).has_state()) && - (id(${yambms_id}_power).has_state()) && - (id(${yambms_id}_battery_soc).has_state()) && - (id(${yambms_id}_battery_soh).has_state()) && - (id(${yambms_id}_battery_capacity).has_state()) && - (id(${yambms_id}_equalizing).has_state()) && - (id(${yambms_id}_max_cell_voltage).has_state()) && - (id(${yambms_id}_max_charge_current).has_state()) && - (id(${yambms_id}_max_discharge_current).has_state()) && - (id(${yambms_id}_cell_ovp).has_state()) && - (id(${yambms_id}_cell_uvp).has_state()) && - (id(${yambms_id}_cell_count).has_state()) && - (id(${yambms_id}_charging_allowed).has_state()) && - (id(${yambms_id}_discharging_allowed).has_state())) + if ((id(yambms${yambms_id}_bms_combined).has_state()) && + (id(yambms${yambms_id}_total_voltage).has_state()) && + (id(yambms${yambms_id}_current).has_state()) && + (id(yambms${yambms_id}_power).has_state()) && + (id(yambms${yambms_id}_battery_soc).has_state()) && + (id(yambms${yambms_id}_battery_soh).has_state()) && + (id(yambms${yambms_id}_battery_capacity).has_state()) && + (id(yambms${yambms_id}_equalizing).has_state()) && + (id(yambms${yambms_id}_max_cell_voltage).has_state()) && + (id(yambms${yambms_id}_max_charge_current).has_state()) && + (id(yambms${yambms_id}_max_discharge_current).has_state()) && + (id(yambms${yambms_id}_cell_ovp).has_state()) && + (id(yambms${yambms_id}_cell_uvp).has_state()) && + (id(yambms${yambms_id}_cell_count).has_state()) && + (id(yambms${yambms_id}_charging_allowed).has_state()) && + (id(yambms${yambms_id}_discharging_allowed).has_state())) { ESP_LOGD("yambms_debug", "===> STEP 3 : Entering YamBMS logic... <==="); @@ -702,35 +702,35 @@ interval: // | Charging Logic | // +-----------------------------------------------+ // EOC => Float - if ((id(${yambms_id}_var_charge_status) == "EOC") && (id(${yambms_id}_switch_float).state)) id(${yambms_id}_var_charge_status) = "Float"; + if ((id(yambms${yambms_id}_var_charge_status) == "EOC") && (id(yambms${yambms_id}_switch_float).state)) id(yambms${yambms_id}_var_charge_status) = "Float"; // No Float => EOC - else if ((id(${yambms_id}_var_charge_status) == "Float") && (!id(${yambms_id}_switch_float).state)) id(${yambms_id}_var_charge_status) = "EOC"; + else if ((id(yambms${yambms_id}_var_charge_status) == "Float") && (!id(yambms${yambms_id}_switch_float).state)) id(yambms${yambms_id}_var_charge_status) = "EOC"; // Force Float - else if (id(${yambms_id}_var_force_float) == true) id(${yambms_id}_var_charge_status) = "Float"; + else if (id(yambms${yambms_id}_var_force_float) == true) id(yambms${yambms_id}_var_charge_status) = "Float"; // +-----------------------------------------------+ // | Charging allowed (BMS and YamBMS) | // +-----------------------------------------------+ - else if ((id(${yambms_id}_charging_allowed).has_state()) && (id(${yambms_id}_charging_allowed).state)) + else if ((id(yambms${yambms_id}_charging_allowed).has_state()) && (id(yambms${yambms_id}_charging_allowed).state)) { // Variables - float cell_bulk_v = (id(${yambms_id}_bulk_voltage).state / id(${yambms_id}_cell_count).state); - float cell_rebulk_v = (id(${yambms_id}_rebulk_voltage).state / id(${yambms_id}_cell_count).state); - float max_cell_v = id(${yambms_id}_max_cell_voltage).state; + float cell_bulk_v = (id(yambms${yambms_id}_bulk_voltage).state / id(yambms${yambms_id}_cell_count).state); + float cell_rebulk_v = (id(yambms${yambms_id}_rebulk_voltage).state / id(yambms${yambms_id}_cell_count).state); + float max_cell_v = id(yambms${yambms_id}_max_cell_voltage).state; // +-----------------------------------------------+ // | Rebulk after N days since last full charge | // +-----------------------------------------------+ - int rebulk_days = (int)id(${yambms_id}_rebulk_days).state; + int rebulk_days = (int)id(yambms${yambms_id}_rebulk_days).state; if (rebulk_days == 0) // Function disabled { - id(${yambms_id}_var_rebulk_days_active) = false; + id(yambms${yambms_id}_var_rebulk_days_active) = false; } - else if (!id(${yambms_id}_var_rebulk_days_active)) // Function enabled + else if (!id(yambms${yambms_id}_var_rebulk_days_active)) // Function enabled { if (rebulk_days > 0) { - time_t last_eoc = id(${yambms_id}_var_eoc_timestamp); + time_t last_eoc = id(yambms${yambms_id}_var_eoc_timestamp); if (last_eoc > 0) { // Round down to 00:00:00 so rebulk gets enabled early in the day @@ -741,7 +741,7 @@ interval: float days_since_eoc = (float)(now - last_eoc_day) / 86400.0f; if (days_since_eoc >= rebulk_days) { - id(${yambms_id}_var_rebulk_days_active) = true; + id(yambms${yambms_id}_var_rebulk_days_active) = true; ESP_LOGD("yambms_debug", "Rebulk after %d days since last full charge: activating rebulk logic", rebulk_days); } } @@ -751,44 +751,44 @@ interval: // +-----------------------------------------------+ // | Force Bulk Logic | // +-----------------------------------------------+ - if (id(${yambms_id}_switch_force_bulk).state) + if (id(yambms${yambms_id}_switch_force_bulk).state) { // Stop Force Bulk when entering the Cut-Off phase - if (id(${yambms_id}_var_charge_status) == "Cut-Off") - id(${yambms_id}_switch_force_bulk).turn_off(); + if (id(yambms${yambms_id}_var_charge_status) == "Cut-Off") + id(yambms${yambms_id}_switch_force_bulk).turn_off(); // Force Bulk - else id(${yambms_id}_var_charge_status) = "Bulk"; + else id(yambms${yambms_id}_var_charge_status) = "Bulk"; } // +-----------------------------------------------+ // | Rebulk Logic | // +-----------------------------------------------+ // Init / Wait - else if ((id(${yambms_id}_var_charge_status) == "Init") || (id(${yambms_id}_var_charge_status) == "Wait")) - id(${yambms_id}_var_charge_status) = "Bulk"; + else if ((id(yambms${yambms_id}_var_charge_status) == "Init") || (id(yambms${yambms_id}_var_charge_status) == "Wait")) + id(yambms${yambms_id}_var_charge_status) = "Bulk"; // Max Cell V. <= 3.3V (default value) else if (max_cell_v <= cell_rebulk_v) - id(${yambms_id}_var_charge_status) = "Bulk"; + id(yambms${yambms_id}_var_charge_status) = "Bulk"; // SoC <= 85% (default value) - else if (id(${yambms_id}_battery_soc).state <= id(${yambms_id}_rebulk_soc).state) - id(${yambms_id}_var_charge_status) = "Bulk"; + else if (id(yambms${yambms_id}_battery_soc).state <= id(yambms${yambms_id}_rebulk_soc).state) + id(yambms${yambms_id}_var_charge_status) = "Bulk"; // Rebulk Days >= 14 (default value) - else if (id(${yambms_id}_var_rebulk_days_active) == true) - id(${yambms_id}_var_charge_status) = "Bulk"; + else if (id(yambms${yambms_id}_var_rebulk_days_active) == true) + id(yambms${yambms_id}_var_charge_status) = "Bulk"; // Force Charge requested - else if (id(${yambms_id}_requested_force_charge).state) - id(${yambms_id}_var_charge_status) = "Bulk"; + else if (id(yambms${yambms_id}_requested_force_charge).state) + id(yambms${yambms_id}_var_charge_status) = "Bulk"; // +-----------------------------------------------+ // | Charging Logic (Bulk) | // +-----------------------------------------------+ - if ((id(${yambms_id}_var_charge_status) != "EOC") && (id(${yambms_id}_var_charge_status) != "Float")) + if ((id(yambms${yambms_id}_var_charge_status) != "EOC") && (id(yambms${yambms_id}_var_charge_status) != "Float")) { - float cv_min = id(${yambms_id}_var_cell_min_charge_v); - float cv_max = id(${yambms_id}_var_cell_max_charge_v); - float current = id(${yambms_id}_current).state; - float cutoff_resistance = ((cv_max - cv_min) / id(${yambms_id}_battery_capacity).state / 0.05); + float cv_min = id(yambms${yambms_id}_var_cell_min_charge_v); + float cv_max = id(yambms${yambms_id}_var_cell_max_charge_v); + float current = id(yambms${yambms_id}_current).state; + float cutoff_resistance = ((cv_max - cv_min) / id(yambms${yambms_id}_battery_capacity).state / 0.05); uint32_t ms_now = millis(); static uint32_t ms_cutoff = ms_now; @@ -828,12 +828,12 @@ interval: { ESP_LOGD("yambms_debug", "Entering the Bulk phase..."); // Stop timer - if (id(${yambms_id}_script_eoc_timer).is_running()) id(${yambms_id}_script_eoc_timer).stop(); - if (id(${yambms_id}_script_cutoff_timer).is_running()) id(${yambms_id}_script_cutoff_timer).stop(); + if (id(yambms${yambms_id}_script_eoc_timer).is_running()) id(yambms${yambms_id}_script_eoc_timer).stop(); + if (id(yambms${yambms_id}_script_cutoff_timer).is_running()) id(yambms${yambms_id}_script_cutoff_timer).stop(); // Balancing : the BMS is equalizing the cells - if (id(${yambms_id}_equalizing).state) id(${yambms_id}_var_charge_status) = "Balancing"; + if (id(yambms${yambms_id}_equalizing).state) id(yambms${yambms_id}_var_charge_status) = "Balancing"; // Bulk - else id(${yambms_id}_var_charge_status) = "Bulk"; + else id(yambms${yambms_id}_var_charge_status) = "Bulk"; } // Cut-Off phase else if (ms_now - ms_cutoff >= 10000) // 10s @@ -841,114 +841,114 @@ interval: ESP_LOGD("yambms_debug", "Entering the Cut-Off phase..."); // Cut-Off : the end of charging is near - id(${yambms_id}_var_charge_status) = "Cut-Off"; + id(yambms${yambms_id}_var_charge_status) = "Cut-Off"; // If the EOC Timer switch is enabled - if (id(${yambms_id}_switch_eoc_timer).state) + if (id(yambms${yambms_id}_switch_eoc_timer).state) { // Start EOC timer // The charging process ends at the latest at the end of this timer (30min by default) - if (!id(${yambms_id}_script_eoc_timer).is_running()) - id(${yambms_id}_script_eoc_timer).execute(); + if (!id(yambms${yambms_id}_script_eoc_timer).is_running()) + id(yambms${yambms_id}_script_eoc_timer).execute(); } // End Of Charge // Equalizing - if (id(${yambms_id}_equalizing).state) + if (id(yambms${yambms_id}_equalizing).state) { // Stop cut-off timer - if (id(${yambms_id}_script_cutoff_timer).is_running()) - id(${yambms_id}_script_cutoff_timer).stop(); + if (id(yambms${yambms_id}_script_cutoff_timer).is_running()) + id(yambms${yambms_id}_script_cutoff_timer).stop(); } // Not Equalizing => Start cut-off timer // If the conditions continue to be respected the charging process will stop in 60s (default value) - else if (!id(${yambms_id}_script_cutoff_timer).is_running()) - id(${yambms_id}_script_cutoff_timer).execute(); + else if (!id(yambms${yambms_id}_script_cutoff_timer).is_running()) + id(yambms${yambms_id}_script_cutoff_timer).execute(); } } } // Charging not allowed (BMS or YamBMS) - else if (id(${yambms_id}_var_bms_charging_logic) == true) + else if (id(yambms${yambms_id}_var_bms_charging_logic) == true) { ESP_LOGD("yambms_debug", "Charging not allowed !"); - if (!id(${yambms_id}_switch_charging).state) id(${yambms_id}_var_charge_status) = "Wait"; + if (!id(yambms${yambms_id}_switch_charging).state) id(yambms${yambms_id}_var_charge_status) = "Wait"; } else { ESP_LOGD("yambms_debug", "Charging not allowed !"); - id(${yambms_id}_var_charge_status) = "Wait"; + id(yambms${yambms_id}_var_charge_status) = "Wait"; } // Publish the sensor - id(${yambms_id}_charging_status).publish_state(id(${yambms_id}_var_charge_status)); + id(yambms${yambms_id}_charging_status).publish_state(id(yambms${yambms_id}_var_charge_status)); // +-----------------------------------------------+ // | Charging Instruction | // +-----------------------------------------------+ std::string charging_instruction; // Bulk Charge - if ((id(${yambms_id}_var_charge_status) != "Init") && - (id(${yambms_id}_var_charge_status) != "Wait") && - (id(${yambms_id}_var_charge_status) != "EOC") && - (id(${yambms_id}_var_charge_status) != "Float")) + if ((id(yambms${yambms_id}_var_charge_status) != "Init") && + (id(yambms${yambms_id}_var_charge_status) != "Wait") && + (id(yambms${yambms_id}_var_charge_status) != "EOC") && + (id(yambms${yambms_id}_var_charge_status) != "Float")) { - id(${yambms_id}_var_eoc) = false; // SoC 100% can't be sent + id(yambms${yambms_id}_var_eoc) = false; // SoC 100% can't be sent charging_instruction = "Bulk"; } // Float Charge - else if (id(${yambms_id}_var_charge_status) == "Float") + else if (id(yambms${yambms_id}_var_charge_status) == "Float") { charging_instruction = "Float"; } // Init / Wait / EOC else charging_instruction = "Stop"; // Publish the sensor - id(${yambms_id}_charging_instruction).publish_state(charging_instruction); + id(yambms${yambms_id}_charging_instruction).publish_state(charging_instruction); // +-----------------------------------------------+ // | Discharging Instruction | // +-----------------------------------------------+ bool discharging_instruction = false; - if (id(${yambms_id}_discharging_allowed).state) + if (id(yambms${yambms_id}_discharging_allowed).state) discharging_instruction = true; - if (id(${yambms_id}_total_voltage).state <= id(${yambms_id}_requested_discharge_voltage).state) + if (id(yambms${yambms_id}_total_voltage).state <= id(yambms${yambms_id}_requested_discharge_voltage).state) discharging_instruction = false; // Publish the sensor - id(${yambms_id}_discharging_instruction).publish_state(discharging_instruction); + id(yambms${yambms_id}_discharging_instruction).publish_state(discharging_instruction); // +-----------------------------------------------+ // | Requested Charge Voltage (CVL) | // +-----------------------------------------------+ float requested_charge_voltage; - if (id(${yambms_id}_bms_combined).state == 0) // no BMS combined + if (id(yambms${yambms_id}_bms_combined).state == 0) // no BMS combined requested_charge_voltage = 0; // Bulk else if (charging_instruction == "Bulk") - requested_charge_voltage = (id(${yambms_id}_bulk_voltage).state + id(${yambms_id}_inverter_offset_v).state + id(${yambms_id}_var_auto_cvl)); + requested_charge_voltage = (id(yambms${yambms_id}_bulk_voltage).state + id(yambms${yambms_id}_inverter_offset_v).state + id(yambms${yambms_id}_var_auto_cvl)); // Float else if (charging_instruction == "Float") - requested_charge_voltage = (id(${yambms_id}_float_voltage).state + id(${yambms_id}_inverter_offset_v).state) + id(${yambms_id}_var_auto_float); + requested_charge_voltage = (id(yambms${yambms_id}_float_voltage).state + id(yambms${yambms_id}_inverter_offset_v).state) + id(yambms${yambms_id}_var_auto_float); // Stop Charging - else requested_charge_voltage = (id(${yambms_id}_rebulk_voltage).state + id(${yambms_id}_inverter_offset_v).state); + else requested_charge_voltage = (id(yambms${yambms_id}_rebulk_voltage).state + id(yambms${yambms_id}_inverter_offset_v).state); // Publish the sensor - id(${yambms_id}_requested_charge_voltage).publish_state(requested_charge_voltage); + id(yambms${yambms_id}_requested_charge_voltage).publish_state(requested_charge_voltage); // +-----------------------------------------------+ // | Requested Discharge Voltage (DVL) | // +-----------------------------------------------+ float requested_discharge_voltage; - if (id(${yambms_id}_bms_combined).state == 0) // no BMS combined + if (id(yambms${yambms_id}_bms_combined).state == 0) // no BMS combined requested_discharge_voltage = 0; else - requested_discharge_voltage = ((id(${yambms_id}_cell_uvp).state + 0.2) * id(${yambms_id}_cell_count).state); + requested_discharge_voltage = ((id(yambms${yambms_id}_cell_uvp).state + 0.2) * id(yambms${yambms_id}_cell_count).state); // Publish the sensor - id(${yambms_id}_requested_discharge_voltage).publish_state(requested_discharge_voltage); + id(yambms${yambms_id}_requested_discharge_voltage).publish_state(requested_discharge_voltage); // +-----------------------------------------------+ // | Requested Charge Current (CCL) | // +-----------------------------------------------+ - int cc_step = id(${yambms_id}_var_charge_current_step); - if (cc_step == id(${yambms_id}_var_auto_ccl_functions_count) + 1) + int cc_step = id(yambms${yambms_id}_var_charge_current_step); + if (cc_step == id(yambms${yambms_id}_var_auto_ccl_functions_count) + 1) { ESP_LOGD("yambms_debug", "Entering Requested CCL..."); ESP_LOGD("yambms_debug", "Charging instruction : %s", charging_instruction.c_str()); @@ -959,31 +959,31 @@ interval: if ((charging_instruction == "Bulk") || (charging_instruction == "Float")) { float auto_limit = std::min({ - id(${yambms_id}_var_auto_ccl), - id(${yambms_id}_var_auto_eoc), - id(${yambms_id}_var_auto_temperature_ccl), - id(${yambms_id}_var_auto_ccl_soft_landing), - id(${yambms_id}_var_auto_soc_limit), + id(yambms${yambms_id}_var_auto_ccl), + id(yambms${yambms_id}_var_auto_eoc), + id(yambms${yambms_id}_var_auto_temperature_ccl), + id(yambms${yambms_id}_var_auto_ccl_soft_landing), + id(yambms${yambms_id}_var_auto_soc_limit), }); - requested_charge_current = round(id(${yambms_id}_max_charge_current).state + auto_limit); + requested_charge_current = round(id(yambms${yambms_id}_max_charge_current).state + auto_limit); if (requested_charge_current < 0) requested_charge_current = 0; } // Publish the sensor - id(${yambms_id}_requested_charge_current).publish_state(requested_charge_current); + id(yambms${yambms_id}_requested_charge_current).publish_state(requested_charge_current); - if (id(${yambms_id}_var_charge_status) != "Init") - id(${yambms_id}_var_requested_ccl_init) = true; + if (id(yambms${yambms_id}_var_charge_status) != "Init") + id(yambms${yambms_id}_var_requested_ccl_init) = true; - id(${yambms_id}_var_charge_current_step) = 1; + id(yambms${yambms_id}_var_charge_current_step) = 1; } // +-----------------------------------------------+ // | Requested Discharge Current (DCL) | // +-----------------------------------------------+ - int dc_step = id(${yambms_id}_var_discharge_current_step); - if (dc_step == id(${yambms_id}_var_auto_dcl_functions_count) + 1) + int dc_step = id(yambms${yambms_id}_var_discharge_current_step); + if (dc_step == id(yambms${yambms_id}_var_auto_dcl_functions_count) + 1) { ESP_LOGD("yambms_debug", "Entering Requested DCL..."); // Discharging Not Allowed @@ -992,66 +992,66 @@ interval: if (discharging_instruction == true) { float auto_limit = std::min({ - id(${yambms_id}_var_auto_dcl), - id(${yambms_id}_var_auto_temperature_dcl) + id(yambms${yambms_id}_var_auto_dcl), + id(yambms${yambms_id}_var_auto_temperature_dcl) }); - requested_discharge_current = round(id(${yambms_id}_max_discharge_current).state + auto_limit); + requested_discharge_current = round(id(yambms${yambms_id}_max_discharge_current).state + auto_limit); if (requested_discharge_current < 0) requested_discharge_current = 0; } // Publish the sensor - id(${yambms_id}_requested_discharge_current).publish_state(requested_discharge_current); + id(yambms${yambms_id}_requested_discharge_current).publish_state(requested_discharge_current); - id(${yambms_id}_var_requested_dcl_init) = true; - id(${yambms_id}_var_discharge_current_step) = 1; + id(yambms${yambms_id}_var_requested_dcl_init) = true; + id(yambms${yambms_id}_var_discharge_current_step) = 1; } // +-----------------------------------------------+ // | End Of STEP 3 : YamBMS initialized ? | // | The datas can be communicated to the inverter | // +-----------------------------------------------+ - if ((id(${yambms_id}_bms_combined).state > 0) && - (id(${yambms_id}_var_charge_status) != "Init") && - (id(${yambms_id}_total_voltage).state > 0) && - (id(${yambms_id}_min_temperature).state < 100) && - (id(${yambms_id}_max_temperature).state > -100) && - (id(${yambms_id}_requested_charge_voltage).state > 0) && - (id(${yambms_id}_requested_discharge_voltage).state > 0) && - (id(${yambms_id}_var_requested_ccl_init) == true) && - (id(${yambms_id}_var_requested_dcl_init) == true)) + if ((id(yambms${yambms_id}_bms_combined).state > 0) && + (id(yambms${yambms_id}_var_charge_status) != "Init") && + (id(yambms${yambms_id}_total_voltage).state > 0) && + (id(yambms${yambms_id}_min_temperature).state < 100) && + (id(yambms${yambms_id}_max_temperature).state > -100) && + (id(yambms${yambms_id}_requested_charge_voltage).state > 0) && + (id(yambms${yambms_id}_requested_discharge_voltage).state > 0) && + (id(yambms${yambms_id}_var_requested_ccl_init) == true) && + (id(yambms${yambms_id}_var_requested_dcl_init) == true)) { - id(${yambms_id}_var_initialized) = true; + id(yambms${yambms_id}_var_initialized) = true; } - else id(${yambms_id}_var_initialized) = false; // Communication with the inverter stops. + else id(yambms${yambms_id}_var_initialized) = false; // Communication with the inverter stops. } // +-----------------------------------------------+ // | DEBUG LOGS | // +-----------------------------------------------+ - if (id(${yambms_id}_var_initialized) == true) ESP_LOGD("yambms_debug", "===> YamBMS initialized <=== : true"); + if (id(yambms${yambms_id}_var_initialized) == true) ESP_LOGD("yambms_debug", "===> YamBMS initialized <=== : true"); else ESP_LOGD("yambms_debug", "===> YamBMS initialized <=== : false"); - if (id(${yambms_id}_total_voltage).has_state()) ESP_LOGD("yambms_debug", "Battery Voltage : %f V", id(${yambms_id}_total_voltage).state); - if (id(${yambms_id}_current).has_state()) ESP_LOGD("yambms_debug", "Battery Current : %f A", id(${yambms_id}_current).state); - if (id(${yambms_id}_power).has_state()) ESP_LOGD("yambms_debug", "Battery Power : %f W", id(${yambms_id}_power).state); - if (id(${yambms_id}_battery_soc).has_state()) ESP_LOGD("yambms_debug", "Battery SOC : %f %%", id(${yambms_id}_battery_soc).state); - if (id(${yambms_id}_battery_soh).has_state()) ESP_LOGD("yambms_debug", "Battery SOH : %f %%", id(${yambms_id}_battery_soh).state); - if (id(${yambms_id}_min_temperature).has_state()) ESP_LOGD("yambms_debug", "Min temp. : %f °C", id(${yambms_id}_min_temperature).state); - if (id(${yambms_id}_max_temperature).has_state()) ESP_LOGD("yambms_debug", "Max temp. : %f °C", id(${yambms_id}_max_temperature).state); - ESP_LOGD("yambms_debug", "Charge Status : %s", id(${yambms_id}_var_charge_status).c_str()); - if (id(${yambms_id}_charging_instruction).has_state()) ESP_LOGD("yambms_debug", "Charging instruction : %s", id(${yambms_id}_charging_instruction).state.c_str()); - if (id(${yambms_id}_discharging_instruction).has_state()) + if (id(yambms${yambms_id}_total_voltage).has_state()) ESP_LOGD("yambms_debug", "Battery Voltage : %f V", id(yambms${yambms_id}_total_voltage).state); + if (id(yambms${yambms_id}_current).has_state()) ESP_LOGD("yambms_debug", "Battery Current : %f A", id(yambms${yambms_id}_current).state); + if (id(yambms${yambms_id}_power).has_state()) ESP_LOGD("yambms_debug", "Battery Power : %f W", id(yambms${yambms_id}_power).state); + if (id(yambms${yambms_id}_battery_soc).has_state()) ESP_LOGD("yambms_debug", "Battery SOC : %f %%", id(yambms${yambms_id}_battery_soc).state); + if (id(yambms${yambms_id}_battery_soh).has_state()) ESP_LOGD("yambms_debug", "Battery SOH : %f %%", id(yambms${yambms_id}_battery_soh).state); + if (id(yambms${yambms_id}_min_temperature).has_state()) ESP_LOGD("yambms_debug", "Min temp. : %f °C", id(yambms${yambms_id}_min_temperature).state); + if (id(yambms${yambms_id}_max_temperature).has_state()) ESP_LOGD("yambms_debug", "Max temp. : %f °C", id(yambms${yambms_id}_max_temperature).state); + ESP_LOGD("yambms_debug", "Charge Status : %s", id(yambms${yambms_id}_var_charge_status).c_str()); + if (id(yambms${yambms_id}_charging_instruction).has_state()) ESP_LOGD("yambms_debug", "Charging instruction : %s", id(yambms${yambms_id}_charging_instruction).state.c_str()); + if (id(yambms${yambms_id}_discharging_instruction).has_state()) { - bool discharging_instruction = id(${yambms_id}_discharging_instruction).state; + bool discharging_instruction = id(yambms${yambms_id}_discharging_instruction).state; if (discharging_instruction == true) ESP_LOGD("yambms_debug", "Discharging instruction : true"); else ESP_LOGD("yambms_debug", "Discharging instruction : false"); } - if (id(${yambms_id}_requested_charge_voltage).has_state()) ESP_LOGD("yambms_debug", "Requested CVL : %f V", id(${yambms_id}_requested_charge_voltage).state); - if (id(${yambms_id}_requested_discharge_voltage).has_state()) ESP_LOGD("yambms_debug", "Requested DVL : %f V", id(${yambms_id}_requested_discharge_voltage).state); - if (id(${yambms_id}_requested_charge_current).has_state()) ESP_LOGD("yambms_debug", "Requested CCL : %f A", id(${yambms_id}_requested_charge_current).state); - if (id(${yambms_id}_requested_discharge_current).has_state()) ESP_LOGD("yambms_debug", "Requested DCL : %f A", id(${yambms_id}_requested_discharge_current).state); - if (id(${yambms_id}_ccl_derating_reason).has_state()) ESP_LOGD("yambms_debug", "CCL derating reason : %s", id(${yambms_id}_ccl_derating_reason).state.c_str()); - if (id(${yambms_id}_dcl_derating_reason).has_state()) ESP_LOGD("yambms_debug", "DCL derating reason : %s", id(${yambms_id}_dcl_derating_reason).state.c_str()); + if (id(yambms${yambms_id}_requested_charge_voltage).has_state()) ESP_LOGD("yambms_debug", "Requested CVL : %f V", id(yambms${yambms_id}_requested_charge_voltage).state); + if (id(yambms${yambms_id}_requested_discharge_voltage).has_state()) ESP_LOGD("yambms_debug", "Requested DVL : %f V", id(yambms${yambms_id}_requested_discharge_voltage).state); + if (id(yambms${yambms_id}_requested_charge_current).has_state()) ESP_LOGD("yambms_debug", "Requested CCL : %f A", id(yambms${yambms_id}_requested_charge_current).state); + if (id(yambms${yambms_id}_requested_discharge_current).has_state()) ESP_LOGD("yambms_debug", "Requested DCL : %f A", id(yambms${yambms_id}_requested_discharge_current).state); + if (id(yambms${yambms_id}_ccl_derating_reason).has_state()) ESP_LOGD("yambms_debug", "CCL derating reason : %s", id(yambms${yambms_id}_ccl_derating_reason).state.c_str()); + if (id(yambms${yambms_id}_dcl_derating_reason).has_state()) ESP_LOGD("yambms_debug", "DCL derating reason : %s", id(yambms${yambms_id}_dcl_derating_reason).state.c_str()); // if (id().has_state()) ESP_LOGD("yambms_debug", "Text : %f V", id().state); @@ -1061,26 +1061,26 @@ interval: # | scripts | # +--------------------------------------+ script: - - id: ${yambms_id}_script_eoc_timer + - id: yambms${yambms_id}_script_eoc_timer then: - delay: ${yambms_eoc_timer}min - - script.execute: ${yambms_id}_script_eoc - - id: ${yambms_id}_script_cutoff_timer + - script.execute: yambms${yambms_id}_script_eoc + - id: yambms${yambms_id}_script_cutoff_timer then: - delay: ${yambms_cutoff_timer}s - - script.execute: ${yambms_id}_script_eoc - - id: ${yambms_id}_script_eoc + - script.execute: yambms${yambms_id}_script_eoc + - id: yambms${yambms_id}_script_eoc then: - lambda: |- // Stop timer - if (id(${yambms_id}_script_eoc_timer).is_running()) id(${yambms_id}_script_eoc_timer).stop(); - if (id(${yambms_id}_script_cutoff_timer).is_running()) id(${yambms_id}_script_cutoff_timer).stop(); + if (id(yambms${yambms_id}_script_eoc_timer).is_running()) id(yambms${yambms_id}_script_eoc_timer).stop(); + if (id(yambms${yambms_id}_script_cutoff_timer).is_running()) id(yambms${yambms_id}_script_cutoff_timer).stop(); // EOC script - if (id(${yambms_id}_switch_float).state) id(${yambms_id}_var_charge_status) = "Float"; - else id(${yambms_id}_var_charge_status) = "EOC"; - id(${yambms_id}_var_eoc) = true; // SOC 100% can be sent - id(${yambms_id}_var_eoc_timestamp) = id(my_time).utcnow().timestamp; // Store charge completion timestamp - id(${yambms_id}_var_rebulk_days_active) = false; // Rebulk after N days logic reset + if (id(yambms${yambms_id}_switch_float).state) id(yambms${yambms_id}_var_charge_status) = "Float"; + else id(yambms${yambms_id}_var_charge_status) = "EOC"; + id(yambms${yambms_id}_var_eoc) = true; // SOC 100% can be sent + id(yambms${yambms_id}_var_eoc_timestamp) = id(my_time).utcnow().timestamp; // Store charge completion timestamp + id(yambms${yambms_id}_var_rebulk_days_active) = false; // Rebulk after N days logic reset @@ -1091,43 +1091,43 @@ script: switch: - platform: template name: "Charge enabled" - id: ${yambms_id}_switch_charging - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_switch_charging + device_id: yambms_yambms${yambms_id} restore_mode: RESTORE_DEFAULT_ON optimistic: true entity_category: config - platform: template name: "Discharge enabled" - id: ${yambms_id}_switch_discharging - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_switch_discharging + device_id: yambms_yambms${yambms_id} restore_mode: RESTORE_DEFAULT_ON optimistic: true entity_category: config - platform: template name: "Float charge enabled" - id: ${yambms_id}_switch_float - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_switch_float + device_id: yambms_yambms${yambms_id} restore_mode: RESTORE_DEFAULT_ON optimistic: true entity_category: config - platform: template name: "EOC Timer enabled" - id: ${yambms_id}_switch_eoc_timer - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_switch_eoc_timer + device_id: yambms_yambms${yambms_id} restore_mode: RESTORE_DEFAULT_ON optimistic: true entity_category: config - platform: template name: "Force Bulk" - id: ${yambms_id}_switch_force_bulk - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_switch_force_bulk + device_id: yambms_yambms${yambms_id} restore_mode: RESTORE_DEFAULT_OFF optimistic: true entity_category: config - platform: template name: "Request force charge" - id: ${yambms_id}_switch_request_force_charge - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_switch_request_force_charge + device_id: yambms_yambms${yambms_id} restore_mode: RESTORE_DEFAULT_OFF optimistic: true entity_category: config @@ -1138,27 +1138,27 @@ switch: binary_sensor: # Equalizing - platform: template - id: ${yambms_id}_equalizing - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_equalizing + device_id: yambms_yambms${yambms_id} name: "Equalizing state" trigger_on_initial_state: true # Charging allowed - platform: template - id: ${yambms_id}_charging_allowed - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_charging_allowed + device_id: yambms_yambms${yambms_id} name: "Charging allowed" trigger_on_initial_state: true # Discharging allowed - platform: template - id: ${yambms_id}_discharging_allowed - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_discharging_allowed + device_id: yambms_yambms${yambms_id} name: "Discharging allowed" trigger_on_initial_state: true # Inverter communication status (CANBUS / RS485) - platform: template name: "Inverter communication status" id: inverter_com_status - device_id: yambms_${yambms_id} + device_id: yambms_yambms${yambms_id} entity_category: diagnostic trigger_on_initial_state: true # +--------------------------------------+ @@ -1166,8 +1166,8 @@ binary_sensor: # +--------------------------------------+ - platform: template name: "Discharging Instruction" - id: ${yambms_id}_discharging_instruction - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_discharging_instruction + device_id: yambms_yambms${yambms_id} icon: mdi:battery-minus trigger_on_initial_state: true # +--------------------------------------+ @@ -1175,17 +1175,17 @@ binary_sensor: # +--------------------------------------+ - platform: template name: "Requested Force Charge" - id: ${yambms_id}_requested_force_charge - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_requested_force_charge + device_id: yambms_yambms${yambms_id} icon: mdi:battery-charging-low trigger_on_initial_state: true lambda: |- - if (id(${yambms_id}_switch_request_force_charge).state) + if (id(yambms${yambms_id}_switch_request_force_charge).state) { - int soc = id(${yambms_id}_battery_soc).state; - if (soc <= id(${yambms_id}_request_force_charge_start_soc).state) return true; - else if (soc >= id(${yambms_id}_request_force_charge_stop_soc).state) return false; - else if (id(${yambms_id}_requested_force_charge).state) return true; + int soc = id(yambms${yambms_id}_battery_soc).state; + if (soc <= id(yambms${yambms_id}_request_force_charge_start_soc).state) return true; + else if (soc >= id(yambms${yambms_id}_request_force_charge_stop_soc).state) return false; + else if (id(yambms${yambms_id}_requested_force_charge).state) return true; else return false; } else return false; @@ -1199,8 +1199,8 @@ number: # - platform: template name: "Bulk voltage" - id: ${yambms_id}_bulk_voltage - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_bulk_voltage + device_id: yambms_yambms${yambms_id} step: 0.1 min_value: 54.0 # LFP 3.37 * 16 cells max_value: 58.4 # LFP 3.65 * 16 cells @@ -1213,8 +1213,8 @@ number: entity_category: config - platform: template name: "Float voltage" - id: ${yambms_id}_float_voltage - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_float_voltage + device_id: yambms_yambms${yambms_id} step: 0.1 min_value: 52.8 # LFP 3.30 * 16 cells max_value: 55.2 # LFP 3.45 * 16 cells @@ -1227,8 +1227,8 @@ number: entity_category: config - platform: template name: "Rebulk V." - id: ${yambms_id}_rebulk_voltage - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_rebulk_voltage + device_id: yambms_yambms${yambms_id} step: 0.1 min_value: 51.2 # LFP 3.20 * 16 cells max_value: 54.0 # LFP 3.37 * 16 cells @@ -1241,8 +1241,8 @@ number: entity_category: config - platform: template name: "Rebulk SoC" - id: ${yambms_id}_rebulk_soc - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_rebulk_soc + device_id: yambms_yambms${yambms_id} step: 1 min_value: 0 max_value: 100 @@ -1255,8 +1255,8 @@ number: entity_category: config - platform: template name: "Rebulk Days" - id: ${yambms_id}_rebulk_days - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_rebulk_days + device_id: yambms_yambms${yambms_id} step: 1 min_value: 0 max_value: 30 @@ -1269,11 +1269,11 @@ number: entity_category: config on_value: then: - - lambda: id(${yambms_id}_var_rebulk_days_active) = false; + - lambda: id(yambms${yambms_id}_var_rebulk_days_active) = false; - platform: template name: "Inverter Offset V." - id: ${yambms_id}_inverter_offset_v - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_inverter_offset_v + device_id: yambms_yambms${yambms_id} step: 0.1 min_value: 0 max_value: 1 @@ -1287,8 +1287,8 @@ number: # internal: true - platform: template name: "Max requested charge current" - id: ${yambms_id}_max_requested_charge_current - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_max_requested_charge_current + device_id: yambms_yambms${yambms_id} step: 5 min_value: 0 max_value: ${yambms_max_requested_charge_current} @@ -1301,8 +1301,8 @@ number: entity_category: config - platform: template name: "Max requested discharge current" - id: ${yambms_id}_max_requested_discharge_current - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_max_requested_discharge_current + device_id: yambms_yambms${yambms_id} step: 5 min_value: 0 max_value: ${yambms_max_requested_discharge_current} @@ -1315,8 +1315,8 @@ number: entity_category: config - platform: template name: "Request Force Charge Start SoC" - id: ${yambms_id}_request_force_charge_start_soc - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_request_force_charge_start_soc + device_id: yambms_yambms${yambms_id} step: 1 min_value: 0 max_value: 100 @@ -1329,8 +1329,8 @@ number: entity_category: config - platform: template name: "Request Force Charge Stop SoC" - id: ${yambms_id}_request_force_charge_stop_soc - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_request_force_charge_stop_soc + device_id: yambms_yambms${yambms_id} step: 1 min_value: 0 max_value: 100 @@ -1350,8 +1350,8 @@ number: sensor: # max_charge_current SUM - platform: template - id: ${yambms_id}_max_charge_current - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_max_charge_current + device_id: yambms_yambms${yambms_id} name: "Max Charge current" update_interval: ${yambms_update_interval} unit_of_measurement: A @@ -1365,8 +1365,8 @@ sensor: # max_discharge_current SUM - platform: template - id: ${yambms_id}_max_discharge_current - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_max_discharge_current + device_id: yambms_yambms${yambms_id} name: "Max Discharge Current" update_interval: ${yambms_update_interval} unit_of_measurement: A @@ -1381,8 +1381,8 @@ sensor: # cell_count - platform: template name: "Cell Count" - id: ${yambms_id}_cell_count - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_cell_count + device_id: yambms_yambms${yambms_id} update_interval: ${yambms_update_interval} icon: mdi:counter accuracy_decimals: 0 @@ -1394,8 +1394,8 @@ sensor: # min_voltage_cell MIN - platform: template - id: ${yambms_id}_min_voltage_cell - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_min_voltage_cell + device_id: yambms_yambms${yambms_id} name: "Min Voltage Cell" update_interval: ${yambms_update_interval} icon: mdi:numeric @@ -1408,8 +1408,8 @@ sensor: # max_voltage_cell MAX - platform: template - id: ${yambms_id}_max_voltage_cell - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_max_voltage_cell + device_id: yambms_yambms${yambms_id} name: "Max Voltage Cell" update_interval: ${yambms_update_interval} icon: mdi:numeric @@ -1422,8 +1422,8 @@ sensor: # min_cell_voltage MIN - platform: template - id: ${yambms_id}_min_cell_voltage - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_min_cell_voltage + device_id: yambms_yambms${yambms_id} name: "Min Cell Voltage" update_interval: ${yambms_update_interval} unit_of_measurement: V @@ -1437,8 +1437,8 @@ sensor: # max_cell_voltage MAX - platform: template - id: ${yambms_id}_max_cell_voltage - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_max_cell_voltage + device_id: yambms_yambms${yambms_id} name: "Max Cell Voltage" update_interval: ${yambms_update_interval} unit_of_measurement: V @@ -1452,8 +1452,8 @@ sensor: # delta_cell_voltage - platform: template - id: ${yambms_id}_delta_cell_voltage - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_delta_cell_voltage + device_id: yambms_yambms${yambms_id} name: "Delta Cell Voltage" update_interval: ${yambms_update_interval} unit_of_measurement: V @@ -1467,8 +1467,8 @@ sensor: # total_voltage MEAN - platform: template - id: ${yambms_id}_total_voltage - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_total_voltage + device_id: yambms_yambms${yambms_id} name: "Total Voltage" update_interval: ${yambms_update_interval} unit_of_measurement: V @@ -1482,8 +1482,8 @@ sensor: # current SUM - platform: template - id: ${yambms_id}_current - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_current + device_id: yambms_yambms${yambms_id} name: "Current" update_interval: ${yambms_update_interval} unit_of_measurement: A @@ -1497,8 +1497,8 @@ sensor: # power SUM - platform: template - id: ${yambms_id}_power - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_power + device_id: yambms_yambms${yambms_id} name: "Power" update_interval: ${yambms_update_interval} unit_of_measurement: W @@ -1513,8 +1513,8 @@ sensor: # battery_soc MEAN - platform: template name: "Battery SoC" - id: ${yambms_id}_battery_soc - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_battery_soc + device_id: yambms_yambms${yambms_id} update_interval: ${yambms_update_interval} unit_of_measurement: "%" device_class: battery @@ -1527,8 +1527,8 @@ sensor: # battery_soh MEAN - platform: template - id: ${yambms_id}_battery_soh - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_battery_soh + device_id: yambms_yambms${yambms_id} name: "Battery SoH" update_interval: ${yambms_update_interval} unit_of_measurement: "%" @@ -1542,8 +1542,8 @@ sensor: # installed_battery_capacity SUM - platform: template - id: ${yambms_id}_installed_battery_capacity - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_installed_battery_capacity + device_id: yambms_yambms${yambms_id} name: "Installed Battery Capacity" update_interval: ${yambms_update_interval} unit_of_measurement: Ah @@ -1554,12 +1554,12 @@ sensor: - or: - throttle: 10s - delta: 1 - lambda: return id(${yambms_id}_var_total_installed_battery_capacity); + lambda: return id(yambms${yambms_id}_var_total_installed_battery_capacity); # battery_capacity SUM - platform: template - id: ${yambms_id}_battery_capacity - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_battery_capacity + device_id: yambms_yambms${yambms_id} name: "Battery Capacity" update_interval: ${yambms_update_interval} unit_of_measurement: Ah @@ -1573,8 +1573,8 @@ sensor: # battery_capacity_remaining SUM - platform: template - id: ${yambms_id}_battery_capacity_remaining - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_battery_capacity_remaining + device_id: yambms_yambms${yambms_id} name: "Capacity Remaining" update_interval: ${yambms_update_interval} unit_of_measurement: Ah @@ -1588,8 +1588,8 @@ sensor: # cell_ovp MIN (Auto CCL) - platform: template - id: ${yambms_id}_cell_ovp - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_cell_ovp + device_id: yambms_yambms${yambms_id} name: "Cell OVP (MIN)" update_interval: ${yambms_update_interval} unit_of_measurement: V @@ -1603,8 +1603,8 @@ sensor: # cell_uvp MAX (Auto DCL and MAX Discharge Voltage) - platform: template - id: ${yambms_id}_cell_uvp - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_cell_uvp + device_id: yambms_yambms${yambms_id} name: "Cell UVP (MAX)" update_interval: ${yambms_update_interval} unit_of_measurement: V @@ -1618,8 +1618,8 @@ sensor: # balance_trigger_voltage MAX (Auto CVL) - platform: template - id: ${yambms_id}_balance_trigger_voltage - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_balance_trigger_voltage + device_id: yambms_yambms${yambms_id} name: "Balance Trigger Voltage (MAX)" update_interval: ${yambms_update_interval} unit_of_measurement: V @@ -1633,8 +1633,8 @@ sensor: # MIN temperature - platform: template - id: ${yambms_id}_min_temperature - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_min_temperature + device_id: yambms_yambms${yambms_id} name: "Min temperature" update_interval: ${yambms_update_interval} unit_of_measurement: °C @@ -1647,8 +1647,8 @@ sensor: # MAX temperature - platform: template - id: ${yambms_id}_max_temperature - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_max_temperature + device_id: yambms_yambms${yambms_id} name: "Max temperature" update_interval: ${yambms_update_interval} unit_of_measurement: °C @@ -1661,8 +1661,8 @@ sensor: # MIN temperature sensor - platform: template - id: ${yambms_id}_min_temperature_sensor - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_min_temperature_sensor + device_id: yambms_yambms${yambms_id} name: "Min temperature sensor" update_interval: ${yambms_update_interval} icon: mdi:numeric @@ -1675,8 +1675,8 @@ sensor: # MAX temperature sensor - platform: template - id: ${yambms_id}_max_temperature_sensor - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_max_temperature_sensor + device_id: yambms_yambms${yambms_id} name: "Max temperature sensor" update_interval: ${yambms_update_interval} icon: mdi:numeric @@ -1689,8 +1689,8 @@ sensor: # charging_cycles MEAN - platform: template - id: ${yambms_id}_charging_cycles - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_charging_cycles + device_id: yambms_yambms${yambms_id} name: "Charging Cycles" update_interval: ${yambms_update_interval} icon: mdi:counter @@ -1703,8 +1703,8 @@ sensor: # Alarm - errors_bitmask bitwise AND (16bit) - platform: template - id: ${yambms_id}_errors_bitmask_alarm - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_errors_bitmask_alarm + device_id: yambms_yambms${yambms_id} name: "Errors Bitmask Alarm" update_interval: ${yambms_update_interval} icon: mdi:alert-circle-outline @@ -1717,8 +1717,8 @@ sensor: # Warning - errors_bitmask bitwise OR (16bit) - platform: template - id: ${yambms_id}_errors_bitmask_warning - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_errors_bitmask_warning + device_id: yambms_yambms${yambms_id} name: "Errors Bitmask Warning" update_interval: ${yambms_update_interval} icon: mdi:alert-circle-outline @@ -1731,8 +1731,8 @@ sensor: # BMS in alarm (errors_bitmask_counter) - platform: template - id: ${yambms_id}_errors_bitmask_counter - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_errors_bitmask_counter + device_id: yambms_yambms${yambms_id} name: "BMS in alarm" update_interval: ${yambms_update_interval} icon: mdi:counter @@ -1746,8 +1746,8 @@ sensor: # BMS count - platform: template name: "BMS count" - id: ${yambms_id}_bms_count - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_bms_count + device_id: yambms_yambms${yambms_id} update_interval: ${yambms_update_interval} icon: mdi:counter state_class: measurement @@ -1760,8 +1760,8 @@ sensor: # BMS combined - platform: template name: "BMS combined" - id: ${yambms_id}_bms_combined - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_bms_combined + device_id: yambms_yambms${yambms_id} update_interval: ${yambms_update_interval} icon: mdi:counter state_class: measurement @@ -1774,8 +1774,8 @@ sensor: # BMS blocking charge - platform: template name: "BMS blocking charge" - id: ${yambms_id}_bms_blocking_charge - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_bms_blocking_charge + device_id: yambms_yambms${yambms_id} update_interval: ${yambms_update_interval} icon: mdi:counter state_class: measurement @@ -1788,8 +1788,8 @@ sensor: # BMS blocking discharge - platform: template name: "BMS blocking discharge" - id: ${yambms_id}_bms_blocking_discharge - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_bms_blocking_discharge + device_id: yambms_yambms${yambms_id} update_interval: ${yambms_update_interval} icon: mdi:counter state_class: measurement @@ -1802,8 +1802,8 @@ sensor: # Shunt count - platform: template name: "Shunt count" - id: ${yambms_id}_shunt_count - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_shunt_count + device_id: yambms_yambms${yambms_id} update_interval: ${yambms_update_interval} icon: mdi:counter state_class: measurement @@ -1816,8 +1816,8 @@ sensor: # Shunt combined - platform: template name: "Shunt combined" - id: ${yambms_id}_shunt_combined - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_shunt_combined + device_id: yambms_yambms${yambms_id} update_interval: ${yambms_update_interval} icon: mdi:counter state_class: measurement @@ -1830,8 +1830,8 @@ sensor: # Battery Charging Power - platform: template name: "Battery Charging Power" - id: ${yambms_id}_battery_charging_power - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_battery_charging_power + device_id: yambms_yambms${yambms_id} update_interval: ${yambms_update_interval} unit_of_measurement: 'W' device_class: power @@ -1841,8 +1841,8 @@ sensor: # Battery Discharging Power - platform: template name: "Battery Discharging Power" - id: ${yambms_id}_battery_discharging_power - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_battery_discharging_power + device_id: yambms_yambms${yambms_id} update_interval: ${yambms_update_interval} unit_of_measurement: 'W' device_class: power @@ -1852,8 +1852,8 @@ sensor: # Daily Charging Energy - platform: total_daily_energy name: "Daily Charging Energy" - device_id: yambms_${yambms_id} - power_id: ${yambms_id}_battery_charging_power + device_id: yambms_yambms${yambms_id} + power_id: yambms${yambms_id}_battery_charging_power unit_of_measurement: 'kWh' device_class: energy state_class: total_increasing @@ -1865,8 +1865,8 @@ sensor: # Daily Discharging Energy - platform: total_daily_energy name: "Daily Discharging Energy" - device_id: yambms_${yambms_id} - power_id: ${yambms_id}_battery_discharging_power + device_id: yambms_yambms${yambms_id} + power_id: yambms${yambms_id}_battery_discharging_power unit_of_measurement: 'kWh' device_class: energy state_class: total_increasing @@ -1880,8 +1880,8 @@ sensor: # +--------------------------------------+ - platform: template name: "Requested Charge Voltage" - id: ${yambms_id}_requested_charge_voltage - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_requested_charge_voltage + device_id: yambms_yambms${yambms_id} update_interval: ${yambms_update_interval} unit_of_measurement: V device_class: voltage @@ -1897,8 +1897,8 @@ sensor: # +--------------------------------------+ - platform: template name: "Requested Discharge Voltage" - id: ${yambms_id}_requested_discharge_voltage - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_requested_discharge_voltage + device_id: yambms_yambms${yambms_id} update_interval: ${yambms_update_interval} unit_of_measurement: V device_class: voltage @@ -1914,8 +1914,8 @@ sensor: # +--------------------------------------+ - platform: template name: "Requested Charge Current" - id: ${yambms_id}_requested_charge_current - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_requested_charge_current + device_id: yambms_yambms${yambms_id} update_interval: ${yambms_update_interval} unit_of_measurement: A device_class: current @@ -1927,15 +1927,15 @@ sensor: - delta: 1 on_value: then: - - component.update: ${yambms_id}_ccl_derating_reason + - component.update: yambms${yambms_id}_ccl_derating_reason # +--------------------------------------+ # | Requested Discharge Current (DCL) | # +--------------------------------------+ - platform: template name: "Requested Discharge Current" - id: ${yambms_id}_requested_discharge_current - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_requested_discharge_current + device_id: yambms_yambms${yambms_id} update_interval: ${yambms_update_interval} unit_of_measurement: A device_class: current @@ -1947,26 +1947,26 @@ sensor: - delta: 1 on_value: then: - - component.update: ${yambms_id}_dcl_derating_reason + - component.update: yambms${yambms_id}_dcl_derating_reason # +--------------------------------------+ # | Last Complete Charge | # +--------------------------------------+ - platform: template name: "Last Complete Charge Timestamp" - id: ${yambms_id}_eoc_timestamp_template - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_eoc_timestamp_template + device_id: yambms_yambms${yambms_id} device_class: timestamp entity_category: diagnostic internal: true - lambda: return id(${yambms_id}_var_eoc_timestamp); + lambda: return id(yambms${yambms_id}_var_eoc_timestamp); on_value: then: - text_sensor.template.publish: - id: ${yambms_id}_eoc_timestamp_human + id: yambms${yambms_id}_eoc_timestamp_human state: !lambda |- char str[19]; - strftime(str, sizeof(str), " %H:%M %d %b %Y", localtime(&id(${yambms_id}_var_eoc_timestamp))); + strftime(str, sizeof(str), " %H:%M %d %b %Y", localtime(&id(yambms${yambms_id}_var_eoc_timestamp))); return {str}; @@ -1977,8 +1977,8 @@ text_sensor: # +--------------------------------------+ - platform: template name: "Charging Instruction" - id: ${yambms_id}_charging_instruction - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_charging_instruction + device_id: yambms_yambms${yambms_id} update_interval: ${yambms_update_interval} icon: mdi:battery-plus # +--------------------------------------+ @@ -1986,8 +1986,8 @@ text_sensor: # +--------------------------------------+ - platform: template name: "Last Complete Charge" - id: ${yambms_id}_eoc_timestamp_human - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_eoc_timestamp_human + device_id: yambms_yambms${yambms_id} icon: mdi:clock-start entity_category: diagnostic # +--------------------------------------+ @@ -1996,8 +1996,8 @@ text_sensor: # +--------------------------------------+ - platform: template name: "Charging Status" - id: ${yambms_id}_charging_status - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_charging_status + device_id: yambms_yambms${yambms_id} update_interval: ${yambms_update_interval} icon: mdi:battery-arrow-up @@ -2025,18 +2025,18 @@ text_sensor: # YamBMS Protection Alarm (all-bms) - platform: template name: "Alarm" - id: ${yambms_id}_alarm - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_alarm + device_id: yambms_yambms${yambms_id} update_interval: ${yambms_update_interval} entity_category: diagnostic icon: mdi:battery-alert lambda: |- // Error Bitmask ? - uint16_t errors_bitmask = id(${yambms_id}_errors_bitmask_alarm).state; - int eb_counter = id(${yambms_id}_errors_bitmask_counter).state; + uint16_t errors_bitmask = id(yambms${yambms_id}_errors_bitmask_alarm).state; + int eb_counter = id(yambms${yambms_id}_errors_bitmask_counter).state; // At least one BMS in alarm - if ((eb_counter > 0) && (eb_counter < id(${yambms_id}_var_bms_counter))) return {"Warning"}; + if ((eb_counter > 0) && (eb_counter < id(yambms${yambms_id}_var_bms_counter))) return {"Warning"}; // All BMS are in alarm else if (errors_bitmask > 0) { @@ -2059,14 +2059,14 @@ text_sensor: # YamBMS Warning (one-bms) - platform: template name: "Warning" - id: ${yambms_id}_warning - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_warning + device_id: yambms_yambms${yambms_id} update_interval: ${yambms_update_interval} entity_category: diagnostic icon: mdi:battery-alert lambda: |- // Error Bitmask ? - uint16_t errors_bitmask = id(${yambms_id}_errors_bitmask_warning).state; + uint16_t errors_bitmask = id(yambms${yambms_id}_errors_bitmask_warning).state; if (errors_bitmask > 0) { @@ -2091,17 +2091,17 @@ text_sensor: # +----------------------------------------+ - platform: template name: "CCL Derating Reason" - id: ${yambms_id}_ccl_derating_reason - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_ccl_derating_reason + device_id: yambms_yambms${yambms_id} icon: "mdi:information-outline" update_interval: never entity_category: diagnostic lambda: |- - float limit_1 = id(${yambms_id}_var_auto_temperature_ccl); - float limit_2 = id(${yambms_id}_var_auto_eoc); - float limit_3 = id(${yambms_id}_var_auto_ccl); - float limit_4 = id(${yambms_id}_var_auto_ccl_soft_landing); - float limit_5 = id(${yambms_id}_var_auto_soc_limit); + float limit_1 = id(yambms${yambms_id}_var_auto_temperature_ccl); + float limit_2 = id(yambms${yambms_id}_var_auto_eoc); + float limit_3 = id(yambms${yambms_id}_var_auto_ccl); + float limit_4 = id(yambms${yambms_id}_var_auto_ccl_soft_landing); + float limit_5 = id(yambms${yambms_id}_var_auto_soc_limit); float min_val = std::min({limit_1, limit_2, limit_3, limit_4, limit_5}); @@ -2118,14 +2118,14 @@ text_sensor: # +----------------------------------------+ - platform: template name: "DCL Derating Reason" - id: ${yambms_id}_dcl_derating_reason - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_dcl_derating_reason + device_id: yambms_yambms${yambms_id} icon: "mdi:information-outline" update_interval: never entity_category: diagnostic lambda: |- - float limit_1 = id(${yambms_id}_var_auto_temperature_dcl); - float limit_2 = id(${yambms_id}_var_auto_dcl); + float limit_1 = id(yambms${yambms_id}_var_auto_temperature_dcl); + float limit_2 = id(yambms${yambms_id}_var_auto_dcl); float min_val = std::min(limit_1, limit_2); diff --git a/packages/yambms/yambms_rs485_pylon.yaml b/packages/yambms/yambms_rs485_pylon.yaml index 461d95c..8bd5d90 100644 --- a/packages/yambms/yambms_rs485_pylon.yaml +++ b/packages/yambms/yambms_rs485_pylon.yaml @@ -1,5 +1,5 @@ -# Updated : 2026.03.23 -# Version : 1.3.9 +# Updated : 2026.06.27 +# Version : 1.4.0 # GitHub : https://github.com/fahmula/esphome-pylontech-rs485 # YamBMS ( Yet another multi-BMS Merging Solution ) @@ -193,8 +193,8 @@ interval: then: - lambda: |- // Save RS485 options - id(${yambms_id}_var_inverter_bms_name) = "RS485"; - id(${yambms_id}_var_inverter_protocol) = id(rs485${rs485_id}_protocol).current_option(); + id(yambms${yambms_id}_var_inverter_bms_name) = "RS485"; + id(yambms${yambms_id}_var_inverter_protocol) = id(rs485${rs485_id}_protocol).current_option(); - interval: 100ms then: @@ -207,27 +207,27 @@ interval: if (id(rs485${rs485_id}_status).has_state()) id(inverter_com_status).publish_state(id(rs485${rs485_id}_status).state); // --- Check YamBMS initialized + BMS ONLINE/OFFLINE status --- - if ((id(${yambms_id}_var_initialized) == true) && (id(${yambms_id}_bms_combined).state > 0)) + if ((id(yambms${yambms_id}_var_initialized) == true) && (id(yambms${yambms_id}_bms_combined).state > 0)) { // --- STATE 1: BMS is ONLINE --- // Sensor Values - if (id(${yambms_id}_battery_soc).has_state()) id(rs485${rs485_id}_proxy_soc).publish_state(id(${yambms_id}_battery_soc).state); - if (id(${yambms_id}_total_voltage).has_state()) id(rs485${rs485_id}_proxy_voltage).publish_state(id(${yambms_id}_total_voltage).state); - if (id(${yambms_id}_current).has_state()) id(rs485${rs485_id}_proxy_current).publish_state(id(${yambms_id}_current).state); - if (id(${yambms_id}_max_temperature).has_state()) id(rs485${rs485_id}_proxy_temperature).publish_state(id(${yambms_id}_max_temperature).state); - if (id(${yambms_id}_battery_soh).has_state()) id(rs485${rs485_id}_proxy_soh).publish_state(id(${yambms_id}_battery_soh).state); - if (id(${yambms_id}_charging_cycles).has_state()) id(rs485${rs485_id}_proxy_cycle_count).publish_state(id(${yambms_id}_charging_cycles).state); - if (id(${yambms_id}_max_cell_voltage).has_state()) id(rs485${rs485_id}_proxy_max_cell_v).publish_state(id(${yambms_id}_max_cell_voltage).state); - if (id(${yambms_id}_min_cell_voltage).has_state()) id(rs485${rs485_id}_proxy_min_cell_v).publish_state(id(${yambms_id}_min_cell_voltage).state); - if (id(${yambms_id}_max_temperature).has_state()) id(rs485${rs485_id}_proxy_max_temp).publish_state(id(${yambms_id}_max_temperature).state); - if (id(${yambms_id}_min_temperature).has_state()) id(rs485${rs485_id}_proxy_min_temp).publish_state(id(${yambms_id}_min_temperature).state); - if (id(${yambms_id}_requested_charge_voltage).has_state()) id(rs485${rs485_id}_proxy_max_charge_v).publish_state(id(${yambms_id}_requested_charge_voltage).state); - if (id(${yambms_id}_requested_discharge_voltage).has_state()) id(rs485${rs485_id}_proxy_min_discharge_v).publish_state(id(${yambms_id}_requested_discharge_voltage).state); - if (id(${yambms_id}_requested_charge_current).has_state()) id(rs485${rs485_id}_proxy_max_charge_i).publish_state(id(${yambms_id}_requested_charge_current).state); - if (id(${yambms_id}_requested_discharge_current).has_state()) id(rs485${rs485_id}_proxy_max_discharge_i).publish_state(id(${yambms_id}_requested_discharge_current).state); + if (id(yambms${yambms_id}_battery_soc).has_state()) id(rs485${rs485_id}_proxy_soc).publish_state(id(yambms${yambms_id}_battery_soc).state); + if (id(yambms${yambms_id}_total_voltage).has_state()) id(rs485${rs485_id}_proxy_voltage).publish_state(id(yambms${yambms_id}_total_voltage).state); + if (id(yambms${yambms_id}_current).has_state()) id(rs485${rs485_id}_proxy_current).publish_state(id(yambms${yambms_id}_current).state); + if (id(yambms${yambms_id}_max_temperature).has_state()) id(rs485${rs485_id}_proxy_temperature).publish_state(id(yambms${yambms_id}_max_temperature).state); + if (id(yambms${yambms_id}_battery_soh).has_state()) id(rs485${rs485_id}_proxy_soh).publish_state(id(yambms${yambms_id}_battery_soh).state); + if (id(yambms${yambms_id}_charging_cycles).has_state()) id(rs485${rs485_id}_proxy_cycle_count).publish_state(id(yambms${yambms_id}_charging_cycles).state); + if (id(yambms${yambms_id}_max_cell_voltage).has_state()) id(rs485${rs485_id}_proxy_max_cell_v).publish_state(id(yambms${yambms_id}_max_cell_voltage).state); + if (id(yambms${yambms_id}_min_cell_voltage).has_state()) id(rs485${rs485_id}_proxy_min_cell_v).publish_state(id(yambms${yambms_id}_min_cell_voltage).state); + if (id(yambms${yambms_id}_max_temperature).has_state()) id(rs485${rs485_id}_proxy_max_temp).publish_state(id(yambms${yambms_id}_max_temperature).state); + if (id(yambms${yambms_id}_min_temperature).has_state()) id(rs485${rs485_id}_proxy_min_temp).publish_state(id(yambms${yambms_id}_min_temperature).state); + if (id(yambms${yambms_id}_requested_charge_voltage).has_state()) id(rs485${rs485_id}_proxy_max_charge_v).publish_state(id(yambms${yambms_id}_requested_charge_voltage).state); + if (id(yambms${yambms_id}_requested_discharge_voltage).has_state()) id(rs485${rs485_id}_proxy_min_discharge_v).publish_state(id(yambms${yambms_id}_requested_discharge_voltage).state); + if (id(yambms${yambms_id}_requested_charge_current).has_state()) id(rs485${rs485_id}_proxy_max_charge_i).publish_state(id(yambms${yambms_id}_requested_charge_current).state); + if (id(yambms${yambms_id}_requested_discharge_current).has_state()) id(rs485${rs485_id}_proxy_max_discharge_i).publish_state(id(yambms${yambms_id}_requested_discharge_current).state); // Binary Sensors (Alarms/Protections) - if (id(${yambms_id}_errors_bitmask_warning).has_state()) { - uint16_t mask = id(${yambms_id}_errors_bitmask_warning).state; + if (id(yambms${yambms_id}_errors_bitmask_warning).has_state()) { + uint16_t mask = id(yambms${yambms_id}_errors_bitmask_warning).state; id(rs485${rs485_id}_proxy_total_voltage_high_alarm).publish_state((mask & 0x0002) > 0); id(rs485${rs485_id}_proxy_total_voltage_low_alarm).publish_state((mask & 0x0004) > 0); id(rs485${rs485_id}_proxy_cell_temp_high_alarm).publish_state((mask & 0x0008) > 0); @@ -238,8 +238,8 @@ interval: id(rs485${rs485_id}_proxy_cell_voltage_high_alarm).publish_state((mask & 0x0002) > 0); id(rs485${rs485_id}_proxy_cell_voltage_low_alarm).publish_state((mask & 0x0004) > 0); } - if (id(${yambms_id}_errors_bitmask_alarm).has_state()) { - uint16_t mask = id(${yambms_id}_errors_bitmask_alarm).state; + if (id(yambms${yambms_id}_errors_bitmask_alarm).has_state()) { + uint16_t mask = id(yambms${yambms_id}_errors_bitmask_alarm).state; id(rs485${rs485_id}_proxy_cell_overvoltage_protection).publish_state((mask & 0x0002) > 0); id(rs485${rs485_id}_proxy_cell_undervoltage_protection).publish_state((mask & 0x0004) > 0); id(rs485${rs485_id}_proxy_cell_overtemp_protection).publish_state((mask & 0x0008) > 0); @@ -325,7 +325,7 @@ pylontech_rs485: min_voltage: rs485${rs485_id}_proxy_min_discharge_v max_charge_current: rs485${rs485_id}_proxy_max_charge_i max_discharge_current: rs485${rs485_id}_proxy_max_discharge_i - requested_force_charge: ${yambms_id}_requested_force_charge + requested_force_charge: yambms${yambms_id}_requested_force_charge # --- Inverter Heartbeat & Com Status --- inverter_heartbeat: rs485${rs485_id}_inverter_heartbeat rs485_status: rs485${rs485_id}_status diff --git a/packages/yambms/yambms_service.yaml b/packages/yambms/yambms_service.yaml index 28abce5..5b0ae5d 100644 --- a/packages/yambms/yambms_service.yaml +++ b/packages/yambms/yambms_service.yaml @@ -1,5 +1,5 @@ -# Updated : 2026.03.23 -# Version : 1.2.6 +# Updated : 2026.06.27 +# Version : 1.2.7 # GitHub : https://github.com/Sleeper85/esphome-yambms # YamBMS ( Yet another multi-BMS Merging Solution ) @@ -21,8 +21,8 @@ esphome: on_boot: - priority: 600 then: - - lambda: id(${yambms_id}_running_version).publish_state("${yambms_version}"); - - lambda: id(${yambms_id}_last_version).publish_state("${yambms_version}"); + - lambda: id(yambms${yambms_id}_running_version).publish_state("${yambms_version}"); + - lambda: id(yambms${yambms_id}_last_version).publish_state("${yambms_version}"); text_sensor: # +--------------------------------------+ @@ -30,15 +30,15 @@ text_sensor: # +--------------------------------------+ - platform: template name: "Running version" - id: ${yambms_id}_running_version - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_running_version + device_id: yambms_yambms${yambms_id} icon: mdi:cogs entity_category: diagnostic update_interval: never - platform: template name: "Last version" - id: ${yambms_id}_last_version - device_id: yambms_${yambms_id} + id: yambms${yambms_id}_last_version + device_id: yambms_yambms${yambms_id} icon: mdi:new-box entity_category: diagnostic update_interval: never @@ -53,7 +53,7 @@ interval: if: condition: and: - - lambda : return id(${yambms_id}_var_service) == true; + - lambda : return id(yambms${yambms_id}_var_service) == true; - lambda : return id(my_network).is_connected(); then: - http_request.get: @@ -64,7 +64,7 @@ interval: - lambda: |- json::parse_json(body, [](JsonObject root) -> bool { // Explicitly cast to std::string to resolve ambiguity - id(${yambms_id}_last_version).publish_state(root["version"].as()); + id(yambms${yambms_id}_last_version).publish_state(root["version"].as()); return true; }); @@ -79,8 +79,8 @@ interval: root["board_name"] = "${board_name}"; root["bms_model"] = "${bms_model}"; root["bms_protocol"] = "${bms_protocol}"; - root["bms_count"] = id(${yambms_id}_var_bms_counter); - root["canbus_name"] = id(${yambms_id}_var_inverter_bms_name); - root["canbus_protocol"] = id(${yambms_id}_var_inverter_protocol); + root["bms_count"] = id(yambms${yambms_id}_var_bms_counter); + root["canbus_name"] = id(yambms${yambms_id}_var_inverter_bms_name); + root["canbus_protocol"] = id(yambms${yambms_id}_var_inverter_protocol); root["uptime"] = id(esp32_uptime).state; root["date_time_now"] = id(esp32_date_time_now).state; diff --git a/packages/yambms/yambms_web_server.yaml b/packages/yambms/yambms_web_server.yaml index 44384a0..a888008 100644 --- a/packages/yambms/yambms_web_server.yaml +++ b/packages/yambms/yambms_web_server.yaml @@ -1,5 +1,5 @@ -# Updated : 2026.01.16 -# Version : 1.1.4 +# Updated : 2026.06.27 +# Version : 1.1.5 # GitHub : https://github.com/Sleeper85/esphome-yambms # YamBMS ( Yet another multi-BMS Merging Solution ) @@ -74,137 +74,137 @@ web_server: select: # YamBMS - Auto Float - - id: !extend ${yambms_id}_auto_float_mode + - id: !extend yambms${yambms_id}_auto_float_mode web_server: sorting_group_id: yambms_auto_float binary_sensor: # YamBMS - Request force charge - - id: !extend ${yambms_id}_requested_force_charge + - id: !extend yambms${yambms_id}_requested_force_charge web_server: sorting_group_id: yambms_request_force_charge # YamBMS - Charge / Discharge switch - - id: !extend ${yambms_id}_charging_allowed + - id: !extend yambms${yambms_id}_charging_allowed web_server: sorting_group_id: yambms_charge_discharge_switch - - id: !extend ${yambms_id}_discharging_allowed + - id: !extend yambms${yambms_id}_discharging_allowed web_server: sorting_group_id: yambms_charge_discharge_switch text_sensor: # YamBMS - Charging Settings - - id: !extend ${yambms_id}_charging_status + - id: !extend yambms${yambms_id}_charging_status web_server: sorting_group_id: yambms_charging_settings - - id: !extend ${yambms_id}_charging_instruction + - id: !extend yambms${yambms_id}_charging_instruction web_server: sorting_group_id: yambms_charging_settings # YamBMS - Max requested current - - id: !extend ${yambms_id}_ccl_derating_reason + - id: !extend yambms${yambms_id}_ccl_derating_reason web_server: sorting_group_id: yambms_max_requested_current - - id: !extend ${yambms_id}_dcl_derating_reason + - id: !extend yambms${yambms_id}_dcl_derating_reason web_server: sorting_group_id: yambms_max_requested_current switch: # YamBMS - Charging Settings - - id: !extend ${yambms_id}_switch_float + - id: !extend yambms${yambms_id}_switch_float web_server: sorting_group_id: yambms_charging_settings - - id: !extend ${yambms_id}_switch_eoc_timer + - id: !extend yambms${yambms_id}_switch_eoc_timer web_server: sorting_group_id: yambms_charging_settings # YamBMS - ReBulk - - id: !extend ${yambms_id}_switch_force_bulk + - id: !extend yambms${yambms_id}_switch_force_bulk web_server: sorting_group_id: yambms_rebulk # YamBMS - Request force charge - - id: !extend ${yambms_id}_switch_request_force_charge + - id: !extend yambms${yambms_id}_switch_request_force_charge web_server: sorting_group_id: yambms_request_force_charge # YamBMS - Charge / Discharge switch - - id: !extend ${yambms_id}_switch_charging + - id: !extend yambms${yambms_id}_switch_charging web_server: sorting_group_id: yambms_charge_discharge_switch - - id: !extend ${yambms_id}_switch_discharging + - id: !extend yambms${yambms_id}_switch_discharging web_server: sorting_group_id: yambms_charge_discharge_switch # YamBMS - Auto CVL - - id: !extend ${yambms_id}_switch_auto_cvl + - id: !extend yambms${yambms_id}_switch_auto_cvl web_server: sorting_group_id: yambms_auto_cvl # YamBMS - Auto CCL / DCL - - id: !extend ${yambms_id}_switch_auto_ccl + - id: !extend yambms${yambms_id}_switch_auto_ccl web_server: sorting_group_id: yambms_auto_ccl_dcl - - id: !extend ${yambms_id}_switch_auto_dcl + - id: !extend yambms${yambms_id}_switch_auto_dcl web_server: sorting_group_id: yambms_auto_ccl_dcl # YamBMS - Max requested current - - id: !extend ${yambms_id}_switch_temperature_based_current_limitation + - id: !extend yambms${yambms_id}_switch_temperature_based_current_limitation web_server: sorting_group_id: yambms_max_requested_current number: # YamBMS - Charging Settings - - id: !extend ${yambms_id}_bulk_voltage + - id: !extend yambms${yambms_id}_bulk_voltage web_server: sorting_group_id: yambms_charging_settings - - id: !extend ${yambms_id}_float_voltage + - id: !extend yambms${yambms_id}_float_voltage web_server: sorting_group_id: yambms_charging_settings - - id: !extend ${yambms_id}_inverter_offset_v + - id: !extend yambms${yambms_id}_inverter_offset_v web_server: sorting_group_id: yambms_charging_settings # YamBMS - ReBulk - - id: !extend ${yambms_id}_rebulk_soc + - id: !extend yambms${yambms_id}_rebulk_soc web_server: sorting_group_id: yambms_rebulk - - id: !extend ${yambms_id}_rebulk_voltage + - id: !extend yambms${yambms_id}_rebulk_voltage web_server: sorting_group_id: yambms_rebulk # YamBMS - Max requested current - - id: !extend ${yambms_id}_max_requested_charge_current + - id: !extend yambms${yambms_id}_max_requested_charge_current web_server: sorting_group_id: yambms_max_requested_current - - id: !extend ${yambms_id}_max_requested_discharge_current + - id: !extend yambms${yambms_id}_max_requested_discharge_current web_server: sorting_group_id: yambms_max_requested_current # YamBMS - Request force charge - - id: !extend ${yambms_id}_request_force_charge_start_soc + - id: !extend yambms${yambms_id}_request_force_charge_start_soc web_server: sorting_group_id: yambms_request_force_charge - - id: !extend ${yambms_id}_request_force_charge_stop_soc + - id: !extend yambms${yambms_id}_request_force_charge_stop_soc web_server: sorting_group_id: yambms_request_force_charge # YamBMS - Auto CVL - - id: !extend ${yambms_id}_auto_cvl_boost_charge_v + - id: !extend yambms${yambms_id}_auto_cvl_boost_charge_v web_server: sorting_group_id: yambms_auto_cvl # YamBMS - Auto Float - - id: !extend ${yambms_id}_auto_float_step_v + - id: !extend yambms${yambms_id}_auto_float_step_v web_server: sorting_group_id: yambms_auto_float - - id: !extend ${yambms_id}_auto_float_interval + - id: !extend yambms${yambms_id}_auto_float_interval web_server: sorting_group_id: yambms_auto_float sensor: # YamBMS - Requested Values - - id: !extend ${yambms_id}_requested_charge_voltage + - id: !extend yambms${yambms_id}_requested_charge_voltage web_server: sorting_group_id: yambms_requested_values - - id: !extend ${yambms_id}_requested_discharge_voltage + - id: !extend yambms${yambms_id}_requested_discharge_voltage web_server: sorting_group_id: yambms_requested_values - - id: !extend ${yambms_id}_requested_charge_current + - id: !extend yambms${yambms_id}_requested_charge_current web_server: sorting_group_id: yambms_requested_values - - id: !extend ${yambms_id}_requested_discharge_current + - id: !extend yambms${yambms_id}_requested_discharge_current web_server: sorting_group_id: yambms_requested_values # YamBMS - Auto Float - - id: !extend ${yambms_id}_auto_float_v + - id: !extend yambms${yambms_id}_auto_float_v web_server: sorting_group_id: yambms_auto_float diff --git a/yambms_custom.yaml b/yambms_custom.yaml index 6f36b22..deedbbc 100644 --- a/yambms_custom.yaml +++ b/yambms_custom.yaml @@ -1,5 +1,5 @@ -# Updated : 2026.02.17 -# Version : 1.1.5 +# Updated : 2026.06.27 +# Version : 1.1.6 # GitHub : https://github.com/Sleeper85/esphome-yambms # YamBMS ( Yet another multi-BMS Merging Solution ) @@ -24,32 +24,34 @@ switch: # Force Float switch - platform: template - name: "${name} ${yambms_name} Force Float" - id: ${yambms_id}_switch_force_float + id: yambms${yambms_id}_switch_force_float + device_id: yambms_yambms${yambms_id} + name: "Force Float" restore_mode: RESTORE_DEFAULT_OFF optimistic: true entity_category: config turn_on_action: - globals.set: - id: ${yambms_id}_var_force_float + id: yambms${yambms_id}_var_force_float value: 'true' turn_off_action: - globals.set: - id: ${yambms_id}_var_force_float + id: yambms${yambms_id}_var_force_float value: 'false' # Update service switch - platform: template - name: "${name} ${yambms_name} Update service" + device_id: yambms_yambms${yambms_id} + name: "Update service" restore_mode: RESTORE_DEFAULT_ON optimistic: true entity_category: config turn_on_action: - globals.set: - id: ${yambms_id}_var_service + id: yambms${yambms_id}_var_service value: 'true' turn_off_action: - globals.set: - id: ${yambms_id}_var_service + id: yambms${yambms_id}_var_service value: 'false' interval: @@ -58,9 +60,9 @@ interval: then: - lambda: |- // Set min/max Float slider - id(${yambms_id}_float_voltage).traits.set_min_value(${yambms_cell_count} * 3.125); - id(${yambms_id}_float_voltage).traits.set_max_value(${yambms_cell_count} * 3.375); + id(yambms${yambms_id}_float_voltage).traits.set_min_value(${yambms_cell_count} * 3.125); + id(yambms${yambms_id}_float_voltage).traits.set_max_value(${yambms_cell_count} * 3.375); // Set min/max Inverter Offset Voltage slider - id(${yambms_id}_inverter_offset_v).traits.set_min_value(-3.0); - id(${yambms_id}_inverter_offset_v).traits.set_max_value(3.0); + id(yambms${yambms_id}_inverter_offset_v).traits.set_min_value(-3.0); + id(yambms${yambms_id}_inverter_offset_v).traits.set_max_value(3.0);