ESPHome support

component.yaml

@@ -0,0 +1,89 @@
+ota:
+  password: "e82fe9bada398051d779151a591a1e2e"
+  # Needed to get round interrupt issue
+  on_begin:
+    then:
+      - lambda: balboagl->pause();
+
+external_components:
+    - source:
+        type: git
+        url: https://github.com/netmindz/balboa_GL_ML_spa_control.git
+        ref: ESPHome
+      refresh: 0s
+
+
+BalboaGL:
+  # Pin values for T-RSC3
+  hardware_uart: UART1
+  rx_pin: 3
+  tx_pin: 10
+  enable_pin: 5
+  panel_select_pin: 6
+
+climate:
+  - platform: BalboaGL
+    name: Temp
+    update_interval: 220ms
+
+#   # Text sensors with general information.
+text_sensor:
+    # Expose ESPHome version as sensor.
+    - platform: version
+      name: ESPHome Version
+    # Expose WiFi information as sensors.
+    - platform: wifi_info
+      ip_address:
+        name: IP
+      ssid:
+        name: SSID
+      bssid:
+        name: BSSID
+
+    - platform: BalboaGL
+      state:
+        name: State
+      raw:
+        name: Raw Data
+      # lcd:
+      #   name: LCD Display
+
+# Sensors with general information.
+sensor:
+  # Uptime sensor.
+  - platform: uptime
+    name: Uptime
+
+  - platform: BalboaGL
+    commandQueue:
+      name: Command Queue
+
+  # WiFi Signal sensor.
+  - platform: wifi_signal
+    name: WiFi Signal
+    update_interval: 60s
+
+switch:
+  - platform: BalboaGL
+    name: Light
+
+
+select:
+  - platform: BalboaGL
+    pump1:
+      name: Pump1
+      options: 
+        "HIGH"
+    pump2:
+      name: Pump2
+      options: 
+        "HIGH"
+
+button:
+  - platform: BalboaGL
+    up:
+      name: "UP"
+    down:
+      name: "Down"
+    mode:
+      name: "Mode"

components/BalboaGL/ESPBalboaGL.cpp

@@ -0,0 +1,177 @@
+#include <string>
+#include "ESPBalboaGL.h"
+using namespace esphome;
+
+void telnetSend(String msg) {
+    ESP_LOGI(TAG, msg.c_str());
+}
+
+void log(const char *format, ...) {
+    char loc_buf[64];
+    char * temp = loc_buf;
+    va_list arg;
+    va_list copy;
+    va_start(arg, format);
+    va_copy(copy, arg);
+    int len = vsnprintf(temp, sizeof(loc_buf), format, copy);
+    va_end(copy);
+    if(len < 0) {
+        va_end(arg);
+    };
+    if(len >= sizeof(loc_buf)){
+        temp = (char*) malloc(len+1);
+        if(temp == NULL) {
+            va_end(arg);
+        }
+        len = vsnprintf(temp, len+1, format, arg);
+    }
+    va_end(arg);
+    std::string str = reinterpret_cast<char *>(temp);
+    ESP_LOGI(TAG, str.c_str());
+    if(temp != loc_buf){
+        free(temp);
+    }
+
+}
+/**
+ * Create a new BalboaGL object
+ *
+ * Args:
+ *   hw_serial: pointer to an Arduino HardwareSerial instance
+ *   poll_interval: polling interval in milliseconds
+ */
+BalboaGL::BalboaGL(
+        HardwareSerial* hw_serial
+) :
+    hw_serial_{hw_serial}
+{
+
+}
+
+void BalboaGL::check_logger_conflict_() {
+#ifdef USE_LOGGER
+    if (this->get_hw_serial_() == logger::global_logger->get_hw_serial()) {
+        ESP_LOGW(TAG, "  You're using the same serial port for logging"
+                " and the BalboaGL component. Please disable"
+                " logging over the serial port by setting"
+                " logger:baud_rate to 0.");
+    }
+#endif
+}
+
+void BalboaGL::loop() {
+    // ESP_LOGV(TAG, "Loop called.");
+    int sanity = 0;
+    do {
+        this->spa->readSerial();
+        // if(status.rawData != lastRaw) {
+        //     ESP_LOGD(TAG, "Raw: %s", status.rawData.c_str());
+        //     lastRaw = status.rawData;
+        //     // this->publish_state();
+        // }
+        sanity++;
+    }
+    while((status.commandQueue > 0) && (sanity < 10));
+    if(status.commandQueue > 0) {
+        this->high_freq_.start(); // no wait on main loop
+    }
+    else {
+        this->high_freq_.stop();
+    }
+
+//    if(status.commandQueue > 0) ESP_LOGV(TAG, "q:%u s:%u", status.commandQueue, sanity);
+}
+
+void BalboaGL::setup() {
+    // This will be called by App.setup()
+    // this->banner();
+    ESP_LOGCONFIG(TAG, "Setting up UART...");
+    if (!this->get_hw_serial_()) {
+        ESP_LOGCONFIG(
+                TAG,
+                "No HardwareSerial was provided. "
+                "Software serial ports are unsupported by this component."
+        );
+        this->mark_failed();
+        return;
+    }
+    this->check_logger_conflict_();
+
+    ESP_LOGCONFIG(TAG, "Initialize new balboaGL object.");
+
+    ESP_LOGI(TAG, "Serial begin rx,tx = %u,%u", this->rx_pin, this->tx_pin);
+    hw_serial_->begin(115200, SERIAL_8N1, rx_pin, tx_pin);
+    // hw_serial_->setHwFlowCtrlMode(UART_HW_FLOWCTRL_RTS);
+    hw_serial_->setPins(this->rx_pin, this->tx_pin, -1, this->rts_pin);
+    // hw_serial_->setMode(UART_MODE_RS485_HALF_DUPLEX);
+    this->spa = new balboaGL(hw_serial_, rts_pin, panel_select_pin);
+    this->spa->attachPanelInterrupt();
+    if(delay_time > -1) this->spa->set_delay_time(delay_time);
+
+//     ESP_LOGCONFIG(
+//             TAG,
+//             "hw_serial(%p) is &Serial(%p)? %s",
+//             this->get_hw_serial_(),
+//             &Serial,
+//             YESNO(this->get_hw_serial_() == &Serial)
+//     );
+
+//     ESP_LOGCONFIG(TAG, "Calling hp->connect(%p)", this->get_hw_serial_());
+
+//     if (hp->connect(this->get_hw_serial_(), this->baud_, -1, -1)) {
+//         hp->sync();
+//     }
+//     else {
+//         ESP_LOGCONFIG(
+//                 TAG,
+//                 "Connection to HeatPump failed."
+//                 " Marking BalboaGL component as failed."
+//         );
+//         this->mark_failed();
+//     }
+
+    ESP_LOGCONFIG(TAG, "End of seutp");
+    this->dump_config();
+}
+
+void BalboaGL::pause() {
+    ESP_LOGI(TAG, "pause");
+    this->spa->detachPanelInterrupt();
+}
+
+void BalboaGL::dump_config() {
+    // this->banner();
+    ESP_LOGI(TAG, " rx,tx = %u,%u", this->rx_pin, this->tx_pin);
+    ESP_LOGI(TAG, " rts_pin = %u", this->rts_pin);
+    ESP_LOGI(TAG, " panel_select_pin = %u", this->panel_select_pin);
+//     ESP_LOGI(TAG, "  Supports HEAT: %s", YESNO(true));
+//     ESP_LOGI(TAG, "  Supports COOL: %s", YESNO(true));
+//     ESP_LOGI(TAG, "  Supports AWAY mode: %s", YESNO(false));
+//     ESP_LOGI(TAG, "  Saved heat: %.1f", heat_setpoint.value_or(-1));
+//     ESP_LOGI(TAG, "  Saved cool: %.1f", cool_setpoint.value_or(-1));
+//     ESP_LOGI(TAG, "  Saved auto: %.1f", auto_setpoint.value_or(-1));
+}
+
+// void BalboaGL::dump_state() {
+//     LOG_CLIMATE("", "BalboaGL Climate", this);
+//     ESP_LOGI(TAG, "HELLO");
+// }
+
+void BalboaGL::set_rx_pin(int pin) {
+    this->rx_pin = pin;
+}
+
+void BalboaGL::set_tx_pin(int pin) {
+    this->tx_pin = pin;
+}
+void BalboaGL::set_rts_pin(int pin) {
+    this->rts_pin = pin;
+}
+
+void BalboaGL::set_panel_select_pin(int pin) {
+    this->panel_select_pin = pin;
+}
+
+void BalboaGL::set_delay_time(int delay) {
+    this->delay_time;
+}

components/BalboaGL/ESPBalboaGL.h

@@ -0,0 +1,96 @@
+#ifndef ESPMHP_H
+#define ESPMHP_H
+
+#include "esphome.h"
+#include "esphome/core/preferences.h"
+// #include "esphome/components/sensor/sensor.h"
+#include "esphome/components/text_sensor/text_sensor.h"
+#include "esphome/core/log.h"
+#include "esp_log.h"
+
+#include "ESPBalboaGL.h"
+
+static const char* TAG = "BalboaGL"; // Logging tag
+
+// // Perform measurements or read nameplate values on your tub to define the power [kW]
+// // for each device in order to calculate tub power usage
+// const float POWER_HEATER = 2.8;
+// const float POWER_PUMP_CIRCULATION = 0.3;
+// const float POWER_PUMP1_LOW = 0.31;
+// const float POWER_PUMP1_HIGH = 1.3;
+// const float POWER_PUMP2_LOW = 0.3;
+// const float POWER_PUMP2_HIGH = 0.6;
+
+// // Tweak for your tub - would be nice to auto-learn in the future to allow for outside temp etc
+// const int MINUTES_PER_DEGC = 45;
+
+const uint32_t POLL_INTERVAL_DEFAULT = 10000;
+
+#include "balboaGL.h"
+
+using namespace esphome;
+
+class BalboaGL : public Component {
+ public:
+      BalboaGL(
+            HardwareSerial* hw_serial
+        );
+
+        // print the current configuration
+        void dump_config() override;
+
+        // Set up the component, initializing the balboaGL object.
+        void setup() override;
+
+        // This is called every poll_interval.
+        void loop() override;
+
+        // Debugging function to print the object's state.
+        // void dump_state();
+
+        void set_rx_pin(int pin);
+
+        void set_tx_pin(int pin);
+
+        void set_rts_pin(int pin);
+
+        void set_panel_select_pin(int pin);
+
+        void set_delay_time(int delay);
+
+        float get_setup_priority() const override { return esphome::setup_priority::HARDWARE; }
+
+        void pause();
+
+        balboaGL* get_spa() {
+            return spa;
+        }
+
+  protected:
+
+        //Accessor method for the HardwareSerial pointer
+        HardwareSerial* get_hw_serial_() {
+            return this->hw_serial_;
+        }
+
+        //Print a warning message if we're using the sole hardware UART on an
+        //ESP8266 or UART0 on ESP32
+        void check_logger_conflict_();
+
+        int rx_pin = -1;
+        int tx_pin = -1;
+        int rts_pin = -1;
+        int panel_select_pin = -1;
+
+        HighFrequencyLoopRequester high_freq_;
+
+        int delay_time = -1;
+
+  private:
+        // Retrieve the HardwareSerial pointer from friend and subclasses.
+        HardwareSerial *hw_serial_; 
+
+        balboaGL* spa;
+        String lastRaw = "0";
+};
+#endif