-
-
Save noone2k/2ddea4c9bf116aaaefb8626b064d9a41 to your computer and use it in GitHub Desktop.
| esphome: | |
| name: bc2500-ble-idf | |
| friendly_name: bc2500-ble-idf | |
| esp32: | |
| board: az-delivery-devkit-v4 | |
| framework: | |
| type: esp-idf | |
| sdkconfig_options: | |
| CONFIG_FREERTOS_UNICORE: y | |
| advanced: | |
| ignore_efuse_mac_crc: true | |
| # Enable logging | |
| logger: | |
| # level: INFO | |
| # level: DEBUG | |
| # baud_rate: 0 | |
| ota: | |
| password: !secret ota_password | |
| wifi: | |
| ssid: !secret wifi_ssid | |
| password: !secret wifi_password | |
| reboot_timeout: 0s | |
| fast_connect: True | |
| # Enable fallback hotspot (captive portal) in case wifi connection fails | |
| ap: | |
| ssid: "Bc2500-Ble Fallback Hotspot" | |
| web_server: | |
| port: 80 | |
| local: true | |
| js_include: "./v2/www.js" | |
| js_url: "" | |
| version: 2 | |
| captive_portal: | |
| mqtt: | |
| id: mqtt_client | |
| broker: !secret mqtt_broker | |
| port: !secret mqtt_port | |
| discovery: False | |
| reboot_timeout: 0s | |
| topic_prefix: b2500 | |
| log_topic: b2500/debug | |
| time: | |
| - platform: sntp | |
| id: sntp_time | |
| on_time: | |
| # Every 10 seconds | |
| - seconds: /10 | |
| then: | |
| - script.execute: ble_process | |
| - script.wait: ble_process | |
| #- script.execute: power_zero | |
| #- button.press: query_info3 | |
| globals: | |
| - id: ble_1_connected | |
| type: bool | |
| initial_value: '0' | |
| - id: ble_1_initialized | |
| type: bool | |
| initial_value: '0' | |
| - id: ble_2_connected | |
| type: bool | |
| initial_value: '0' | |
| - id: ble_2_initialized | |
| type: bool | |
| initial_value: '0' | |
| - id: cmd30_xor_last_1 | |
| type: int | |
| initial_value: '0' | |
| - id: cmd30_xor_last_2 | |
| type: int | |
| initial_value: '0' | |
| - id: internal_console_dbg | |
| type: bool | |
| initial_value: '0' | |
| - id: internal_console_hexdump | |
| type: bool | |
| initial_value: '1' | |
| esp32_ble_tracker: | |
| ble_client: | |
| - mac_address: !secret hm2500_1_mac | |
| id: bc2500_1 | |
| on_connect: | |
| then: | |
| - globals.set: | |
| id: ble_1_connected | |
| value: '1' | |
| - binary_sensor.template.publish: | |
| id: bool_ble_ok_1 | |
| state: ON | |
| - script.execute: | |
| id: ble_set_time | |
| ble_device_nr: 1 | |
| - script.wait: ble_set_time | |
| - script.execute: | |
| id: ble_set_time | |
| ble_device_nr: 1 | |
| - script.wait: ble_set_time | |
| on_disconnect: | |
| then: | |
| - binary_sensor.template.publish: | |
| id: bool_ble_ok_1 | |
| state: OFF | |
| - globals.set: | |
| id: ble_1_connected | |
| value: '0' | |
| - globals.set: | |
| id: ble_1_initialized | |
| value: '0' | |
| - mac_address: !secret hm2500_2_mac | |
| id: bc2500_2 | |
| on_connect: | |
| then: | |
| - globals.set: | |
| id: ble_2_connected | |
| value: '1' | |
| - binary_sensor.template.publish: | |
| id: bool_ble_ok_2 | |
| state: ON | |
| - script.execute: | |
| id: ble_set_time | |
| ble_device_nr: 2 | |
| - script.wait: ble_set_time | |
| - script.execute: | |
| id: ble_set_time | |
| ble_device_nr: 2 | |
| - script.wait: ble_set_time | |
| on_disconnect: | |
| then: | |
| - binary_sensor.template.publish: | |
| id: bool_ble_ok_2 | |
| state: OFF | |
| - globals.set: | |
| id: ble_2_connected | |
| value: '0' | |
| - globals.set: | |
| id: ble_2_initialized | |
| value: '0' | |
| button: | |
| - platform: restart | |
| id: controller_restart | |
| name: "Restart Controller" | |
| number: | |
| - platform: template | |
| name: "D1-52: Entladeschwelle" | |
| id: sensor_discharge_treshold_1 | |
| state_topic: b2500/1/battery/discharge_treshold | |
| command_topic: b2500/1/battery/discharge_treshold/set | |
| optimistic: True | |
| min_value: 1 | |
| max_value: 500 | |
| step: 1 | |
| restore_value: True | |
| on_value: | |
| - script.execute: | |
| id: ble_set_discharge_treshold | |
| ble_device_nr: 1 | |
| discharge: !lambda return x; | |
| - platform: template | |
| name: "D1-53: DOD" | |
| state_topic: b2500/1/battery/dod | |
| command_topic: b2500/1/battery/dod/set | |
| id: sensor_dod_1 | |
| optimistic: True | |
| min_value: 10 | |
| max_value: 100 | |
| step: 1 | |
| restore_value: True | |
| on_value: | |
| - script.execute: | |
| id: ble_set_dod | |
| ble_device_nr: 1 | |
| dod: !lambda return x; | |
| - platform: template | |
| name: "D2-52: Entladeschwelle" | |
| id: sensor_discharge_treshold_2 | |
| state_topic: b2500/2/battery/discharge_treshold | |
| command_topic: b2500/2/battery/discharge_treshold/set | |
| optimistic: True | |
| min_value: 1 | |
| max_value: 500 | |
| step: 1 | |
| restore_value: True | |
| on_value: | |
| - script.execute: | |
| id: ble_set_discharge_treshold | |
| ble_device_nr: 2 | |
| discharge: !lambda return x; | |
| - platform: template | |
| name: "D2-53: DOD" | |
| state_topic: b2500/2/battery/dod | |
| command_topic: b2500/2/battery/dod/set | |
| id: sensor_dod_2 | |
| optimistic: True | |
| min_value: 10 | |
| max_value: 100 | |
| step: 1 | |
| restore_value: True | |
| on_value: | |
| - script.execute: | |
| id: ble_set_dod | |
| ble_device_nr: 2 | |
| dod: !lambda return x; | |
| ### power zero | |
| - platform: template | |
| name: "MQTT: opendtu set limit" | |
| id: mqtt_opendtu_limit | |
| internal: False | |
| state_topic: !secret mqtt_opendtu_limit_cmd | |
| command_topic: !secret mqtt_opendtu_limit_state | |
| optimistic: True | |
| min_value: 1 | |
| max_value: 75 | |
| step: 1 | |
| restore_value: True | |
| - platform: template | |
| name: "MQTT: opendtu set limit max" | |
| id: mqtt_opendtu_limit_max | |
| internal: False | |
| optimistic: True | |
| min_value: 1 | |
| max_value: 75 | |
| step: 1 | |
| restore_value: True | |
| switch: | |
| - platform: template | |
| id: switch_powerout_1_1 | |
| name: "D1-01: Power Out 1" | |
| state_topic: b2500/1/power1/enabled | |
| command_topic: b2500/1/power1/enabled/set | |
| optimistic: True | |
| assumed_state: True | |
| on_turn_on: | |
| then: | |
| - switch.turn_on: switch_powerout_1_1 | |
| - script.execute: | |
| id: ble_powerout | |
| ble_device_nr: 1 | |
| on_turn_off: | |
| then: | |
| - switch.turn_off: switch_powerout_1_1 | |
| - script.execute: | |
| id: ble_powerout | |
| ble_device_nr: 1 | |
| - platform: template | |
| id: switch_powerout_1_2 | |
| name: "D1-02: Power Out 2" | |
| state_topic: b2500/1/power2/enabled | |
| command_topic: b2500/1/power2/enabled/set | |
| optimistic: True | |
| assumed_state: True | |
| on_turn_on: | |
| then: | |
| - switch.turn_on: switch_powerout_1_2 | |
| - script.execute: | |
| id: ble_powerout | |
| ble_device_nr: 1 | |
| on_turn_off: | |
| then: | |
| - switch.turn_off: switch_powerout_1_2 | |
| - script.execute: | |
| id: ble_powerout | |
| ble_device_nr: 1 | |
| - platform: template | |
| id: switch_powerout_2_1 | |
| name: "D2-01: Power Out 1" | |
| state_topic: b2500/2/power1/enabled | |
| command_topic: b2500/2/power1/enabled/set | |
| optimistic: True | |
| assumed_state: True | |
| on_turn_on: | |
| then: | |
| - script.execute: | |
| id: ble_powerout | |
| ble_device_nr: 2 | |
| on_turn_off: | |
| then: | |
| - script.execute: | |
| id: ble_powerout | |
| ble_device_nr: 2 | |
| - platform: template | |
| id: switch_powerout_2_2 | |
| name: "D2-02: Power Out 2" | |
| state_topic: b2500/2/power2/enabled | |
| command_topic: b2500/2/power2/enabled/set | |
| optimistic: True | |
| assumed_state: True | |
| on_turn_on: | |
| then: | |
| - script.execute: | |
| id: ble_powerout | |
| ble_device_nr: 2 | |
| on_turn_off: | |
| then: | |
| - script.execute: | |
| id: ble_powerout | |
| ble_device_nr: 2 | |
| - platform: template | |
| id: switch_pv2_passthrough_1 | |
| name: "D1-03: PV2 Passtrough" | |
| state_topic: b2500/1/pv2/passtrough | |
| command_topic: b2500/1/pv2/passtrough/set | |
| optimistic: True | |
| assumed_state: True | |
| on_turn_on: | |
| then: | |
| - script.execute: | |
| id: ble_passthrough | |
| ble_device_nr: 1 | |
| switch_cmd: 0 | |
| on_turn_off: | |
| then: | |
| - script.execute: | |
| id: ble_passthrough | |
| ble_device_nr: 1 | |
| switch_cmd: 1 | |
| - platform: template | |
| id: switch_pv2_passthrough_2 | |
| name: "D2-03: PV2 Passtrough" | |
| state_topic: b2500/2/pv2/passtrough | |
| command_topic: b2500/2/pv2/passtrough/set | |
| optimistic: True | |
| assumed_state: True | |
| on_turn_on: | |
| then: | |
| - script.execute: | |
| id: ble_passthrough | |
| ble_device_nr: 2 | |
| switch_cmd: 0 | |
| on_turn_off: | |
| then: | |
| - script.execute: | |
| id: ble_passthrough | |
| ble_device_nr: 2 | |
| switch_cmd: 1 | |
| - platform: template | |
| id: switch_debug_hexdump | |
| name: "INTERNAL:DEBUG HEXDUMP" | |
| optimistic: True | |
| #assumed_state: True | |
| - platform: template | |
| id: switch_opendtu_limit | |
| name: "MQTT: opendtu - zero power" | |
| optimistic: True | |
| #assumed_state: True | |
| text: | |
| - platform: template | |
| name: "A1-t01 - Device Type" | |
| id: txt_A01_1 | |
| state_topic: b2500/1/device/type | |
| optimistic: true | |
| max_length: 30 | |
| mode: text | |
| - platform: template | |
| name: "A1-t02 - Device ID" | |
| state_topic: b2500/1/device/id | |
| id: txt_A02_1 | |
| optimistic: true | |
| max_length: 30 | |
| mode: text | |
| - platform: template | |
| name: "A1-t03 - MAC" | |
| id: txt_A03_1 | |
| state_topic: b2500/1/device/ble_mac | |
| optimistic: true | |
| max_length: 30 | |
| mode: text | |
| - platform: template | |
| name: "A1-t04 - SSID" | |
| id: txt_A11_1 | |
| state_topic: b2500/1/device/wifi_ssid | |
| optimistic: true | |
| max_length: 30 | |
| mode: text | |
| - platform: template | |
| name: "A2-t01 - Device Type" | |
| id: txt_A01_2 | |
| state_topic: b2500/2/device/type | |
| optimistic: true | |
| max_length: 30 | |
| mode: text | |
| - platform: template | |
| name: "A2-t02 - Device ID" | |
| id: txt_A02_2 | |
| state_topic: b2500/2/device/id | |
| optimistic: true | |
| max_length: 30 | |
| mode: text | |
| - platform: template | |
| name: "A2-t03 - MAC" | |
| id: txt_A03_2 | |
| optimistic: true | |
| state_topic: b2500/2/device/ble_mac | |
| max_length: 30 | |
| mode: text | |
| - platform: template | |
| name: "A2-t04 - SSID" | |
| id: txt_A11_2 | |
| state_topic: b2500/2/device/wifi_ssid | |
| optimistic: true | |
| max_length: 30 | |
| mode: text | |
| - platform: template | |
| name: "A1-t56: Szene" | |
| id: txt_scene_1 | |
| state_topic: b2500/1/device/scene | |
| optimistic: true | |
| max_length: 32 | |
| mode: text | |
| - platform: template | |
| name: "A1-t57: Region" | |
| id: txt_region_1 | |
| state_topic: b2500/1/device/region | |
| optimistic: true | |
| max_length: 8 | |
| mode: text | |
| - platform: template | |
| name: "A2-t56: Szene" | |
| id: txt_scene_2 | |
| state_topic: b2500/2/device/scene | |
| optimistic: true | |
| max_length: 32 | |
| mode: text | |
| - platform: template | |
| name: "A2-t57: Region" | |
| id: txt_region_2 | |
| state_topic: b2500/2/device/region | |
| optimistic: true | |
| max_length: 8 | |
| mode: text | |
| binary_sensor: | |
| - platform: template | |
| name: "D1-i01: PV 1 - Aktiv" | |
| id: bool_pv_active_1_1 | |
| state_topic: b2500/1/pv1/active | |
| - platform: template | |
| name: "D1-i11: PV 2 - Aktiv" | |
| id: bool_pv_active_1_2 | |
| state_topic: b2500/1/pv2/active | |
| - platform: template | |
| name: "D1-i02: PV 1 - Transparent" | |
| id: bool_pv_transparent_1_1 | |
| state_topic: b2500/1/pv1/transparent | |
| - platform: template | |
| name: "D1-i11: PV 2 - Transparent" | |
| id: bool_pv_transparent_1_2 | |
| state_topic: b2500/1/pv2/transparent | |
| - platform: template | |
| name: "D1-i54: Wifi Connected (?)" | |
| id: bool_wifi_ok_1 | |
| state_topic: b2500/1/device/wifi_ok | |
| - platform: template | |
| name: "D1-i55: MQTT1 Connected" | |
| id: bool_mqtt1_ok_1 | |
| state_topic: b2500/1/device/mqtt_ok | |
| - platform: template | |
| name: "D1-i58: BLE Connected" | |
| id: bool_ble_ok_1 | |
| state_topic: b2500/1/device/ble_ok | |
| - platform: template | |
| name: "D1-i21: Ausgang 1 - Aktiv" | |
| id: bool_power_active_1_1 | |
| state_topic: b2500/1/power1/active | |
| - platform: template | |
| name: "D1-i31: Ausgang 2 - Aktiv" | |
| id: bool_power_active_1_2 | |
| state_topic: b2500/1/power2/active | |
| - platform: template | |
| name: "D1-i40: Erweiterung 1 - angeschlossen" | |
| id: bool_extern_connected_1_1 | |
| state_topic: b2500/1/extern1/connected | |
| - platform: template | |
| name: "D1-i41: Erweiterung 2 - angeschlossen" | |
| id: bool_extern_connected_1_2 | |
| state_topic: b2500/1/extern2/connected | |
| - platform: template | |
| name: "D2-i01: PV 1 - Aktiv" | |
| id: bool_pv_active_2_1 | |
| state_topic: b2500/2/pv1/active | |
| - platform: template | |
| name: "D2-i11: PV 2 - Aktiv" | |
| id: bool_pv_active_2_2 | |
| state_topic: b2500/2/pv2/active | |
| - platform: template | |
| name: "D2-i02: PV 1 - Transparent" | |
| id: bool_pv_transparent_2_1 | |
| state_topic: b2500/2/pv1/transparent | |
| - platform: template | |
| name: "D2-i12: PV 2 - Transparent" | |
| id: bool_pv_transparent_2_2 | |
| state_topic: b2500/2/pv2/transparent | |
| - platform: template | |
| name: "D2-i54: Wifi Connected (?)" | |
| id: bool_wifi_ok_2 | |
| state_topic: b2500/2/device/wifi_ok | |
| - platform: template | |
| name: "D2-i55: MQTT1 Connected" | |
| id: bool_mqtt1_ok_2 | |
| state_topic: b2500/2/device/mqtt_ok | |
| - platform: template | |
| name: "D2-i58: BLE Connected" | |
| id: bool_ble_ok_2 | |
| state_topic: b2500/2/device/ble_ok | |
| - platform: template | |
| name: "D2-i21: Ausgang 1 - Aktiv" | |
| id: bool_power_active_2_1 | |
| state_topic: b2500/2/power1/active | |
| - platform: template | |
| name: "D2-i31: Ausgang 2 - Aktiv" | |
| id: bool_power_active_2_2 | |
| state_topic: b2500/2/power2/active | |
| - platform: template | |
| name: "D2-i40: Erweiterung 1 - angeschlossen" | |
| id: bool_extern_connected_2_1 | |
| state_topic: b2500/2/extern1/connected | |
| - platform: template | |
| name: "D2-i41: Erweiterung 2 - angeschlossen" | |
| id: bool_extern_connected_2_2 | |
| state_topic: b2500/2/extern2/connected | |
| sensor: | |
| - platform: template | |
| name: "D1-i05: PV 1 - Leistung" | |
| id: sensor_pv_power_in_1_1 | |
| state_topic: b2500/1/pv1/power | |
| accuracy_decimals: 0 | |
| - platform: template | |
| name: "D1-i15: PV 2 - Leistung" | |
| id: sensor_pv_power_in_1_2 | |
| state_topic: b2500/1/pv2/power | |
| accuracy_decimals: 0 | |
| - platform: template | |
| name: "D1-i50: Füllstand der Batterie in Prozent" | |
| id: sensor_bat_remain_1 | |
| state_topic: b2500/1/battery/remaining_percent | |
| accuracy_decimals: 0 | |
| - platform: template | |
| name: "D1-i51: Füllstand der Batterie in Wh" | |
| id: sensor_bat_capacity_1 | |
| state_topic: b2500/1/battery/remaining_capacity | |
| accuracy_decimals: 0 | |
| - platform: template | |
| name: "D1-i25: Ausgang 1 - Leistung" | |
| id: sensor_power_out_1_1 | |
| state_topic: b2500/1/power1/power | |
| accuracy_decimals: 0 | |
| - platform: template | |
| name: "D1-i35: Ausgang 2 - Leistung" | |
| id: sensor_power_out_1_2 | |
| state_topic: b2500/1/power2/power | |
| accuracy_decimals: 0 | |
| - platform: template | |
| name: "A1-t59: Geräte Version" | |
| id: sensor_device_version_1 | |
| state_topic: b2500/1/device/fw_version | |
| accuracy_decimals: 2 | |
| - platform: template | |
| name: "D2-i05: PV 1 - Leistung" | |
| id: sensor_pv_power_in_2_1 | |
| state_topic: b2500/2/pv1/power | |
| accuracy_decimals: 0 | |
| - platform: template | |
| name: "D2-i15: PV 2 - Leistung" | |
| id: sensor_pv_power_in_2_2 | |
| state_topic: b2500/2/pv2/power | |
| accuracy_decimals: 0 | |
| - platform: template | |
| name: "D2-i50: Füllstand der Batterie in Prozent" | |
| id: sensor_bat_remain_2 | |
| state_topic: b2500/2/battery/remaining_percent | |
| accuracy_decimals: 0 | |
| - platform: template | |
| name: "D2-i51: Füllstand der Batterie in Wh" | |
| id: sensor_bat_capacity_2 | |
| state_topic: b2500/2/battery/remaining_capacity | |
| accuracy_decimals: 0 | |
| - platform: template | |
| name: "D2-i25: Ausgang 1 - Leistung " | |
| id: sensor_power_out_2_1 | |
| state_topic: b2500/2/power1/power | |
| accuracy_decimals: 0 | |
| - platform: template | |
| name: "D2-i35: Ausgang 2 - Leistung " | |
| id: sensor_power_out_2_2 | |
| state_topic: b2500/2/power2/power | |
| accuracy_decimals: 0 | |
| - platform: template | |
| name: "A2-t59: Geräte Version" | |
| id: sensor_device_version_2 | |
| state_topic: b2500/2/device/fw_version | |
| accuracy_decimals: 2 | |
| - platform: ble_client | |
| ble_client_id: bc2500_1 | |
| internal: True | |
| type: characteristic | |
| name: "infoX2a" | |
| id: infoX2a | |
| service_uuid: 'ff00' | |
| characteristic_uuid: 'ff02' | |
| notify: True | |
| lambda: |- | |
| std::vector<char> tData; | |
| for (auto b : x) { tData.push_back(b); } | |
| id(ble_notify_parse).execute(1,tData); | |
| return (float)x[0]; | |
| - platform: ble_client | |
| ble_client_id: bc2500_2 | |
| internal: True | |
| type: characteristic | |
| name: "infoX2b" | |
| id: infoX2b | |
| service_uuid: 'ff00' | |
| characteristic_uuid: 'ff02' | |
| notify: True | |
| lambda: |- | |
| std::vector<char> tData; | |
| for (auto b : x) { tData.push_back(b); } | |
| id(ble_notify_parse).execute(2,tData); | |
| return (float)x[0]; | |
| ### power zero - mqtt grid power sensor ( any who publish the grid power to mqtt - defined in secrets,yaml ) | |
| - platform: mqtt_subscribe | |
| name: "MQTT: Grid Power" | |
| id: mqtt_grid_power | |
| topic: !secret mqtt_grid_power | |
| on_value: | |
| then: | |
| - script.execute: power_zero | |
| ###test | |
| - platform: ble_client | |
| ble_client_id: bc2500_1 | |
| internal: True | |
| type: characteristic | |
| name: "infoX6a" | |
| id: infoX6a | |
| service_uuid: 'ff00' | |
| characteristic_uuid: 'ff06' | |
| notify: True | |
| lambda: |- | |
| std::vector<char> tData; | |
| for (auto b : x) { tData.push_back(b); } | |
| id(ble_notify_parse_test).execute(1,tData); | |
| return (float)x[0]; | |
| - platform: ble_client | |
| ble_client_id: bc2500_2 | |
| internal: True | |
| type: characteristic | |
| name: "infoX6b" | |
| id: infoX6b | |
| service_uuid: 'ff00' | |
| characteristic_uuid: 'ff06' | |
| notify: True | |
| lambda: |- | |
| std::vector<char> tData; | |
| for (auto b : x) { tData.push_back(b); } | |
| id(ble_notify_parse_test).execute(1,tData); | |
| return (float)x[0]; | |
| script: | |
| # ble communication | |
| # | |
| # action ( 00f1 ) | |
| # | |
| # head = 0x73 | |
| # length = len(paket) | |
| # cntl = 0x23 | |
| # cmd = 0x02 set Region 1Byte (0x00 = EU / 0x01 = China / 0x02 = Non-EU) | |
| # = 0x03 runtimeInfo 1Byte (0x01) | |
| # = 0x04 DeviceInfo 1Byte (0x01) | |
| # = 0x0B DOD 1Byte (0-100) | |
| # = 0x0C Entladeschwelle 2Byte (0-500) | |
| # = 0x0D PV2-Passtrough 1Byte (0x00 on / 0x01 off) | |
| # = 0x0E PowerOut 1Byte (0x00 1-2 off / 0x01 1 on / 0x02 2 on / 0x03 1-2 on) | |
| # | |
| # = 0x05 Wifi-Config xByte ( ssid<.,.>pwd ) | |
| # = 0x08 Wifi-State 1Byte (0x01) ???? | |
| # | |
| # q&d c&p - more details will be added, maybe ... | |
| # = 0x14 set AWS MQTT xByte ( url<.,.>Port ) .... | |
| # = 0x60 set MQTT Certs xByte ( 0x00 = client.key / 0x01 = client.crt / 0x02 = ca.crt + cert len ) | |
| # = 0x61 trans MQTT Certs xByte ( jeweils 128bytes des certs ) | |
| # = 0x62 end MQTT Certs xByte ( ) | |
| # | |
| # testing / notes | |
| # = 0x01 Debug ?!?! 1Byte (0x00 = off / 0x01 = on) - enables QBLEGATTSNOTIFY notify 1 / 81 ( entspricht ~ runtimeinfo ) | |
| # = 0x06 | |
| # = 0x07 | |
| # = 0x09 | |
| # = 0x0A | |
| # = 0x0E HW-RESET ????? / send before head 0XAA ( deactivate output ??? ) | |
| # = 0x0F new in fw 131 1Byte ( 0x01 ) | |
| # | |
| # = 0x30 found in logs ... unknown parm 0x01 ???? answers since fw 131 | |
| # = 0x14 maybe not for mqtt ... set localtime ??? for auth/certs/challenge requests ????? ( query/set wifi depends ????) | |
| # | |
| # data = xx xx xx xx xx xx .... / depends on cmd | |
| # crc = xor len(paket) - 1 | |
| # | |
| # | |
| # responses ( ff02 ): | |
| # | |
| # head = 0x73 | |
| # length = len(paket) | |
| # cntl = 0x23 | |
| # cmd = cmd | |
| # data = xx xx xx xx xx .... | |
| # | |
| # | |
| # | |
| ################ maybe direct for arm | |
| # send ( ff01 ) | |
| # | |
| # head1 = 0xAA | |
| # head2(?) = 0x55 ( not length ?!?!? ) | |
| # cmd = 1x / 2x / 3x ( flash - 30 "open"/ 31 - write / 32 "close" ) / 5x | |
| # data = xx xx xx xx xx .... | |
| # crc = xor len(paket) -1 | |
| # | |
| ################ maybe direct for bms | |
| # send/receive ( ff06 ) | |
| # | |
| # head = 0xAA | |
| # len = 0x05/0x03 | |
| # data = xx xx xxx ( xx xx ) | |
| # crc = x1 + x2 + ... + xn | |
| # | |
| # | |
| # | |
| # -> aa 05 01 00 01 01 00 08 | |
| # <- aa 01 00 01 | |
| # | |
| # -> aa 05 01 00 01 00 00 07 | |
| # <- aa 01 00 01 | |
| # | |
| - id: ble_command_simple | |
| parameters: | |
| ble_device_nr: int | |
| ble_cmd: int | |
| ble_cmd_parm: int | |
| then: | |
| - logger.log: | |
| format: "ble command parse: %i [%i] %i" | |
| args: [ 'ble_device_nr','ble_cmd','ble_cmd_parm' ] | |
| - if: | |
| condition: | |
| lambda: 'return (ble_device_nr == 1);' | |
| then: | |
| - ble_client.ble_write: | |
| id: bc2500_1 | |
| #service_uuid: 'ff00' | |
| #characteristic_uuid: 'ff01' | |
| service_uuid: 0000ff00-0000-1000-8000-00805f9b34fb | |
| characteristic_uuid: 0000ff01-0000-1000-8000-00805f9b34fb | |
| value: !lambda |- | |
| std::vector<unsigned char> rdat1{ 0x73,0x06,0x23,(unsigned char)ble_cmd}; | |
| if (ble_cmd == 0x0C) { | |
| rdat1.push_back((uint8_t)((ble_cmd_parm >> 0) & 0xFF)); | |
| rdat1.push_back((uint8_t)((ble_cmd_parm >> 8) & 0xFF)); | |
| } else { | |
| rdat1.push_back((unsigned char)ble_cmd_parm); | |
| } | |
| int rlen = rdat1.size(); | |
| rdat1.at(1) = rlen+1; | |
| int rxor = 0; | |
| for (int i=0;i<rlen;i++) { | |
| rxor = rxor ^ rdat1[i]; | |
| } | |
| rdat1.push_back(rxor); | |
| if (id(internal_console_dbg)) { | |
| for (auto b : rdat1) { | |
| ESP_LOGD("COMMAND", "%x - %i - %c", b,b,b); | |
| } | |
| } | |
| return rdat1; | |
| - if: | |
| condition: | |
| lambda: 'return (ble_device_nr == 2);' | |
| then: | |
| - ble_client.ble_write: | |
| id: bc2500_2 | |
| service_uuid: 'ff00' | |
| characteristic_uuid: 'ff01' | |
| value: !lambda |- | |
| std::vector<unsigned char> rdat2{ 0x73,0x06,0x23,(unsigned char)ble_cmd}; | |
| if (ble_cmd == 0x0C) { | |
| rdat2.push_back((uint8_t)((ble_cmd_parm >> 0) & 0xFF)); | |
| rdat2.push_back((uint8_t)((ble_cmd_parm >> 8) & 0xFF)); | |
| } else { | |
| rdat2.push_back((unsigned char)ble_cmd_parm); | |
| } | |
| int rlen = rdat2.size(); | |
| rdat2.at(1) = rlen+1; | |
| int rxor = 0; | |
| for (int i=0;i<rlen;i++) { | |
| rxor = rxor ^ rdat2[i]; | |
| } | |
| rdat2.push_back(rxor); | |
| if (id(internal_console_dbg)) { | |
| for (auto b : rdat2) { | |
| ESP_LOGD("COMMAND", "%x - %i - %c", b,b,b); | |
| } | |
| } | |
| return rdat2; | |
| - id: ble_command_string | |
| parameters: | |
| ble_device_nr: int | |
| ble_cmd: int | |
| ble_cmd_parm: string | |
| then: | |
| - logger.log: | |
| format: "ble command parse: %i [%i]" | |
| args: [ 'ble_device_nr','ble_cmd'] | |
| - if: | |
| condition: | |
| lambda: 'return (ble_device_nr == 1);' | |
| then: | |
| - ble_client.ble_write: | |
| id: bc2500_1 | |
| #service_uuid: 'ff00' | |
| #characteristic_uuid: 'ff01' | |
| service_uuid: 0000ff00-0000-1000-8000-00805f9b34fb | |
| characteristic_uuid: 0000ff01-0000-1000-8000-00805f9b34fb | |
| value: !lambda |- | |
| std::vector<unsigned char> rdat1{ 0x73,0x06,0x23,(unsigned char)ble_cmd}; | |
| for (auto b : ble_cmd_parm) { | |
| rdat1.push_back((unsigned char)b); | |
| } | |
| int rlen = rdat1.size(); | |
| rdat1.at(1) = rlen+1; | |
| int rxor = 0; | |
| for (int i=0;i<rlen;i++) { | |
| rxor = rxor ^ rdat1[i]; | |
| } | |
| rdat1.push_back(rxor); | |
| if (id(internal_console_dbg)) { | |
| for (auto b : rdat1) { | |
| ESP_LOGD("COMMAND", "%x - %i - %c", b,b,b); | |
| } | |
| } | |
| return rdat1; | |
| - if: | |
| condition: | |
| lambda: 'return (ble_device_nr == 2);' | |
| then: | |
| - ble_client.ble_write: | |
| id: bc2500_2 | |
| service_uuid: 'ff00' | |
| characteristic_uuid: 'ff01' | |
| #service_uuid: 0000ff00-0000-1000-8000-00805f9b34fb | |
| #characteristic_uuid: 0000ff01-0000-1000-8000-00805f9b34fb | |
| value: !lambda |- | |
| std::vector<unsigned char> rdat2{ 0x73,0x06,0x23,(unsigned char)ble_cmd}; | |
| for (auto b : ble_cmd_parm) { | |
| rdat2.push_back((unsigned char)b); | |
| } | |
| int rlen = rdat2.size(); | |
| rdat2.at(1) = rlen+1; | |
| int rxor = 0; | |
| for (int i=0;i<rlen;i++) { | |
| rxor = rxor ^ rdat2[i]; | |
| } | |
| rdat2.push_back(rxor); | |
| if (id(internal_console_dbg)) { | |
| for (auto b : rdat2) { | |
| ESP_LOGD("COMMAND", "%x - %i - %c", b,b,b); | |
| } | |
| } | |
| return rdat2; | |
| - id: ble_set_time | |
| parameters: | |
| ble_device_nr: int | |
| then: | |
| - if: | |
| condition: | |
| lambda: 'return (ble_device_nr == 1);' | |
| then: | |
| - ble_client.ble_write: | |
| id: bc2500_1 | |
| #service_uuid: 'ff00' | |
| #characteristic_uuid: 'ff01' | |
| service_uuid: 0000ff00-0000-1000-8000-00805f9b34fb | |
| characteristic_uuid: 0000ff01-0000-1000-8000-00805f9b34fb | |
| value: !lambda |- | |
| std::vector<unsigned char> rdat1{ 0x73,0x0d,0x23,0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00 }; | |
| auto time = id(sntp_time).now(); | |
| rdat1.at(4) = time.year - 1900; | |
| rdat1.at(5) = time.month; | |
| rdat1.at(6) = time.day_of_month; | |
| rdat1.at(7) = time.hour; | |
| rdat1.at(8) = time.minute; | |
| rdat1.at(9) = time.second + 1; | |
| int rlen = rdat1.size(); | |
| rdat1.at(1) = rlen+1; | |
| int rxor = 0; | |
| for (int i=0;i<rlen;i++) { | |
| rxor = rxor ^ rdat1[i]; | |
| } | |
| rdat1.push_back(rxor); | |
| if (id(internal_console_dbg)) { | |
| for (auto b : rdat1) { | |
| ESP_LOGD("COMMAND", "%x - %i - %c", b,b,b); | |
| } | |
| } | |
| return rdat1; | |
| - globals.set: | |
| id: ble_1_initialized | |
| value: '1' | |
| - if: | |
| condition: | |
| lambda: 'return (ble_device_nr == 2);' | |
| then: | |
| - ble_client.ble_write: | |
| id: bc2500_2 | |
| service_uuid: 'ff00' | |
| characteristic_uuid: 'ff01' | |
| #service_uuid: 0000ff00-0000-1000-8000-00805f9b34fb | |
| #characteristic_uuid: 0000ff01-0000-1000-8000-00805f9b34fb | |
| value: !lambda |- | |
| std::vector<unsigned char> rdat2{ 0x73,0x0d,0x23,0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00 }; | |
| auto time = id(sntp_time).now(); | |
| rdat2.at(4) = time.year - 1900; | |
| rdat2.at(5) = time.month; | |
| rdat2.at(6) = time.day_of_month; | |
| rdat2.at(7) = time.hour; | |
| rdat2.at(8) = time.minute; | |
| rdat2.at(9) = time.second + 1; | |
| int rlen = rdat2.size(); | |
| rdat2.at(1) = rlen+1; | |
| int rxor = 0; | |
| for (int i=0;i<rlen;i++) { | |
| rxor = rxor ^ rdat2[i]; | |
| } | |
| rdat2.push_back(rxor); | |
| if (id(internal_console_dbg)) { | |
| for (auto b : rdat2) { | |
| ESP_LOGD("COMMAND", "%x - %i - %c", b,b,b); | |
| } | |
| } | |
| return rdat2; | |
| - globals.set: | |
| id: ble_2_initialized | |
| value: '1' | |
| - id: ble_command_raw_06 | |
| parameters: | |
| ble_device_nr: int | |
| ble_cmd_parm: char[] | |
| then: | |
| - logger.log: | |
| format: "ble command parse (raw): %i" | |
| args: [ 'ble_device_nr'] | |
| - if: | |
| condition: | |
| lambda: 'return (ble_device_nr == 1);' | |
| then: | |
| - ble_client.ble_write: | |
| id: bc2500_1 | |
| #service_uuid: 'ff00' | |
| #characteristic_uuid: 'ff06' | |
| service_uuid: 0000ff00-0000-1000-8000-00805f9b34fb | |
| characteristic_uuid: 0000ff06-0000-1000-8000-00805f9b34fb | |
| value: !lambda |- | |
| std::vector<unsigned char> rdat1; | |
| for (auto b : ble_cmd_parm) { | |
| rdat1.push_back((unsigned char)b); | |
| } | |
| /* | |
| int rlen = rdat1.size(); | |
| rdat1.at(1) = rlen+1; | |
| int rxor = 0; | |
| for (int i=0;i<rlen;i++) { | |
| rxor = rxor ^ rdat1[i]; | |
| } | |
| rdat1.push_back(rxor); | |
| */ | |
| //if (id(internal_console_dbg)) { | |
| for (auto b : rdat1) { | |
| ESP_LOGD("COMMAND raw", "%x - %i - %c", b,b,b); | |
| } | |
| //} | |
| return rdat1; | |
| - if: | |
| condition: | |
| lambda: 'return (ble_device_nr == 2);' | |
| then: | |
| - ble_client.ble_write: | |
| id: bc2500_2 | |
| #service_uuid: 'ff00' | |
| #characteristic_uuid: 'ff06' | |
| service_uuid: 0000ff00-0000-1000-8000-00805f9b34fb | |
| characteristic_uuid: 0000ff06-0000-1000-8000-00805f9b34fb | |
| value: !lambda |- | |
| std::vector<unsigned char> rdat2; | |
| for (auto b : ble_cmd_parm) { | |
| rdat2.push_back((unsigned char)b); | |
| } | |
| /* | |
| int rlen = rdat2.size(); | |
| rdat2.at(1) = rlen+1; | |
| int rxor = 0; | |
| for (int i=0;i<rlen;i++) { | |
| rxor = rxor ^ rdat2[i]; | |
| } | |
| rdat2.push_back(rxor); | |
| */ | |
| //if (id(internal_console_dbg)) { | |
| for (auto b : rdat2) { | |
| ESP_LOGD("COMMAND raw", "%x - %i - %c", b,b,b); | |
| } | |
| //} | |
| return rdat2; | |
| - id: ble_process | |
| then: | |
| - if: | |
| condition: | |
| - lambda: 'return (id(ble_1_connected) && id(ble_1_initialized));' | |
| then: | |
| - script.execute: | |
| id: ble_runtime_query | |
| ble_device_nr: 1 | |
| - script.wait: ble_runtime_query | |
| ### query cmd30 if firmware > 1.30 | |
| - if: | |
| condition: | |
| - lambda: 'return (id(sensor_device_version_1).state * 100 > 130);' | |
| then: | |
| - script.execute: | |
| id: ble_runtime_query30 | |
| ble_device_nr: 1 | |
| - script.wait: ble_runtime_query30 | |
| - script.execute: | |
| id: ble_runtime_query0F | |
| ble_device_nr: 1 | |
| - script.wait: ble_runtime_query0F | |
| ### query deviceinfo if empty | |
| - if: | |
| condition: | |
| - lambda: 'return (id(txt_A03_1).state == "");' | |
| then: | |
| - script.execute: | |
| id: ble_command_simple | |
| ble_device_nr: 1 | |
| ble_cmd: 0x04 | |
| ble_cmd_parm: 0x01 | |
| - script.wait: ble_command_simple | |
| - if: | |
| condition: | |
| - lambda: 'return (id(ble_2_connected) && id(ble_2_initialized));' | |
| then: | |
| - script.execute: | |
| id: ble_runtime_query | |
| ble_device_nr: 2 | |
| - script.wait: ble_runtime_query | |
| ### query cmd30 if firmware > 1.30 | |
| - if: | |
| condition: | |
| - lambda: 'return (id(sensor_device_version_2).state * 100 > 130);' | |
| then: | |
| - script.execute: | |
| id: ble_runtime_query30 | |
| ble_device_nr: 2 | |
| - script.wait: ble_runtime_query30 | |
| - script.execute: | |
| id: ble_runtime_query0F | |
| ble_device_nr: 2 | |
| - script.wait: ble_runtime_query0F | |
| ### query deviceinfo if empty | |
| - if: | |
| condition: | |
| - lambda: 'return (id(txt_A03_2).state == "");' | |
| then: | |
| - script.execute: | |
| id: ble_command_simple | |
| ble_device_nr: 2 | |
| ble_cmd: 0x04 | |
| ble_cmd_parm: 0x01 | |
| - script.wait: ble_command_simple | |
| - id: ble_runtime_query | |
| parameters: | |
| ble_device_nr: int | |
| then: | |
| - logger.log: | |
| format: "runtime query: %i" | |
| args: [ 'ble_device_nr' ] | |
| - script.execute: | |
| id: ble_command_simple | |
| ble_device_nr: !lambda return ble_device_nr; | |
| ble_cmd: 0x03 | |
| ble_cmd_parm: 0x01 | |
| - script.wait: ble_command_simple | |
| - id: ble_runtime_query30 | |
| parameters: | |
| ble_device_nr: int | |
| then: | |
| - logger.log: | |
| format: "runtime query 30: %i" | |
| args: [ 'ble_device_nr' ] | |
| - script.execute: | |
| id: ble_command_simple | |
| ble_device_nr: !lambda return ble_device_nr; | |
| ble_cmd: 0x30 | |
| ble_cmd_parm: 0x01 | |
| - script.wait: ble_command_simple | |
| - id: ble_runtime_query0F | |
| parameters: | |
| ble_device_nr: int | |
| then: | |
| - logger.log: | |
| format: "runtime query 0F: %i" | |
| args: [ 'ble_device_nr' ] | |
| - script.execute: | |
| id: ble_command_simple | |
| ble_device_nr: !lambda return ble_device_nr; | |
| ble_cmd: 0x0F | |
| ble_cmd_parm: 0x01 | |
| - script.wait: ble_command_simple | |
| - id: ble_powerout | |
| parameters: | |
| ble_device_nr: int | |
| then: | |
| - lambda: |- | |
| int ble_cmd_t = 0x00; | |
| if ( ble_device_nr == 1 ) { | |
| if ( ! id(switch_powerout_1_1).state && ! id(switch_powerout_1_2).state ) { ble_cmd_t = 0x00; } | |
| if ( id(switch_powerout_1_1).state && ! id(switch_powerout_1_2).state ) { ble_cmd_t = 0x01; } | |
| if ( ! id(switch_powerout_1_1).state && id(switch_powerout_1_2).state ) { ble_cmd_t = 0x02; } | |
| if ( id(switch_powerout_1_1).state && id(switch_powerout_1_2).state ) { ble_cmd_t = 0x03; } | |
| } | |
| if ( ble_device_nr == 2 ) { | |
| if ( ! id(switch_powerout_2_1).state && ! id(switch_powerout_2_2).state ) { ble_cmd_t = 0x00; } | |
| if ( id(switch_powerout_2_1).state && ! id(switch_powerout_2_2).state ) { ble_cmd_t = 0x01; } | |
| if ( ! id(switch_powerout_2_1).state && id(switch_powerout_2_2).state ) { ble_cmd_t = 0x02; } | |
| if ( id(switch_powerout_2_1).state && id(switch_powerout_2_2).state ) { ble_cmd_t = 0x03; } | |
| } | |
| id(ble_command_simple).execute(ble_device_nr,0x0E,ble_cmd_t); | |
| if (ble_cmd_t == 0x00) { ESP_LOGD("set_power_out", "Device %i - %s", ble_device_nr,"1 OFF / 2 OFF"); } | |
| if (ble_cmd_t == 0x01) { ESP_LOGD("set_power_out", "Device %i - %s", ble_device_nr,"1 ON / 2 OFF"); } | |
| if (ble_cmd_t == 0x02) { ESP_LOGD("set_power_out", "Device %i - %s", ble_device_nr,"1 OFF / 2 ON"); } | |
| if (ble_cmd_t == 0x03) { ESP_LOGD("set_power_out", "Device %i - %s", ble_device_nr,"1 ON / 2 ON"); } | |
| - id: ble_passthrough | |
| parameters: | |
| ble_device_nr: int | |
| switch_cmd: bool | |
| then: | |
| - logger.log: | |
| format: "PV2 Passthrough %i : %i" | |
| args: [ble_device_nr,switch_cmd] | |
| - script.execute: | |
| id: ble_command_simple | |
| ble_device_nr: !lambda return ble_device_nr; | |
| ble_cmd: 0x0D | |
| ble_cmd_parm: !lambda return switch_cmd; | |
| - id: ble_set_dod | |
| parameters: | |
| ble_device_nr: int | |
| dod: int | |
| then: | |
| - logger.log: | |
| format: "set DOD: %i" | |
| args: [ 'dod' ] | |
| - if: | |
| condition: | |
| lambda: 'return ( dod <= 100 && dod >= 10);' | |
| then: | |
| - script.execute: | |
| id: ble_command_simple | |
| ble_device_nr: !lambda return ble_device_nr; | |
| ble_cmd: 0x0B | |
| ble_cmd_parm: !lambda return dod; | |
| - id: ble_set_discharge_treshold | |
| parameters: | |
| ble_device_nr: int | |
| discharge: int | |
| then: | |
| - logger.log: | |
| format: "set discharge level: %i" | |
| args: [ 'discharge' ] | |
| - if: | |
| condition: | |
| lambda: 'return ( discharge <= 500 && discharge >= 1);' | |
| then: | |
| - script.execute: | |
| id: ble_command_simple | |
| ble_device_nr: !lambda return ble_device_nr; | |
| ble_cmd: 0x0C | |
| ble_cmd_parm: !lambda return discharge; | |
| - id: ble_notify_parse_test | |
| parameters: | |
| ble_device_nr: int | |
| x: char[] | |
| then: | |
| - logger.log: | |
| format: "runtime parse: %i" | |
| args: [ 'ble_device_nr' ] | |
| - lambda: |- | |
| //if (id(internal_console_dbg)) { | |
| ESP_LOGD("parse test", "x[3] = %i", x[3]); | |
| for (auto b : x) { | |
| ESP_LOGD("data test", "%.2x \t %i \t %c", b,b,b); | |
| } | |
| //} | |
| - id: ble_notify_parse | |
| parameters: | |
| ble_device_nr: int | |
| x: char[] | |
| then: | |
| - logger.log: | |
| format: "runtime parse: %i" | |
| args: [ 'ble_device_nr' ] | |
| - lambda: |- | |
| ESP_LOGD("notify_parse", "Device: %i", ble_device_nr); | |
| if (id(internal_console_dbg)) { | |
| ESP_LOGD("parse", "x[3] = %i", x[3]); | |
| for (auto b : x) { | |
| ESP_LOGD("data", "%.2x \t %i \t %c", b,b,b); | |
| } | |
| } | |
| if (id(switch_debug_hexdump).state == true) { | |
| ESP_LOG_BUFFER_HEXDUMP("hexdump", &x[0], x.size(), ESP_LOG_ERROR); | |
| } | |
| if ((std::count (x.begin(), x.end(), '_') == 16) || (std::count (x.begin(), x.begin() + 10, '_') == 3)) | |
| { | |
| ESP_LOGD("main", "Data: cmd 0x0F"); | |
| int pos = 0; | |
| int soc = 0; | |
| int t1 = 0; | |
| int t2 = 0; | |
| float cv = 0.0; | |
| float cmin = std::numeric_limits<float>::max(); | |
| float cmax = std::numeric_limits<float>::min(); | |
| float ct = 0.0; | |
| int found = -1; | |
| char delimiter = '_'; | |
| std::string xstr; | |
| std::vector<float> cellV; | |
| xstr.assign(x.begin(), x.end()); // copy values from vector into string xstr, deep copy | |
| xstr = xstr + delimiter; // append delimiter to xstr | |
| found = xstr.find(delimiter); // search for position of the first delimiter | |
| while (found != -1) // loop until no more delimiter found | |
| { | |
| if(pos == 0) soc = atoi( xstr.substr(0, found).c_str()); // pos 0 don't care | |
| if(pos == 1) t1 = atoi( xstr.substr(0, found).c_str()); // pos 1 get int value of temperature sensor 1 | |
| if(pos == 2) t2 = atoi( xstr.substr(0, found).c_str()); // pos 2 get int value of temperature sensor 2 | |
| if((pos >= 3) && (pos <= 16)) // pos 3-16 parse pos for the 14 cell voltages | |
| { | |
| ct = atof( xstr.substr(0, found).c_str()); // get float value of pos x | |
| cellV.push_back(ct); | |
| //ESP_LOGD("cell voltage", ct.c_str()); | |
| cv += ct; // add actual value to var cv | |
| if(ct > cmax) cmax = ct; // check for higher value as stored in cmax | |
| if(ct < cmin) cmin = ct; // check for lower value as stored in cmin | |
| } | |
| xstr.erase(xstr.begin(), xstr.begin() + found + 1); // remove parsed string part | |
| found = xstr.find(delimiter); // find next delimiter | |
| pos++; // increment pos | |
| } | |
| /* calculate SoC from cell voltages | |
| cell empty = 3.0 Volt = 0% SoC | |
| cell full = 3.5 Volt = 100% SoC | |
| */ | |
| // float soccalc = (cv/14000 - 3.0) * 200; | |
| float lowlimit = 3.0; // low voltage limit | |
| float highlimit = 3.5; // high voltage limit | |
| float soccalc = 100*((cv/14000) | |
| - highlimit)/(highlimit - lowlimit) + 100; // equation of line with two points (0,lowlimit) (100,highlimit) | |
| ESP_LOGD("cellVoltage","soc: %i, temp1: %i, temp2: %i",soc,t1,t2); | |
| ESP_LOGD("cellVoltage","cell01: %.f, cell 02: %.f, cell 03: %.f, cell 04: %.f", cellV[0], cellV[1], cellV[2], cellV[3]); | |
| ESP_LOGD("cellVoltage","cell05: %.f, cell 06: %.f, cell 07: %.f, cell 08: %.f", cellV[4], cellV[5], cellV[6], cellV[7]); | |
| ESP_LOGD("cellVoltage","cell09: %.f, cell 10: %.f, cell 11: %.f, cell 12: %.f", cellV[8], cellV[9], cellV[10], cellV[11]); | |
| ESP_LOGD("cellVoltage","cell13: %.f, cell 14: %.f", cellV[12], cellV[13]); | |
| char mtopic[48]; | |
| for (int i=0; i<14; i++) { | |
| snprintf(mtopic, 48,"b2500/%i/battery/cells/%02d/voltage",ble_device_nr,i+1); | |
| //ESP_LOGD("cellVoltageX","%s : %f", mtopic, cellV[i]); | |
| id(mqtt_client).publish(mtopic,to_string(cellV[i]/1000)); | |
| } | |
| snprintf(mtopic, 48,"b2500/%i/battery/cells/sum/voltage",ble_device_nr); | |
| id(mqtt_client).publish(mtopic,to_string(cv/1000)); | |
| snprintf(mtopic, 48,"b2500/%i/battery/cells/sum/cmin",ble_device_nr); | |
| id(mqtt_client).publish(mtopic,to_string(cmin/1000)); | |
| snprintf(mtopic, 48,"b2500/%i/battery/cells/sum/cmax",ble_device_nr); | |
| id(mqtt_client).publish(mtopic,to_string(cmax/1000)); | |
| snprintf(mtopic, 48,"b2500/%i/battery/cells/sum/cavg",ble_device_nr); | |
| id(mqtt_client).publish(mtopic,to_string(cv/14000)); | |
| snprintf(mtopic, 48,"b2500/%i/battery/cells/sum/cdiff",ble_device_nr); | |
| id(mqtt_client).publish(mtopic,to_string((cmax-cmin)/1000)); | |
| snprintf(mtopic, 48,"b2500/%i/battery/cells/sum/soccalc",ble_device_nr); | |
| id(mqtt_client).publish(mtopic,to_string(soccalc)); | |
| snprintf(mtopic, 48,"b2500/%i/battery/temp1",ble_device_nr); | |
| id(mqtt_client).publish(mtopic,to_string(t1)); | |
| snprintf(mtopic, 48,"b2500/%i/battery/temp2",ble_device_nr); | |
| id(mqtt_client).publish(mtopic,to_string(t2)); | |
| /* | |
| id(bcsoc).publish_state(soc); // SOC from device (%) | |
| id(bcsoccalc).publish_state(soccalc); // SOC calculated from cell voltages (%) | |
| id(bctemp1).publish_state(t1); // Temperature 1 (°C) | |
| id(bctemp2).publish_state(t2); // Temperature 2 (°C) | |
| id(bccvsum).publish_state(cv/1000); // sum of cellvoltages = battery Voltage(V) | |
| id(bccvmin).publish_state(cmin/1000); // lowest cellvoltage (V) | |
| id(bccvmax).publish_state(cmax/1000); // highest cellvoltage (V) | |
| id(bccvdiff).publish_state((cmax-cmin)/1000); | |
| id(bccvavg).publish_state(cv/14000); // avarage cellvoltage (V) | |
| */ | |
| } | |
| else if (x[3] == 0x03) { | |
| ESP_LOGD("main", "Data: runtimeInfo "); | |
| //sensor | |
| // pv_level 1 und 2 | |
| /* | |
| [6][7] PV-Eingangsleistung 1 (2Byte) | |
| [8][9] PV-Eingangsleistung 2 (2Byte) | |
| x[Y] | x[Z] << 8; | |
| */ | |
| int pvPower1 = x[6] | x[7] << 8; | |
| int pvPower2 = x[8] | x[9] << 8; | |
| if (ble_device_nr==1) { id(sensor_pv_power_in_1_1).publish_state(pvPower1); id(sensor_pv_power_in_1_2).publish_state(pvPower2); } | |
| if (ble_device_nr==2) { id(sensor_pv_power_in_2_1).publish_state(pvPower1); id(sensor_pv_power_in_2_2).publish_state(pvPower2); } | |
| // Batterie Stand in % | |
| /* | |
| [10][11] Verbleibende Batteriekapazität in Prozent (2Byte) | |
| x[Y] | x[Z] << 8; | |
| */ | |
| int batRemain = x[10] | x[11] << 8 ; | |
| if (ble_device_nr==1) { id(sensor_bat_remain_1).publish_state(batRemain / 10); } | |
| if (ble_device_nr==2) { id(sensor_bat_remain_2).publish_state(batRemain / 10); } | |
| // Entladen bei weniger als ??? Watt PV Eingang | |
| /* | |
| [19][20] Entladeschwelle(2Byte) | |
| x[Y] | x[Z] << 8; | |
| */ | |
| int disCharge = x[19] | x[20] << 8; | |
| if (ble_device_nr==1) { id(sensor_discharge_treshold_1).publish_state(disCharge); } | |
| if (ble_device_nr==2) { id(sensor_discharge_treshold_2).publish_state(disCharge); } | |
| // Füllstand des Akkus in Wh | |
| /* | |
| [22][23] Gesamtkapazität der Batterie (1Byte) | |
| x[Y] | x[Z] << 8; | |
| */ | |
| int batCapacity = x[22] | x[23] << 8; | |
| if (ble_device_nr==1) { id(sensor_bat_capacity_1).publish_state(batCapacity); } | |
| if (ble_device_nr==2) { id(sensor_bat_capacity_2).publish_state(batCapacity); } | |
| // Ausgangsleistung in Watt | |
| /* | |
| [24][25] Ausgangsleistung 1(1Byte) | |
| [26][27] Ausgangsleistung 2(1Byte) | |
| x[Y] | x[Z] << 8; | |
| */ | |
| int powerOut1 = x[24] | x[25] << 8; | |
| int powerOut2 = x[26] | x[27] << 8; | |
| if (ble_device_nr==1) { id(sensor_power_out_1_1).publish_state(powerOut1); id(sensor_power_out_1_2).publish_state(powerOut2); } | |
| if (ble_device_nr==2) { id(sensor_power_out_2_1).publish_state(powerOut1); id(sensor_power_out_2_2).publish_state(powerOut2); } | |
| // Geräte Version ( Firmware ? ) | |
| /* | |
| [12] B2500 Geräteversion (1Byte) | |
| 0-255 ( ~ anzeige als /100 ) | |
| */ | |
| float dev_version = x[12]; | |
| if (ble_device_nr==1) { id(sensor_device_version_1).publish_state(dev_version / 100); } | |
| if (ble_device_nr==2) { id(sensor_device_version_2).publish_state(dev_version / 100); } | |
| // | |
| /* | |
| [18] Dod (1Byte) | |
| 0-100 Prozentualer Anteil der Entladeleistung an der Nennleistung | |
| */ | |
| int dod_level = x[18]; | |
| if (ble_device_nr==1) { id(sensor_dod_1).publish_state(dod_level); } | |
| if (ble_device_nr==2) { id(sensor_dod_2).publish_state(dod_level); } | |
| // binary sensor / bool | |
| // pv 1 und 2 in | |
| /* | |
| [x4] PV IN 1 Zustand (1Byte) | |
| [x5] PV IN 2 Zustand (1Byte) | |
| 0x00 （off） | |
| 0x01 （Aufladung） | |
| 0x02 （transparent für Wechselrichter） | |
| */ | |
| if (ble_device_nr==1) { | |
| if( x[4] == 0x00 ) { id(bool_pv_active_1_1).publish_state(false);id(bool_pv_transparent_1_1).publish_state(false); } | |
| if( x[4] == 0x01 ) { id(bool_pv_active_1_1).publish_state(true); id(bool_pv_transparent_1_1).publish_state(false); } | |
| if( x[4] == 0x02 ) { id(bool_pv_active_1_1).publish_state(true); id(bool_pv_transparent_1_1).publish_state(true); } | |
| if( x[5] == 0x00 ) { id(bool_pv_active_1_2).publish_state(false);id(bool_pv_transparent_1_2).publish_state(false); } | |
| if( x[5] == 0x01 ) { id(bool_pv_active_1_2).publish_state(true); id(bool_pv_transparent_1_2).publish_state(false); } | |
| if( x[5] == 0x02 ) { id(bool_pv_active_1_2).publish_state(true); id(bool_pv_transparent_1_2).publish_state(true); } | |
| } | |
| if (ble_device_nr==2) { | |
| if( x[4] == 0x00 ) { id(bool_pv_active_2_1).publish_state(false);id(bool_pv_transparent_2_1).publish_state(false); } | |
| if( x[4] == 0x01 ) { id(bool_pv_active_2_1).publish_state(true); id(bool_pv_transparent_2_1).publish_state(false); } | |
| if( x[4] == 0x02 ) { id(bool_pv_active_2_1).publish_state(true); id(bool_pv_transparent_2_1).publish_state(true); } | |
| if( x[5] == 0x00 ) { id(bool_pv_active_2_2).publish_state(false);id(bool_pv_transparent_2_2).publish_state(false); } | |
| if( x[5] == 0x01 ) { id(bool_pv_active_2_2).publish_state(true); id(bool_pv_transparent_2_2).publish_state(false); } | |
| if( x[5] == 0x02 ) { id(bool_pv_active_2_2).publish_state(true); id(bool_pv_transparent_2_2).publish_state(true); } | |
| } | |
| // pv 2 durchleiten | |
| /* | |
| [13] Einstellung des Ladevorgangs (1Byte) | |
| 0x00 （PV1 Aufladung PV2 Durchleitung） | |
| 0x01 （Volles Laden und Entladen） | |
| */ | |
| if (ble_device_nr==1) { | |
| if( x[13] == 0x00 ) { id(switch_pv2_passthrough_1).turn_on(); } | |
| if( x[13] == 0x01 ) { id(switch_pv2_passthrough_1).turn_off(); } | |
| } | |
| if (ble_device_nr==2) { | |
| if( x[13] == 0x00 ) { id(switch_pv2_passthrough_2).turn_on(); } | |
| if( x[13] == 0x01 ) { id(switch_pv2_passthrough_2).turn_off(); } | |
| } | |
| // RESERVED ( wifi / mqtt ) | |
| /* | |
| [15] Reserve(1Byte) | |
| 0x00 wifi funktioniert nicht | |
| 0x01 wifi ok, mqtt nicht verbunden | |
| 0x02 wifi ok, mqtt connect ok | |
| ??? 0x03 wifi ok, mqtt1 connect ok, mqtt2 connect ok | |
| maybe wifi / mqtt | |
| 00 = false / false | |
| 01 = true / false | |
| 02 = false / true | |
| 03 = true / true | |
| ------- | |
| first part means not wifi connected ?!?!? | |
| 00 = ??? / mqtt not connected | |
| 01 = ??? / mqtt not connected | |
| 02 = ??? / mqtt connected | |
| 03 = ??? / mqtt connected | |
| */ | |
| // wifi and mqtt, 03 maybe webserver | |
| if (ble_device_nr==1) { | |
| if( x[15] == 0x00 ) { id(bool_wifi_ok_1).publish_state(false); id(bool_mqtt1_ok_1).publish_state(false); } | |
| if( x[15] == 0x01 ) { id(bool_wifi_ok_1).publish_state(true); id(bool_mqtt1_ok_1).publish_state(false);} | |
| if( x[15] == 0x02 ) { id(bool_wifi_ok_1).publish_state(false); id(bool_mqtt1_ok_1).publish_state(true); } | |
| if( x[15] == 0x03 ) { id(bool_wifi_ok_1).publish_state(true); id(bool_mqtt1_ok_1).publish_state(true); } | |
| } | |
| if (ble_device_nr==2) { | |
| if( x[15] == 0x00 ) { id(bool_wifi_ok_2).publish_state(false); id(bool_mqtt1_ok_2).publish_state(false); } | |
| if( x[15] == 0x01 ) { id(bool_wifi_ok_2).publish_state(true); id(bool_mqtt1_ok_2).publish_state(false); } | |
| if( x[15] == 0x02 ) { id(bool_wifi_ok_2).publish_state(false); id(bool_mqtt1_ok_2).publish_state(true); } | |
| if( x[15] == 0x03 ) { id(bool_wifi_ok_2).publish_state(true); id(bool_mqtt1_ok_2).publish_state(true); } | |
| } | |
| // power 1 und 2 enabled/disabled | |
| /* | |
| [14] Entlade-Modus / Enabled (1Byte) | |
| 0x00 OUT1&OUT2 Sperren | |
| 0x01 nur OUT1 Freigabe | |
| 0x02 nur OUT2 Freigabe | |
| 0x03 OUT1&OUT2 Freigabe | |
| */ | |
| if (ble_device_nr==1) { | |
| if( x[14] == 0x00 ) { id(switch_powerout_1_1).turn_off(); id(switch_powerout_1_2).turn_off();} | |
| if( x[14] == 0x01 ) { id(switch_powerout_1_1).turn_on(); id(switch_powerout_1_2).turn_off();} | |
| if( x[14] == 0x02 ) { id(switch_powerout_1_1).turn_off(); id(switch_powerout_1_2).turn_on(); } | |
| if( x[14] == 0x03 ) { id(switch_powerout_1_1).turn_on(); id(switch_powerout_1_2).turn_on(); } | |
| } | |
| if (ble_device_nr==2) { | |
| if( x[14] == 0x00 ) { id(switch_powerout_2_1).turn_off(); id(switch_powerout_2_2).turn_off();} | |
| if( x[14] == 0x01 ) { id(switch_powerout_2_1).turn_on(); id(switch_powerout_2_2).turn_off();} | |
| if( x[14] == 0x02 ) { id(switch_powerout_2_1).turn_off(); id(switch_powerout_2_2).turn_on(); } | |
| if( x[14] == 0x03 ) { id(switch_powerout_2_1).turn_on(); id(switch_powerout_2_2).turn_on(); } | |
| } | |
| // power 1 und 2 active | |
| /* | |
| [16] Ausgang Port 1 Status (1Byte) | |
| [17] Ausgang Port 2 Status (1Byte) | |
| 0x00（Aus） | |
| 0x01（Entladung） | |
| */ | |
| if (ble_device_nr==1) { | |
| if( x[16] == 0x00 ) { id(bool_power_active_1_1).publish_state(false);} | |
| if( x[16] == 0x01 ) { id(bool_power_active_1_1).publish_state(true); } | |
| if( x[17] == 0x00 ) { id(bool_power_active_1_2).publish_state(false);} | |
| if( x[17] == 0x01 ) { id(bool_power_active_1_2).publish_state(true); } | |
| } | |
| if (ble_device_nr==2) { | |
| if( x[16] == 0x00 ) { id(bool_power_active_2_1).publish_state(false);} | |
| if( x[16] == 0x01 ) { id(bool_power_active_2_1).publish_state(true); } | |
| if( x[17] == 0x00 ) { id(bool_power_active_2_2).publish_state(false);} | |
| if( x[17] == 0x01 ) { id(bool_power_active_2_2).publish_state(true); } | |
| } | |
| // zusatzakku 1 und 2 | |
| /* | |
| [28] Ist Netzgerät 1 angeschlossen (1Byte) | |
| [29] Ist Netzgerät 2 angeschlossen (1Byte) | |
| 0x00（Kein Akkupack angeschlossen） | |
| 0x01（Verbinden Sie das Netzteil） | |
| */ | |
| if (ble_device_nr==1) { | |
| if( x[28] == 0x00 ) { id(bool_extern_connected_1_1).publish_state(false);} | |
| if( x[28] == 0x01 ) { id(bool_extern_connected_1_1).publish_state(true); } | |
| if( x[29] == 0x00 ) { id(bool_extern_connected_1_2).publish_state(false);} | |
| if( x[29] == 0x01 ) { id(bool_extern_connected_1_2).publish_state(true); } | |
| } | |
| if (ble_device_nr==2) { | |
| if( x[28] == 0x00 ) { id(bool_extern_connected_2_1).publish_state(false);} | |
| if( x[28] == 0x01 ) { id(bool_extern_connected_2_1).publish_state(true); } | |
| if( x[29] == 0x00 ) { id(bool_extern_connected_2_2).publish_state(false);} | |
| if( x[29] == 0x01 ) { id(bool_extern_connected_2_2).publish_state(true); } | |
| } | |
| if (ble_device_nr==1) { | |
| auto call_21 = id(txt_scene_1).make_call(); | |
| if( x[21] == 0x00 ) { call_21.set_value("Tag"); } | |
| if( x[21] == 0x01 ) { call_21.set_value("Nacht"); } | |
| if( x[21] == 0x02 ) { call_21.set_value("Morgens/Abends"); } | |
| call_21.perform(); | |
| } | |
| if (ble_device_nr==2) { | |
| auto call_21 = id(txt_scene_2).make_call(); | |
| if( x[21] == 0x00 ) { call_21.set_value("Tag"); } | |
| if( x[21] == 0x01 ) { call_21.set_value("Nacht"); } | |
| if( x[21] == 0x02 ) { call_21.set_value("Morgens/Abends"); } | |
| call_21.perform(); | |
| } | |
| if (ble_device_nr==1) { | |
| auto call_30 = id(txt_region_1).make_call(); | |
| if( x[30] == 0x00 ) { call_30.set_value("EU"); } | |
| if( x[30] == 0x01 ) { call_30.set_value("China"); } | |
| if( x[30] == 0x02 ) { call_30.set_value("non-EU"); } | |
| call_30.perform(); | |
| } | |
| if (ble_device_nr==2) { | |
| auto call_30 = id(txt_region_2).make_call(); | |
| if( x[30] == 0x00 ) { call_30.set_value("EU"); } | |
| if( x[30] == 0x01 ) { call_30.set_value("China"); } | |
| if( x[30] == 0x02 ) { call_30.set_value("non-EU"); } | |
| call_30.perform(); | |
| } | |
| } | |
| else if (x[3] == 0x04) { | |
| ESP_LOGD("main", "Data: deviceInfo "); | |
| //for (auto b : x) { | |
| // ESP_LOGD("data", "%i", b); | |
| //} | |
| // 's<#?type=<5>,id=<24>,mac=<12>t' | |
| // ESP_LOGD("data", "%s", vType); | |
| int data_len = x.size(); | |
| unsigned char vType[8]; | |
| for (int i=9;i<14;i++) { | |
| vType[i-9] = x[i]; | |
| } | |
| vType[5] = 0x00; | |
| unsigned char vID[32]; | |
| for (int i=18;i<42;i++) { | |
| vID[i-18] = x[i]; | |
| } | |
| vID[24]=0x00; | |
| unsigned char vMac[16]; | |
| for (int i=47;i<59;i++) { | |
| vMac[i-47] = x[i]; | |
| } | |
| vMac[12] = 0x00; | |
| ESP_LOGD("deviceInfo", "%i: %s [%s] %s", data_len,vType,vMac,vID); | |
| std::string sType(reinterpret_cast<char*>(vType)); | |
| std::string sID(reinterpret_cast<char*>(vID)); | |
| std::string sMac(reinterpret_cast<char*>(vMac)); | |
| if (ble_device_nr==1) { id(txt_A01_1).publish_state(sType); id(txt_A02_1).publish_state(sID); id(txt_A03_1).publish_state(sMac); } | |
| if (ble_device_nr==2) { id(txt_A01_2).publish_state(sType); id(txt_A02_2).publish_state(sID); id(txt_A03_2).publish_state(sMac); } | |
| } | |
| // get wifi info - "admin mode" only | |
| else if (x[3] == 0x08) { | |
| ESP_LOGD("main", "Data: wifiInfo "); | |
| int data_len = x.size(); | |
| unsigned char vSSID[32]; | |
| for (int i=4;i<data_len-1;i++) { | |
| vSSID[i-4] = x[i]; | |
| } | |
| vSSID[data_len-5] = 0x00; | |
| ESP_LOGD("deviceInfo", "%i: %s", data_len,vSSID); | |
| std::string sSSID(reinterpret_cast<char*>(vSSID)); | |
| if (ble_device_nr==1) { id(txt_A11_1).publish_state(sSSID); } | |
| if (ble_device_nr==2) { id(txt_A11_2).publish_state(sSSID); } | |
| for (auto b : x) { | |
| ESP_LOGD("data", "%x \t %i \t %x", b,b,b); | |
| } | |
| } | |
| else if (x[3] == 0x30) { | |
| ESP_LOGD("main", "Data: cmd 0x30 "); | |
| int data_len = x.size(); | |
| int data_pos = 0; | |
| int rxor = 0; | |
| for (int i=0;i<data_len;i++) { | |
| rxor = rxor ^ x[i]; | |
| } | |
| /* | |
| //if( rxor != id(cmd30_xor_last_1) ) { | |
| ESP_LOGD("data 30 - raw" , "Device %i",ble_device_nr); | |
| ESP_LOGD("data 30 - raw" , "0x%.2x 0x%.2x 0x%.2x 0x%.2x", x[0], x[1], x[2], x[3]); | |
| for(int i=4;i<data_len-1;i++) { | |
| ESP_LOGD("data 30 - raw" , "0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x", x[i], x[i+1], x[i+2], x[i+3], x[i+4],x[i+5],x[i+6],x[i+7],x[i+8]); | |
| i += 8; | |
| } | |
| //ESP_LOGD("data 30 - raw" , " "); | |
| id(cmd30_xor_last_1) = rxor; | |
| //} | |
| */ | |
| } | |
| /* | |
| else if (x[3] == 0x30) { | |
| ESP_LOGD("main", "Data: cmd 0x30"); | |
| int data_len = x.size(); | |
| for(int i=0;i<data_len;i++) { | |
| int d1 = x[i]; | |
| ESP_LOGD("data 30" , "%x \t %i \t %c" , d1, d1, char(d1)); | |
| } | |
| } | |
| */ | |
| // debug ??? | |
| else if (x[3] == 0x01) { | |
| ESP_LOGD("main", "Data: cmd 0x01"); | |
| int data_len = x.size(); | |
| for(int i=0;i<data_len;i++) { | |
| int d1 = x[i]; | |
| ESP_LOGD("data 01" , "%x \t %i \t %c" , d1, d1, char(d1)); | |
| } | |
| } | |
| else if (x[3] == 0x81) { | |
| ESP_LOGD("main", "Data: cmd 0x81"); | |
| int data_len = x.size(); | |
| for(int i=0;i<data_len;i++) { | |
| int d1 = x[i]; | |
| ESP_LOGD("data 81" , "%x \t %i \t %c" , d1, d1, char(d1)); | |
| } | |
| } | |
| else { | |
| /*int data_len = x.size(); | |
| for(int i=0;i<data_len;i++) { | |
| int d1 = x[i]; | |
| ESP_LOGD("unknown" , "%x \t %i \t %c" , d1, d1, char(d1)); | |
| } | |
| */ | |
| ESP_LOG_BUFFER_HEXDUMP("hexdump", &x[0], x.size(), ESP_LOG_ERROR); | |
| } | |
| - id: power_zero | |
| then: | |
| ### Nulleinspeisung - Powerzero by neromatrix | |
| ### - mqtt only adaption by noone2k | |
| ### first attempt, use at your own risk ! | |
| ### Ver. 0.01m | |
| - lambda: |- | |
| if(id(switch_opendtu_limit).state) | |
| { | |
| int ptu_min_value = 5; | |
| int ptu_max_value = id(mqtt_opendtu_limit_max).state; // 50; // <- nax rel value -> id(npw2500_zeropower_max_powerlimit_rel).state; | |
| int ptu_limit = 0; | |
| int ptu_max_power = 900; // max:2 (x:4*2 for 4port using 2port) | |
| int grid_to_ptu_ratio = ptu_max_power/100; | |
| int grid_min_value = 20; | |
| static int ptu_old_limit = 0; | |
| /* | |
| <- actual power mqtt -> prev. int(id(npw2500_grid_power).state); | |
| keep over grid_min_value | |
| */ | |
| int grid_value = int(id(mqtt_grid_power).state) - grid_min_value;; | |
| ptu_limit = grid_value / grid_to_ptu_ratio + ptu_old_limit; | |
| if(ptu_limit > ptu_max_value) ptu_limit = ptu_max_value; | |
| if(ptu_limit < ptu_min_value) ptu_limit = ptu_min_value; | |
| // change only if diff more than +/-1% | |
| if ( ptu_limit - ptu_old_limit > 1 || ptu_old_limit - ptu_limit > 1 ) { | |
| ESP_LOGD("npw2500","PowerZero PTU old limit %d, PTU new limit %d, Grid value %d " ,ptu_old_limit, ptu_limit, grid_value); | |
| ptu_old_limit = ptu_limit; | |
| //char mtopic[64]; | |
| //snprintf(mtopic, 64,"openDTU/XXXXXXXXXXX/cmd/limit_persistent_relative"); | |
| //id(mqtt_client).publish(mtopic,to_string(ptu_limit)); | |
| id(mqtt_opendtu_limit).publish_state(ptu_limit); | |
| } | |
| } |
Ne kurze Nachfrage zu dieser Zeile :
ble_cmd_parm: "0<.,.>192.168.XX.XXX<.,.>1883<.,.>noone<.,.>noone<.,.>"
Diese Größer/Kleiner, Punkt und Komma sind nicht irgendwelche Platzhalter und müssen drin sein ? Sorry, bin mir dieser Sprache nicht mächtig. Ich muß also nur diese X mit meiner Broker-IP ergänzen und statt noone mein User/PW ändern. Port stimmt ja.
richtig, sind keine platzhalter .. die firmware trennt an dieser stelle die einzelnen parameter und schreibt diese in den speicher ...
//edit ... stell dir das wie csv vor ... nur der separator ist "<.,.>" .....
wer die möglichkeit hat, mqtt zu testen: im git sind jetzt paar test-shell-scripte
und ne ocr transcription des online-manuals ...
in der ocr transcription ist noch der eine oder andere fehler. bei ocr kaum zu vermeiden,
wer die korrigieren und "aufhübschen" möchte, gerne zu ...
wenn, dann bitte im reinen txt format bleiben ... kein odt/pdf/doc/whatever ... platzverschwendung für reine informationen ....
auch das "loop"-test-script ist nur für die v1 werte, wer das auf seiner >=v1.2 testet und anpasst ..
( im grunde wäre das nur eine fleiss-aufgabe - c&p im array), kann gerne auch die änderungen submitten ...
euch heute ne gute ernte
und geniesst die sonne ...
(und nicht zuviel marschieren 😁 )
@noone2k
Ich habe von npw wieder auf dein Script umgestellt, da ich die Abfrage von zwei Speichern brauche und mir ausreicht, die Entladeschwelle über 500W stellen zu können. Dann funktioniert der Speicher (für mich) optimal.
Allerdings bekomme ich nur kurzzeitig Werte per MQTT, danach nur noch diese Fehler im ESPHome-Log:
[08:38:49][W][script:060]: Script 'ble_process' is already running! (mode: single)
[08:38:53][D][esp32_ble_client:110]: [1] [C4:A6:4E:45:29:64] ESP_GATTC_READ_CHAR_EVT
[08:38:53][W][ble_sensor:078]: Error reading char at handle 21, status=2
[08:38:53][W][ble_sensor:078]: Error reading char at handle 21, status=2
[08:38:54][D][esp32_ble_client:110]: [0] [E8:8D:A6:56:9B:9B] ESP_GATTC_READ_CHAR_EVT
[08:38:54][W][ble_sensor:078]: Error reading char at handle 24, status=2
[08:38:54][W][ble_sensor:078]: Error reading char at handle 24, status=2
[08:39:00][W][script:060]: Script 'ble_process' is already running! (mode: single)
[08:39:04][D][esp32_ble_client:110]: [1] [C4:A6:4E:45:29:64] ESP_GATTC_READ_CHAR_EVT
[08:39:04][W][ble_sensor:078]: Error reading char at handle 24, status=2
[08:39:04][W][ble_sensor:078]: Error reading char at handle 24, status=2
[08:39:07][D][esp32_ble_client:110]: [0] [E8:8D:A6:56:9B:9B] ESP_GATTC_READ_CHAR_EVT
Es scheint dazu auch einen Issue bei ESPHome zu geben: esphome/issues#5421
Ich bin auf Version 2024.4.2
nutzt du das script aus dem gist oder git ?
das gist hier habe ich schon ne weile nicht mehr geupdatet ..
das neueste ist im git ....
teste vorallem gerade das esp-idf 5.2.1, deswegen ist noch nicht alles neue im git ...
//edit die meisten error, die da sind , kann man ignorieren, unschön fürs log, aber funktioniert trortdem
was blockiert ist der der error mit dem "mode:single " ... das dürfte in der git version "unelegant" umschifft worden sein ...
Ich habe das gist genommen, stelle ich gleich mal um.
ESP-IDF Updates mache ich in meinen Projekten nicht mehr, seit da regelmässig übliche Funktionalitäten wir RS232 oder das Interrupt-Handling so verändert wurden, dass tagelanges Debugging angesagt war. Da ist mir meine Zeit zu schade.
:) ... ja, kenn ich .... im neueren platform-io framework zum esp-idf fehlt u.a. noch die sntp adaptierung ... bin deswegen bei meinen tests von sntp-timer auf intervall umgestiegen ... u.a. aus diesen grund fehlt mir u.a. auch der timestamp der letzten antwort ...
ble scheint etwas stabiler, aber der esp32 rebootet relativ häufig ( alle 1-12 h ),
so das man nicht sagen kann ob es der stack ist oder die häufigen reboots des esp32 , die das gerade biegen 😁
der reboot des esp32 ist aber normalerweise für mich kein problem ... gibs halt für ca. 30 sekunden keine im mqtt-daten ...
anyway ... vor kurzem schon daran gedacht, mal wieder das "alte" bzw. default framework zum vergleich laufen zulassen,
Mit der Variante aus dem Git verbindet er sich nicht mehr mit den Speichern:
10:07:20 | [W] | [ble_sensor:123] | [infoX2b] Cannot poll, not connected
10:07:28 | [W] | [ble_sensor:123] | [infoX2a] Cannot poll, not connected
10:08:20 | [W] | [ble_sensor:123] | [infoX2b] Cannot poll, not connected
10:08:28 | [W] | [ble_sensor:123] | [infoX2a] Cannot poll, not connected
Die MAC-Adressen stimmen, habe ich mehrfach kontrolliert. Clean Build Files hat auch nix gebracht.
Das muss jetzt leider erstmal warten.
ok, wäre ne gelgenheit mal auf das default-framework umzustellen, um das besser nachstellen zu können ...
gibs da noch ein bisserl mehr ?
Leider nicht. Ich spiele das über Home Assistant auf. Mehr gibt das Log nicht her:
INFO Upload took 9.58 seconds, waiting for result...
INFO OTA successful
INFO Successfully uploaded program.
INFO Starting log output from 192.168.2.184 using esphome API
INFO Successfully connected to bc2500-ble-idf @ 192.168.2.184 in 15.627s
INFO Successful handshake with bc2500-ble-idf @ 192.168.2.184 in 0.127s
[10:42:08][I][app:100]: ESPHome version 2024.4.2 compiled on May 2 2024, 10:38:37
[10:42:10][W][component:237]: Component api took a long time for an operation (58 ms).
[10:42:10][W][component:238]: Components should block for at most 30 ms.
[10:42:41][W][ble_sensor:123]: [infoX2a] Cannot poll, not connected
[10:42:50][W][ble_sensor:123]: [infoX2b] Cannot poll, not connected
[10:43:41][W][ble_sensor:123]: [infoX2a] Cannot poll, not connected
[10:43:50][W][ble_sensor:123]: [infoX2b] Cannot poll, not connected
Ich habe auf dem Kommunikationsmodul noch Version 202303012046, weil bisher alle Update-Versuche fehlgeschlagen sind. BT funktioniert aber prinzipiell, das gist funktioniert ja und auch die Handy-App verbindet sich, wenn ich in der Nähe bin.
wenn ich jetzt die richtige version erwischt habe, funktioniert die git version bei mir aus dem stand heraus ...
muss aber einiges backporten ( hat nichts mit der funktionalität an sich zu tun, eher mit meinem oh-frontend ) ..
[10:41:31][I][app:100]: ESPHome version 2024.4.1 compiled on May 2 2024, 10:36:21
[10:41:31][I][esp32_ble_client:067]: [0] [E8:8D:A6:XX:XX:XX] 0x00 Attempting BLE connection
[10:41:31][I][esp-idf:000]: W (6571) BT_HCI: hcif disc complete: hdl 0x0, rsn 0x3e
[10:41:32][I][ble_sensor:031]: [infoX2a] Connected successfully!
[10:41:33][I][esp32_ble_client:067]: [1] [E8:8D:A6:XX:XX:XX] 0x00 Attempting BLE connection
[10:41:33][I][esp32_ble_client:227]: [0] [E8:8D:A6:XX:XX:XX] Connected
[10:41:34][I][main:2695]: ble command send: 1 [2] 0
[10:41:34][I][ble_sensor:031]: [infoX2b] Connected successfully!
[10:41:34][I][esp32_ble_client:227]: [1] [E8:8D:A6:XX:XX:XX] Connected
[10:41:35][I][main:2695]: ble command send: 2 [2] 0
[10:41:40][I][main:2695]: ble command send: 1 [4] 1
[10:41:40][I][main:1773]: runtime parse: 1
[10:41:40][I][main:2695]: ble command send: 2 [4] 1
[10:41:40][I][main:1773]: runtime parse: 2
[10:41:50][I][main:2695]: ble command send: 1 [3] 1
ich sehe gerade, bin auf 24.04.01 ... werde mal 02 updaten ...
sollte unabhängig der fc41d firmware sein ...
du bist nicht reinzufällig noch mit dem handy verbunden ?
Das Handy ist sicher nicht verbunden, so weit geht das nicht. Ich habe die App jetzt auch deaktiviert, selbes Verhalten. Neuen ESP32 kann ich heute Abend testen, falls der Nachwuchs mir soviel Luft lässt.
eine schneller versuch wäre, den esp32 vorher komplett zu säubern ...
an der shell/console/whatever ( ich kenn mich mit ha nicht aus, vllt. gibs da auch eine möglichkeit direkt in der gui ) :
esptool erase_flash ..... ( die komplette cmd-line dürfte im git in der readme stehen ... da bin ich mir ziemlich sicher )
//edit die komplette steht da nicht ... man muss glaube nur noch den port angeben ... ( ---port /dev/ttyXXX ) ... solte aber vom dem error-text ableitbar sein ...
Ich habe den ESP über PlatformIO gelöscht und neu bespielt. Leider mit demselben Ergebnis. Seltsamerweise verbindet auch der Code aus dem gist nicht mehr.
@andreash-esp
ist etwas OT aber im Moment gibt es anscheinend Probleme mit ESP (in HA)
Ich kann keinen ESP mehr für einen DS18B20 aufsetzen.
Egal welchen Pin ich verwende - nix. Auch nicht mit einem 8266
zu wenig informationen um daraus irgendwas abzuleiten ...
ggf. mal ein kompletter log über die serial ... da könnte ein wenig mehr drin stehen ...
die config hast du schon gegengeprüft, laut deiner aussage ...
was mir gerade noch einfällt, habs aber nicht geprüft:
die secrets.yaml von neromatrix und mir nutzen eine unterschiedliche nomenklatur.
aber theor, müsstte esphome da lautstark protestieren, wenn eine definition nicht übereinstimmt ...
etwas schwer so eine diagnose, wenn ich das problem nicht in den händen halte und das fehlerbild mir unbekannt ist 😁
@helmi55
die info gibt wenigstens einen weiteren anhaltspunkt, wo man weiter gucken könnte ;)
abr bei HA bin ich raus ...
@helmi55 Vielen Dank, guter Hinweis!
Da finden sich einige Hinweise in ESPhome Github über Wifi/BT Probleme. Das hier passt auch gut:
esphome/issues#5693
An sich bin ich schon beruflich ein Fan von "stay current, stay up-to-date", aber in dem Umfeld macht das oft keinen Spass.
Hat jemand von euch eine Ahnung wie man die Wifi Einstellung komplett löscht? Seit dem ich das update der App auf 1.3.7 gemacht hatte und in den mqtt einstellungen meine Daten eigegeben habe, stellt ein speicher keine verbindung mehr zu meinem Wifi her. Es meldet sich zwar an und ist auch im Netzwerk aber das Wifi zeichen in der app bleibt gelb und irgendwann bricht der kontakt komplett ab.
du bist mit dem wifi verbunden ... nur nicht mehr mit dem amazon mqtt servern ... ( gelb = wifi ja / amazon mqtt nein ) ....
du greifst NIE direkt auf die kiste mit wifi zu, das geht immer über den umweg der amazon mqtt server ...
//welche firmware hast du auf dem gerät ?
anyway
du kannst per ble probieren, die werkeinstellungen zu laden. ggf. vorher die app auf 1.41 updaten ...
//edit .. ok, hier kommen ein paar edits von dir dazwischen ... app version 1.41 und firmware 1.37 ?
es braucht ggf. ne weile, bis die kiste mit deinen lokalen mqtt verbunden ist ... einfach kurz abwarten ...
diehst du in deinem mqtt-broker conneccts ?
Habe selbes Problem.
Werkseinstellungen etc..... hat bei mir alles nichts geholfen.Schuss hat mir heute eine Firmware freigegeben.Kann ich aber erst später mal probieren.
du hattest aber fw 1.35 ? oder auch schon 1.37 ?
//edit
die app sendet nur den befehl, das die fw in der kiste die werkeinstellungen "laden" soll ...
die fw 1.35 setzt ggf. aber nicht die mqtt einstellungen zurück ... die 1.37 ggf. jedoch schon .. müsste mal reinguckem ...
@noone2k ich habe die v135 und auch die 1.4.1 app gehabt es hat alles nichts gebracht. Hardreset, Werkseinstellungen, Neustart, Pinbrücke nichts...
Mich wundert das die app immer wieder den wlan ssid drin hat obwohl ich alles resets gemacht habe und auch die app mit vorherigem löschen des speichers deinstalliert habe.
Ich habe einen V2 mit Firmware 157.
die fw setzt beim werkeinstellung laden die wifi einstellungen auf "hellow/!2345678" ...
so wars zumindestens in früheren ... ggf. mal gucken, ob sich das geändert hat.
Ich habe immer unseren netzwerknamen drin egal was ich in der app einstelle. War aber schon immer so. Obwohl ich mich auch schon erfolgreich in hotspots eingewählt habe trotzdem steht app wieder die haus ssid drin.
@Fuxifux
ok, zu v2 kann ich keine aussage machen .. das verhalten scheint aber identisch zur fw 1.35 der v1, in verbindung der app 1.4x
die app mekrt sich die ssid an für sich nicht, afaik
sondern fragt sie von der kiste ab, per ble ...
Und das kann man aus der kiste nicht löschen?
sollte mit den werkeinstellungen überschrieben werden,
anscheinend bei dir nicht ... habs bei mir jedoch nicht weiter getestet ...
die app 1.4x sollte nur mit der fw 1.37 genutzt werden, wenn es um mqtt geht.
es gibt auch mqtt settings in der 1.35, da ist der syntax jedoch anders ...
sollte in der app abgefangen werden ... wirds aber anscheinend nicht ...
zur ssid kann ich erstmal nichts sagen, will das gerade nicht testen ...
aber dein mqtt problem könnte mit der fw 1.37 behoben werden.
es ist etwas verwirrend .. einmal schreibst du fw 1.35 und dann wieder 1.37 ...
//edit wenn du die 1.37 hast, kannst du mein script aus dem git nutzen, und die korrekten mqtt parameter für dein lokalen mqtt setzen, falls da ein fehler drin war ...
Also mein app update war 1.37 und die fw ist aktuell v135
bei dir wurde das update auf FW 1.37 für die kiste angezeigt. und hast du das eingespielt ?
Nein es wurde nicht angezeigt bzw. hab es nicht mitbekommen das es angezeigt wurde.
Als ich das update auf 135 angezeigt bekommen habe konnte ich es zu dem zeitpunkt nicht flashen und wollte später machen. Als ich es später machen wollte wurde es nicht mehr angezeigt. Erst nach ein paar tagen kam es das das update auf v135. Finde ich auch etwas merkwürdig. Und aktuell hab ich kein hinweis auf ein update v137
und was ist dann die 1.37 ? IOS ?
Okay jetzt bin ich selber verwirrt. Also ich habe Android und habe mein mqtt mit der Appversion 1.37 eingerichtet was aber nicht funktioniert hat. Seither funktioniert Wifi nicht mehr richtig. Dann hatte ich noch Appupdate 1.4.0 und kurz darauf 1.4.1. Die fw des speichers war zu jeder zeit immer auf v135
Aber mit App Version 1.37 konnte man doch keine MQTT Einstellungen vornehmen ! Ging erst bei 1.40.
Daraus wurde dann 1.41 wo das MQTT wieder entfernt wurde in der APP.
ok .. got it .... 😁
wow .. schwere geburt ... 😁
ja, die app läuft nicht 100% lokal, sondern bezieht sich online einige zusatzfuntkionen und informationen.
wenn du die mqtt parameter bei der fw 1.35 setzt, werden die einstellungen in der kiste verhunzt.
resultat: wifi ja / mqtt nein -> gelbes symbol ... ich müsste in der fw 1.35 gucken, ob man das gerade biegen könnte.
aber das sollte die aufgabe vom support der kiste sein.
dann bleibt das gleiche problem, bei dir wird wahrscheinlich nur ein update auf fw 1.37 etwas bringen ...
Stimmt du hast recht. Entschuldige bitte da war ich jetzt durcheinander gekommen
muss hier glaube noch mal ne kleine erklärung nachschieben:
die sogenannte wifi-steuerung funktioniert über die amazon-mqtt server ( du bist nie direkt per wifi mit der kiste verbunden ).
wenn internet oder die amazon-mqtt server weg sind ( oder in der kiste falsch konfiguriert bzw. auf local gesetzt sind ),
gibt es keine "wifi-steuerung" ... die gab es im eigentlichen sinne NIE ... das geht alles über die amazon server.
die einzige wirklich locale steuerung funktioniert per ble ( und die neue locale mqtt-untersützung, sollte diese "marktreife" erlangen )
@Larvy
ich weiss nicht, ob schuss diese möglichkeit hat, aber theor. kann man auch die 1.35 nochmal drüber bügeln.
habe das bei mir schon gemacht.
das hängt aber davon ab, was das update-system von schuss/hametech erlaubt. das kenn ich ja so nicht ...
wenn man die fehlerhaften parameter im flash identifiziert, kann man die auch einzeln überschreiben,
aber auch hier weiss ich nicht, was das system von hametech ermöglicht/erlaubt.
wird wahrscheinlich auf ein komplettes update auf 1.37 hinauslaufen.
Okay ich danke dir für die ausführliche Info. Dann warte ich mal. Aber wenn das Ding kein inet / wifi hat kommt doch auch kein update zustande oder?
das ding hat doch internet zugang .. nur kein mqtt ...
aber auch für das update brauch die kiste kein internet ...
das fw update für die kiste holt sich die app auf dem tablet/handy über das internet ... und spielt es über bluetooth ein ...
Firma Schuss hat mir eine Firmware V160 freigegeben.Installiert und funktioniert wieder. WiFi Zeichen ist wieder grün. 👍
habe von der 1.60 irgendwo gelesen .. wird dann wahrscheinlich das equivalent zum 1.37 bei der v1 sein ....
scrollup ... jup, du bist der, mit dem gs v2 😁
Genau 😂👍
Nach dem Update auf die Version 1.3.7 funktioniert auch mein Erweiterungsspeicher. Der DOD wird nur auch für die Erweiterungsbatterie berücksichtigt, keine Kommunikationsprobleme mit dem Speicher, bisher keine Nachteile festgestellt.
Bei mir startet der ESP recht regelmässig neu:
Das führt im Zusammenspiel mit dem EnforceDOD dazu, dass morgens die Ausgänge deaktiviert sind.
Ist das "normal" für den ESPhome? Ich stelle erstmal den EnforceDOD und die Abfrage der Zellspannungen aus.
jaein ... was ist schon "normal" ... :)
in der git version sind mehrere restarts eingebaut, wenn bestimmte ble-fehler entdeckt werden.
ob es jetzt definitiv einer der abgefangen ble-fehler sind oder was anderes, ist teilw. schwer zu erkennen,
wenn kein rechner direkt am esp32 per serial drangestöpselt ist.
da, wo jetzt meine batterien / esp32 sind/ist, hab ich momentan keinen rechner stehen um diese low-level fehler zu analysieren.
bei mir stören diese reboot erstmal nicht. bei dir scheint es da probleme zu geben ...
im top-bereich des yaml gibt es einige switch_on_off anweisungen, die bei einem neustart gesetzt werden. da kannst du die optionen,
die probleme machen erstmal deaktivieren.
enforce_dod ist z.b. nicht nötig wenn man nur out2 am wr hat ...
da fällt mir ein, habe noch gar nicht getestet, ob diese "sporadische" stromabgabe bei dod auch beim hm1500 auftritt,
wenn out1/out2 am wr sind.
alternativ könnte man nen watch-task oder so einrichten, der unter bestimmten bedingungen die ausgänge wieder aktiviert.
muss mal schauen, ob ich mir die arbeit mache und nen esp32-c6 als serial-wifi bridge umbastle ( falls die genug power liefern ),
um auch an die low-level serial logs komme ohne das ich da nen rechner vor ort habe.
dürfte noch paar irgendwo in der bastel kiste haben.
Hallo,
melde mich hier das erste mal, da heute mein Speicher angekommen & angeschlossen ist. Jetzt würde ich das Teil natürlich auch gerne per mqtt auslesen und steuern.
Ich habe mir dazu einen Raspi mit Home Assist hergerichtet um den ESP32 mit der Firmware zu betanken.
Leider gibt es Probleme mit dem web_server. Beim Kompilieren werden diese Daten nicht gefunden: js_include: "./v2/www.js"
Habe von Home Assistant leider keinen Ahnung!
Wie macht ihr das?
Viele Grüße
Reiner
@Reinschki
Servus und willkommen.
Du musst in HA als erstes ESPhome installieren
Du musst in HA mit dem File editor oder mit dem Studio Code Server (gibts unter HACS
unter config im Ordner "esphome" einen Ordner v2 anlegen und dort die www.js reinkopieren
Ich weiss jetzt leider nicht auf die Schnelle wo du das findest, aber ich glaube es wurde hier angeführt
https://gist.github.com/neromatrix/6ec812f35418c4b38ebbad4e92cac888
Sonst würde ich dir für HA dieses Forum empfehlen. Hier kannst du dich einlesen:
https://community.simon42.com
LG
Helmut
wenn du nur mqtt nutzen möchtest, schau hier: https://github.com/noone2k/hm2500pub
da sind alle notwendigen dateien vorhanden ...
theor. kannst du auch den webserver komplett deaktivieren ...
wenn du ha einsetzen willst, schau auf diese seite von neromatrix:: https://gist.github.com/neromatrix/6ec812f35418c4b38ebbad4e92cac888
da sitzen die HA experten ...
@helmi55
Datei ist jetzt vorhanden, es sieht jetzt so aus wie bei dir!
Aber es will nicht so recht gelingen!?
einmal "esphome clean" ausführen ... oder wenn du ne gui benutzt, gucken wo man die build-files "aufräumen" kann ...
Dank eurer "schubser" läuft der ESP und es werden Nachrichten per MQTT übertragen.
Ich nutze übrigens Fhem zur Steuerung und Anzeige der Werte.
Um jetzt beispielsweise den DOD einzustellen müsste ich doch folgendes publishen:
b2500/hame_energy/HMA-1/App/94706ccdbd65/ctrl cd=05,md=70
Und HMA-1 abweichend von deinem Beispiel, weil:
Das müsste doch so verarbeitet werden, oder?
b2500/1/battery/dod ändert sich aber nicht auf 50!?
jaein ... die topics, die du nutzt, sind für die integrierte locale mqtt steuerung des b2500 ...
die ist noch in entwicklung und "eigentlich" noch nicht verfügbar.
solltest du "reinzufällig" die fw 1.37 auf deinem b2500 haben,
kannst du integrierte mqtt steuerung im b2500 einschalten. ( dann funtkioniert aber die "wifi-steuerung" nicht mehr, erklärung weiter oben )
mit diesem yaml wird die kiste m.h. des esp32 über ble gesteuert. welcher wiederum per mqtt gesteuert werden kann.
die befehle für die mqtt->ble steuerung findest du in dem yaml. ist noch nicht in einer readme oder so dokumentiert.
die einzige dokumentation ist die yaml selbst ;)
bspw. für den dod: b2500/1/battery/dod/set
( oder b2500/2/battery/dod/set , für ne zweite batterie. greppe einfach nach "command_topic" , dann hast du alle implementierten commands )
btw. nutze auch fhem für die 433/868 steuerung einiger geräte ( u.a. ventilator / klimaanlage / wetterstation / lichterketten ) 😁
mein hauptfrontend ist aber OH ...
ach .. hast du u.a. die infos aus dem mqtt ordner im git genutzt ?
wenn ja, sollte ich ggf. doch mal dazuschreiben,
für was diese befehle sind ( im b2500 integrierte local mqtt steuerung ab fw 1.37+) 😁
@Reinschki
Ist OT aber willst du nicht gleich auf HA umsteigen.
ist wesentlich komfortabler als FHEM.
ich habe vor 1 1/2 Jahren diesen Schritt gewagt und noch nicht bereut......
Blöde Frage,aber wenn ich das local MQTT jetzt nutzen will, muss ich dann die # aus der yaml (add mqtt local) entfernen und dort meinen Broker eintragen ? Oder muss ich die Daten in der Secret eintragen ?
Soviel ich vestehe denke ich die # entfernen und meine Daten eintragen,aber was mache ich dann mit denen aus der Secret ? Rauslöschen ?
wenn du die "#" entfernst hast, kannst du im b2500 den mqtt-server eintragen, mit dem er sich connecten soll.
d.h. der speicher schreibt ( wie im mqtt-ordner beschrieben ) selbst und direkt in deinen lokalen mqtt-broker.
der amazon mqtt ( und damit die "wifi-steuerung" ) wird dann nicht mehr genutzt.
man kann dann ohne esp32 oder andere zwischenschritte den speicher direkt steuern ( im gewissen rahmen ).
die topics sind anders und man muss nen kompletten string parsen, es gibt nicht mehr einzelne subtopics.
aber das ist im mqtt-ordner beschrieben ( die interne locale mqtt steuerung des b2500 , muss mir da was kürzeres einfallen lassen 😁 )
du musst dann aber alle "komfort-funktionen", die bspw. neromatrix in seiner HA-Version drin hat,
in deinem Smarthome-system selbst abbilden ( sei es OH, HA, whatver ).
Macht u.a. dann Sinn, wenn du dich in deiner eigenen Umgebung, die du schon länger nutzt, wohler fühlst,
als in einem yaml für den esp32.
//edit
btw. die esp32 steuerung und "ILMSDB25" ( justkidding 😀 ) funktionieren auch parallel, genauso wie vorher auch die amazon-mqtt steuerung ...
die esp32 lösung ist im grunde nur eine ble-mqtt ( oder HA) - bridge speziell für den B2500.
der b2500 soll das irgendwann auch selbst können
ab fw. 1.37 bei der v1 ist eine "test-version" drin bzw noch in der entwicklung.
kann sich also jederzeit ändern, die topics, die möglichkeiten, whatever ...
Aaaaaaah, echt viel zu lesen (und zu verwechseln) hier! Jetzt kann ich den Speicher steuern!
Was mir noch fehlt ist die Info zum aktuellen Ladezustand.
Die Werte wurde wurden heute morgen gepublished, seitdem aber nicht mehr. Batterie ist jetzt voll!
Kann ich die Aktualisierung irgendwie anstoßen?
Das heisst # entfernen.Daten eintragen.Auf ESP32 flashen und kurz laufen lassen, dann fertig ?
@Reinschki
remaining_* = SoC
solange die ble verbindung besteht, sollte der esp32 die werte auslesen und in mqtt publishen ..
ich sehe gerade du hast nen HMA-1, also nen v1.2/V2 ( wie auch immer ) und die fw. 157 ..
dieses script ist auf basis der V1 entstanden ... das meiste davon sollte auch beim v2 funktionen ...
aber es kann da natürlich unterschiede geben und es werden nicht alle funktionen der v2 genutzt.
im git ist irgendwo ne kurze diskussion dazu ...
voralllem solltest du erstmal NICHT die interne mqtt steuerung des v2 damit "einschalten" ...
wenn ich as richtig verstanden habe, geht das bei der v2 erst ab fw. 160 ... ( dont quote me on that, habe keinen zugriff auf so ein gerät )
Das heisst # entfernen.Daten eintragen.Auf ESP32 flashen und kurz laufen lassen, dann fertig ?
halbwegs ... dann gibt es einen neuen button ... den muss man noch "drücken" ...
am schnellsten geht es, wenn du einfach "PRESS" an das topic "b2500/1/test/mqtt/set" sendest ;)
dann werden die werte, die bei "ble_cmd_parm" stehen an den speicher gesendet und der b2500 wird
dieses dann nutzen, anstelle des amazon mqtt für die "wifi-steuerung" ...
OK,werde das mal checken wenn ich Zeit habe.Danke !!
Muss ich die ganzen # entfernen,sprich Zeile 288 bis 351 ?
nope ... nur 338 - 351 ...
ich kann dir aber nicht sagen, was die fw 160 der v2 mit dem befehl macht.
das die 160 ein equivalent der 137 ist, ist eine reine vermutung ... also auf eigenes risiko ... ( wobei ich das wahrscheinlich aus neugier auch selbst testen würde 😁 )
Das Skript läuft so auch auf den V2,also gehe ich stark davon ab das dies auch funktioniert,hoffe ich 😉😂
nope ... nur 338 - 351 ... ich kann dir aber nicht sagen, was die fw 160 der v2 mit dem befehl macht. das die 160 ein equivalent der 137 ist, ist eine reine vermutung ... also auf eigenes risiko ... ( wobei ich das wahrscheinlich aus neugier auch selbst testen würde 😁 )
Kann ich dich da irgendwie unterstützen? Irgendwie Zugang zu meinen V2 Speicher geben? Was geht ist die DOD zu verstellen bei meinem V2. Cool wäre wenn ich die Ausgangsleistung anpassen könnte, das geht bestimmt auch irgendwie
So ich habe hier nun schon einiges gelesen und verstehe auch den Sinn der ESP32 also mqtt Server bzw Bluetooth Bridge.
Nun habe ich NodeRed auf einem Raspberry und könnte ja direkt per Bluetooth die Daten abziehen aus dem BC2500 korrekt ?
Weiß jemand mit welchem Bluetooth Passwort man sich verbindet und wie sowas in etwa technisch abläuft ? Mit welchem Weg bekommt auch der ESP32 die Daten aus dem BC2500 ? MQTT Client ist er ja scheinbar ?!
Grüße und viel Sonne,
Daniel
So hab jetzt alles vorbereitet,aber ich traue mich nicht drücken auf set MQTT local. 😂
nope ... nur 338 - 351 ... ich kann dir aber nicht sagen, was die fw 160 der v2 mit dem befehl macht. das die 160 ein equivalent der 137 ist, ist eine reine vermutung ... also auf eigenes risiko ... ( wobei ich das wahrscheinlich aus neugier auch selbst testen würde 😁 )
Kann ich dich da irgendwie unterstützen? Irgendwie Zugang zu meinen V2 Speicher geben? Was geht ist die DOD zu verstellen bei meinem V2. Cool wäre wenn ich die Ausgangsleistung anpassen könnte, das geht bestimmt auch irgendwie
@vogty79
in diesem fall reicht mir ein remote zugang nicht wirklich ...
um die kommunikation zu verstehen, benötige ich einen ble-sniff,
wenn man das mit der app einstellen kann.
bspw. m.h. von wireshark + bt5040u ( + passende firmware ) ...
einige android handy erlauben auch die kommunikation mitzuschneiden .. modellabhängig ...
oder die firmware ... da werde ich aber nicht die mir bekannten 4 wege erklären ...
ist zwar nicht illegal, aber in falschen händen könnte das problematisch werden.
wobei die falschen hände das auch so hinbekommen ...
ein ble-sniff ist die leichtere variante, als sich durch die firmware zu wühlen ...
wenn du bedenken hast, oder nicht die möglichkeit, die 160 erneut einzuspielen. kannst du das auch lassen.
alles gut 😁
wenn du auf die "wifi-steuerung" verzichten kannst, dann los 😁
theor. kannst du mit nem klick auf "werkseinstellungen laden", die mqtt server wieder gerade biegen.
bin mir da momentan aber nicht 100% sicher, müsste in die firmware schauen und ich habe nur die vom v1 ( 137 ) hier ...
// auprobieren kann/will ich gerade nicht, da ich gerade die gute sonnenzeit nutze, um die batterien zu kalibrieren
Egal,ja auf die Wifi könnte ich verzichten,ich lass es mal so.Vielleicht kommt ja doch in naher Zukunft die "offizielle" Variante für den MQTT.
Zumindest habe ich jetzt mal alles in meiner Loxone Welt wie ich es will.😉
Wenn nicht,dann werde ich mutig sein und es riskieren. 😂
Aber mal großes Danke für die ganze Arbeit hier.
@Fuxifux
alles ok ... 👍
kann nur von der v1-firmware ausgehen ... und das einzigste was da passieren kann, das mqtt nicht mehr funktioniert.
ich kann dir zu nichts raten/empfehlen, wenn ich das nicht weiss oder erfahrung damit habe ... theorie und praxis 😁
// ich bin mir immer dessen bewusst, das meine spielereien auch zu einem brick führen können
// habe auch die möglichkeit, die firmware von grund auf neu einzuspielen, was zwar nervig ist, aber fehler korrigieren kann.
// auf der anderen seite, ist das gefühl unbezahlbar, wenn es funktioniert und man was neues lernt 😁
Habt ihr einen Tip, wie man das Update des Kommunikationsmoduls einspielen kann? Ich habe das jetzt meine ich zu jeder möglichen Zeit versucht. WLAN und BT sind dabei stabil und verbunden.
Ich habe zwei V1 Speicher, die mit der 800W Entladeschwelle top funktionieren. Nur die BT-Verbindung zum ESPHome hängt sich immer mal wieder auf und dann stimmen die Statistiken nicht bzw. kann ich nicht Lastabhängig steuern.
es gibt den befehl 0x24, womit du die firmware einspielen kannst.
das ganze kann aber mehrere versuche benötigen, genauso wie in der app ...
es ist nur bequemer das ganze mit dem yaml aus dem git zu machen, als mit der app ...
falls du im photovoltaik forum bist, schreib mich dort privat an ... gleicher nick ...
// habe gerade mal getestet ... momentan dauert es bis zu 30sekunden die datei vom china-server zu ziehen ... viel zu lange ...
// ich weiss gerade nicht, ob mittlerweile das update auf den eu server umgestellt wurde ... da dauert der download < 1 sekunde ... sollte damit besser klappen ...
habe gerade gesehen, das es die fw 1.38 gibt ... gleich mal installiert ...
werde mich mal drüber hermachen, sobald es passt,
nach nem kurzen blick, sieht das erstmal nach einem bugfix release aus, aber keine neuen funktionen gegenüber der 1.37 ...
k.a. ob das was offizielles ist oder nur wieder eine interne test-version ...
also zu nachfragen bei schuss erstmal zurückhalten . bis es offiziell ist oder euch angeboten wird ...
Ja,beim V2 hab ich auch schon von einer V163 gehört. Das Pendant zum V1 wahrscheinlich.
Was echt super wäre wenn man noch die Entladeleistung einstellen könnte für den v2, dann könnte man sich eine Nulleinspeisung basteln mit zum Beispiel einen Hichi IR Sensor ohne den Umweg über den Wechselrichter zu gehen, ist ja im Prinzip nur 1 Wert der regelbar werden müsste. Der Wert wird denke ich auch nicht im eprom geschrieben da er ja mit dem zukünftigen Smartmeter auch ständig angepasst werden wird, vll kann man das in der Firmware auslesen
Im der App gibt's ja schon den Punkt Selbstanpassung. Vielleicht wurde das in den letzten Monaten der Diskussion mal erwähnt, aber gibt's nen bestimmt grund warum man die Ausgangsleistung nicht per Bluetooth einstellen kann? @noone2k
Zudem, gibts sowas wie ein Wiki zu den speichern? Derzeit gibts ja viele Infos überall verstreut.
ja, ich habe keinen v2 um zu gucken was da möglich ist und ggf. die funktionalität nachzubilden ( extrahieren und testen )
ich weiss sogut wie gar nichts über den v2, ausser was man so ab und zu nebenbei hört ( also "werbung" und aus "laien" sicht ).
im git gibt es die möglichkeit ein wiki zu nutzen ...
da schreiben nicht unbedingt meine liebste beschäftigung ist und mich von dingen abhält die mir mehr zusagen
( oder für mich wichtiger sind /höhere prios haben - wie reallife ) steht da relativ wenig bis nichts nützliches.
das ganze ist und bleibt ein hobby für mich und das bedeutet, ich nehme dinger lieber auseinander als da was zu schreiben 😁
jeder ist aber dazu eingeladen beim wiki etwas beizutragen ...
https://github.com/noone2k/hm2500pub/wiki
Ich habe ein V2.
Wie kann ich dir helfen?
Oder
Wie bekomm ich das selbst ausgelesen
Zum Thema schreiben. Kann ich Völlig verstehen 😀
habe in paar tagen die möglichkeit mir mal so ein teil genauer anzuschauen ...
Ich hatte heute mal wieder etwas Zeit und wollte rumspielen. Nach der Umstellung auf lokalem MQTT kommt nicht viel, ich dachte da kommt mehr 😲
Was mache ich falsch ?
verwende die ble-mac statt der serialnr ...
bzw. schaue in den mqtt-ordner im git ....
// sind das deine anfragen ? oder die vom speicher ? der speicher selbst sendet auch diese cd=01 anfragen ( an die serial - hab das schon an "schuss" weitergeleitet ... k.a. ob feature oder fehler )
// du musst diese senden, mit der ble-mac ...
// beispiele sind dort als shell scripte hinterlegt ...
Ach Du meinst ich muß erst mal ein pub machen um dann was zu bekommen 😲
jup ... du sendest den ctrl cd=01 ( mit der ble_mac ) .....
dann bekommst du auf dem sub die antwort.
aber nur für cd=01/cd=30, die anderen sind still.
den status ob die anderen funktionen funktioniert haben, kannst du wieder mit cd=01 abfragen ...
Ach Du meinst ich muß erst mal ein pub machen um dann was zu bekommen 😲
Das, was du da in deinem Screenshot siehst, ist das Topic, das die App verwendet um dem Speicher zum senden von Daten zu bringen. Der Speicher schreibt seine Nachrichten in das .../device/... topic. Wenn du die Nachricht nicht gepublished hast, wer war das dann? 🤔 Die App schreibt doch nicht in den lokalen MQTT, oder doch?
der speicher selbst ... da das erstmal für mich auf den ersten blick keinen sinn macht, habe ich das schuss gemeldet.
aber wer weiss, warum der speicher seine daten selbst versucht abzufragen, die er sowieso schon hat ( haben müsste ) ... 😁
für die locale ansteuerung wird die ble_mac verwendet ...
//edit
@knickohr
schau dir die bash-scripte an bzw. das ocr-transcript ....
zum "lauschen": _bc2500_mqtt_listen.sh
zum "befehlen": _bc2500_mqtt_pub.sh
innerhalb der *pub.sh sind die commandos auch soweit dokumentiert.
und als kleines gimmik, ein listen parser, als reines shell-script: _bc2500_mqtt_loop.sh 😁
Alles fein 👍
Man muß nur wissen das man die Batterie erst dazu bitten muß 🤪
alles gut .. ich vergesse manchmal auch die "@" ansprache oder ähnliches...
und da kann man durcheinander kommen, wenn man so egozentrisch eingestellt ist oder glaubt eine persönliche beziehung zu haben und alles auf sich bezieht 😁