ESP32 (C6-Zero or comparable) Storz & Bickel Volcano Exporter

volcano_exporter.ino

/*
MIT License

Copyright (c) 2024 Lukas Fülling ([email protected])

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/

/*
 * volcano_exporter
 */
#include "BLEDevice.h"
#include <Arduino.h>
#include <WiFi.h>

// Replace with your network credentials
const char *ssid = "MY_NETWORK";
const char *password = "MY_PASSWORD";

typedef enum {
  DEVICE_STATE_INIT,
  DEVICE_STATE_CONNECTING_WIFI,
  DEVICE_STATE_CONNECTING_BLE,
  DEVICE_STATE_IDLE,
  DEVICE_STATE_FETCHING_WIFI,
  DEVICE_STATE_FETCHING_BLE,
  DEVICE_STATE_ERROR
} DeviceState;

struct VolcanoMetrics {
  bool connected = false;
  bool heaterActive = false;
  bool airActive = false;
  uint32_t currentTemperature = -1;
  uint32_t selectedTemperature = -1;
  uint32_t operationHours = -1;
  uint16_t autoShutoffTime = -1;
  uint16_t ledBrightness = -1;
  uint32_t serialNumber = -1;
  String deviceFirmwareVersion = "";
  String bleFirmwareVersion = "";
  String bleAddress = "";
};

NetworkServer server(80);
TaskHandle_t ledTaskHandle = NULL;
DeviceState state = DEVICE_STATE_INIT;
VolcanoMetrics deviceMetrics = VolcanoMetrics();

void registerMetricsUpdates(BLERemoteService *service,
                            BLEUUID characteristicId,
                            notify_callback callback,
                            std::function<void(BLERemoteCharacteristic *characteristic)> readInitialValue) {
  BLERemoteCharacteristic *characteristic = service->getCharacteristic(characteristicId);
  if (characteristic == nullptr) {
    Serial.println("[ERROR] Failed to find characteristic!");
    return;
  }
  if (characteristic == nullptr) {
    Serial.println("[ERROR] Characteristic is null!");
    return;
  }

  if (characteristic->canRead()) {
    readInitialValue(characteristic);
  } else {
    Serial.print("[WARNING] Unable to read ");
    Serial.print(characteristic->getUUID().toString());
    Serial.println("!");
  }

  if (characteristic->canNotify()) {
    characteristic->registerForNotify(callback);
  } else {
    Serial.print("[WARNING] Unable to notify for ");
    Serial.print(characteristic->getUUID().toString());
    Serial.println("!");
  }
}

String getMetricLabels(VolcanoMetrics metrics) {
  return "{addr=\"" + metrics.bleAddress + "\"," + "dev_fw=\"" + metrics.deviceFirmwareVersion + "\"," + "ble_fw=\"" + metrics.bleFirmwareVersion + "\"," + "serial=\"" + metrics.serialNumber + "\"}";
}

String getMetricString(String label, String help, String type, String value, VolcanoMetrics metrics) {
  return "# HELP " + label + " " + help + "\n" + "# TYPE " + label + " " + type + "\n" + label + getMetricLabels(metrics) + " " + value + "\n";
}

String getGaugeMetricString(String label, String help, String value, VolcanoMetrics metrics) {
  return getMetricString(label, help, "gauge", value, metrics);
}

String buildMetricsString() {
  String result = "";

  if (deviceMetrics.currentTemperature != -1) {
    result += getGaugeMetricString("volcano_current_temp_celsius",
                                   "The current temperature in Celsius.",
                                   String(deviceMetrics.currentTemperature), deviceMetrics);
  }
  if (deviceMetrics.selectedTemperature != -1) {
    result += getGaugeMetricString("volcano_selected_temp_celsius",
                                   "The selected temperature in Celsius.",
                                   String(deviceMetrics.selectedTemperature), deviceMetrics);
  }
  if (deviceMetrics.operationHours != -1) {
    result += getMetricString("volcano_operation_hours",
                              "Device operation hours.",
                              "counter",
                              String(deviceMetrics.operationHours), deviceMetrics);
  }
  if (deviceMetrics.autoShutoffTime != -1) {
    result += getGaugeMetricString("volcano_auto_shutoff_time",
                                   "Auto shutoff time in seconds(?).",
                                   String(deviceMetrics.autoShutoffTime), deviceMetrics);
  }
  if (deviceMetrics.ledBrightness != -1) {
    result += getGaugeMetricString("volcano_led_brightness",
                                   "LED Brightness.",
                                   String(deviceMetrics.ledBrightness), deviceMetrics);
  }

  result += getGaugeMetricString("volcano_heat_active",
                                 "Boolean (0 or 1) showing whether the heat is currently active.",
                                 String(deviceMetrics.heaterActive ? "1" : "0"), deviceMetrics);
  result += getGaugeMetricString("volcano_air_active",
                                 "Boolean (0 or 1) showing whether the air pump is currently active.",
                                 String(deviceMetrics.airActive ? "1" : "0"), deviceMetrics);

  return result;
}

void ledIteration(int i) {
  // DEVICE LAYOUT IS GRB, NOT RGB!!!
  switch (state) {
    case DEVICE_STATE_CONNECTING_WIFI:
      neopixelWrite(RGB_BUILTIN, i, 0, i);
      break;
    case DEVICE_STATE_CONNECTING_BLE:
      neopixelWrite(RGB_BUILTIN, 0, 0, i);
      break;
    case DEVICE_STATE_IDLE:
      neopixelWrite(RGB_BUILTIN, i, 0, 0);
      break;
    case DEVICE_STATE_FETCHING_WIFI:
      neopixelWrite(RGB_BUILTIN, 0, max(i, 8), max(i, 8));
      break;
    case DEVICE_STATE_FETCHING_BLE:
      neopixelWrite(RGB_BUILTIN, i, max(i, 8), max(i, 8));
      break;
    case DEVICE_STATE_ERROR:
      neopixelWrite(RGB_BUILTIN, 0, i, 0);
    case DEVICE_STATE_INIT:
    default:
      neopixelWrite(RGB_BUILTIN, i, i, i);
  }
}

void ledLoop(void *param) {
  while (1) {
    for (int i = 1; i < 16; i++) {
      ledIteration(i);
      vTaskDelay(pdMS_TO_TICKS(80));
    }
    for (int i = 1; i < 16; i++) {
      ledIteration(17 - i);
      vTaskDelay(pdMS_TO_TICKS(80));
    }
  }
}

void connectVolcano(BLEAdvertisedDevice advertisedDevice) {
  Serial.print("[INFO] Found Volcano ");
  Serial.print(advertisedDevice.getAddress().toString().c_str());
  Serial.println("…");

  BLEClient *pClient = BLEDevice::createClient();
  Serial.println("[DEBUG] Created client…");

  pClient->connect(&advertisedDevice);
  Serial.println("[DEBUG] Connected to server…");
  pClient->setMTU(517);

  BLERemoteService *service1 = pClient->getService(BLEUUID("10110000-5354-4F52-5A26-4249434B454C"));
  if (service1 == nullptr) {
    Serial.println("[ERROR] Failed to find service1!");
  } else {
    // current temperature
    registerMetricsUpdates(
      service1, BLEUUID("10110001-5354-4f52-5a26-4249434b454c"),
      [](BLERemoteCharacteristic *characteristic, uint8_t *pData, size_t length, bool isNotify) {
        uint32_t value = 0;
        if (length == 4) {
          value = ((uint32_t)pData[3] << 24) | ((uint32_t)pData[2] << 16) | ((uint32_t)pData[1] << 8) | ((uint32_t)pData[0]);
          deviceMetrics.currentTemperature = value / 10;
        } else {
          Serial.println("[WARNING] Invalid data length!");
        }
      },
      [](BLERemoteCharacteristic *characteristic) {
        deviceMetrics.currentTemperature = characteristic->readUInt32() / 10;
      });

    // selected temperature
    registerMetricsUpdates(
      service1, BLEUUID("10110003-5354-4f52-5a26-4249434b454c"),
      [](BLERemoteCharacteristic *characteristic, uint8_t *pData, size_t length, bool isNotify) {
        uint32_t value = 0;
        if (length == 4) {
          value = ((uint32_t)pData[3] << 24) | ((uint32_t)pData[2] << 16) | ((uint32_t)pData[1] << 8) | ((uint32_t)pData[0]);
          deviceMetrics.selectedTemperature = value / 10;
        } else {
          Serial.println("[WARNING] Invalid data length!");
        }
      },
      [](BLERemoteCharacteristic *characteristic) {
        deviceMetrics.selectedTemperature = characteristic->readUInt32() / 10;
      });

    // operation hours
    registerMetricsUpdates(
      service1, BLEUUID("10110015-5354-4f52-5a26-4249434b454c"),
      [](BLERemoteCharacteristic *characteristic, uint8_t *pData, size_t length, bool isNotify) {
        uint32_t value = 0;
        if (length == 4) {
          value = ((uint32_t)pData[3] << 24) | ((uint32_t)pData[2] << 16) | ((uint32_t)pData[1] << 8) | ((uint32_t)pData[0]);
          deviceMetrics.operationHours = value;
        } else {
          Serial.println("[WARNING] Invalid data length!");
        }
      },
      [](BLERemoteCharacteristic *characteristic) {
        deviceMetrics.operationHours = characteristic->readUInt32();
      });

    // led brightness
    registerMetricsUpdates(
      service1, BLEUUID("10110005-5354-4f52-5a26-4249434b454c"),
      [](BLERemoteCharacteristic *characteristic, uint8_t *pData, size_t length, bool isNotify) {
        uint16_t value = 0;
        if (length == 2) {
          value = (((uint16_t)pData[1] << 8) | ((uint16_t)pData[0]));
          deviceMetrics.ledBrightness = value;
        } else {
          Serial.println("[WARNING] Invalid data length!");
        }
      },
      [](BLERemoteCharacteristic *characteristic) {
        deviceMetrics.ledBrightness = characteristic->readUInt16();
      });

    // auto shutoff time
    registerMetricsUpdates(
      service1, BLEUUID("1011000d-5354-4f52-5a26-4249434b454c"),
      [](BLERemoteCharacteristic *characteristic, uint8_t *pData, size_t length, bool isNotify) {
        uint16_t value = 0;
        if (length == 2) {
          value = (((uint16_t)pData[1] << 8) | ((uint16_t)pData[0]));
          deviceMetrics.autoShutoffTime = value;
        } else {
          Serial.println("[WARNING] Invalid data length!");
        }
      },
      [](BLERemoteCharacteristic *characteristic) {
        deviceMetrics.autoShutoffTime = characteristic->readUInt16();
      });
  }

  BLERemoteService *service2 = pClient->getService(BLEUUID("10100000-5354-4F52-5A26-4249434B454C"));
  if (service2 == nullptr) {
    Serial.println("[ERROR] Failed to find service2!");
  } else {
    // serial number
    registerMetricsUpdates(
      service2, BLEUUID("10100008-5354-4f52-5a26-4249434b454c"),
      [](BLERemoteCharacteristic *characteristic, uint8_t *pData, size_t length, bool isNotify) {
        uint32_t value = 0;
        if (length == 4) {
          value = ((uint32_t)pData[3] << 24) | ((uint32_t)pData[2] << 16) | ((uint32_t)pData[1] << 8) | ((uint32_t)pData[0]);
          deviceMetrics.serialNumber = value;
        } else {
          Serial.println("[WARNING] Invalid data length!");
        }
      },
      [](BLERemoteCharacteristic *characteristic) {
        deviceMetrics.serialNumber = characteristic->readUInt32();
      });

    // firmware version
    registerMetricsUpdates(
      service2, BLEUUID("10100003-5354-4f52-5a26-4249434b454c"),
      [](BLERemoteCharacteristic *characteristic, uint8_t *pData, size_t length, bool isNotify) {
        String value = "";
        for (int i = 0; i < length; i++) {
          value += (char)pData[i];
        }
        deviceMetrics.deviceFirmwareVersion = value;
      },
      [](BLERemoteCharacteristic *characteristic) {
        deviceMetrics.deviceFirmwareVersion = characteristic->readValue();
      });

    // ble firmware version
    registerMetricsUpdates(
      service2, BLEUUID("10100004-5354-4f52-5a26-4249434b454c"),
      [](BLERemoteCharacteristic *characteristic, uint8_t *pData, size_t length, bool isNotify) {
        String value = "";
        for (int i = 0; i < length; i++) {
          value += (char)pData[i];
        }
        deviceMetrics.bleFirmwareVersion = value;
      },
      [](BLERemoteCharacteristic *characteristic) {
        deviceMetrics.bleFirmwareVersion = characteristic->readValue();
      });

    // heat/air status
    registerMetricsUpdates(
      service2, BLEUUID("1010000c-5354-4f52-5a26-4249434b454c"),
      [](BLERemoteCharacteristic *characteristic, uint8_t *pData, size_t length, bool isNotify) {
        String value = "";
        for (int i = 0; i < length; i++) {
          value += (char)pData[i];
        }
        if (value.length() >= 2) {
          uint8_t heaterValue = value[0];
          bool heaterStatus = (heaterValue & 0x0020) != 0;
          deviceMetrics.heaterActive = heaterStatus;

          uint8_t airValue = value[1];
          bool airPumpStatus = (airValue & 0x0030) != 0;
          deviceMetrics.airActive = airPumpStatus;
        } else {
          Serial.println("[WARNING] Invalid data length!");
        }
      },
      [](BLERemoteCharacteristic *characteristic) {
        String value = characteristic->readValue();
        if (value.length() >= 2) {
          uint8_t heaterValue = value[0];
          bool heaterStatus = (heaterValue & 0x0020) != 0;
          deviceMetrics.heaterActive = heaterStatus;

          uint8_t airValue = value[1];
          bool airPumpStatus = (airValue & 0x0030) != 0;
          deviceMetrics.airActive = airPumpStatus;
        } else {
          Serial.println("[WARNING] Invalid data length!");
        }
      });
  }
  deviceMetrics.connected = true;
}

void setup() {
  Serial.begin(115200);
  Serial.println("[INFO] Booted!");

  // Start ledLoop
  xTaskCreatePinnedToCore(ledLoop, "ledLoop", 10000, NULL, 8, &ledTaskHandle, 1);

  state = DEVICE_STATE_CONNECTING_BLE;
  Serial.println("[INFO] Initializing BLE…");
  BLEDevice::init("volcano_exporter");
  BLEScan *pBLEScan = BLEDevice::getScan();
  pBLEScan->setInterval(1349);
  pBLEScan->setWindow(449);
  pBLEScan->setActiveScan(true);

  while (!deviceMetrics.connected) {
    BLEScanResults *scanResults = pBLEScan->start(5, false);
    for (int i = 0; i < scanResults->getCount(); i++) {
      BLEAdvertisedDevice advertisedDevice = scanResults->getDevice(i);
      String deviceName = advertisedDevice.getName().c_str();
      if (deviceName.startsWith("S&B")) {
        connectVolcano(advertisedDevice);
        // break out of the loop!
        break;
      }
    }
  }

  state = DEVICE_STATE_CONNECTING_WIFI;
  Serial.println("[INFO] Initializing WiFi…");
  WiFi.setHostname("volcano_exporter");
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    vTaskDelay(pdMS_TO_TICKS(1000));
    Serial.println("[DEBUG] (still) connecting to WiFi…");
  }
  Serial.println("[INFO] Connected to WiFi!");
  Serial.print("[INFO] IP address: ");
  Serial.println(WiFi.localIP());
  server.begin();
}

void handleAvailableClient() {
  NetworkClient client = server.accept();
  if (client) {
    state = DEVICE_STATE_FETCHING_WIFI;
    String currentLine = "";
    String header = "";
    while (client.connected()) {
      if (client.available()) {  // check if bytes are available
        char c = client.read();
        header += c;
        if (c == '\n') {  // if the byte is a newline character
          // if the current line is blank, you got two newline characters in a row.
          // that's the end of the client HTTP request, so send a response:
          if (currentLine.length() == 0) {
            Serial.print("[INFO] Request: " + header.substring(0, header.indexOf('\n')));

            if (header.indexOf("GET /metrics") >= 0) {
              if (deviceMetrics.connected) {
                Serial.println(" -> 200, metrics!");
                String metricsString = buildMetricsString();
                client.println("HTTP/1.1 200 OK");
                client.println("Content-type: text/plain; version=0.0.4; charset=utf-8");
                client.println("Connection: close");
                client.println("Content-Length: " + String(metricsString.length()));
                client.println();
                client.println(metricsString);
              } else {
                Serial.println(" -> 500, error!");
                String response = "It bork.";
                state = DEVICE_STATE_ERROR;
                client.println("HTTP/1.1 500 Internal Server Error");
                client.println("Content-type: text/plain");
                client.println("Connection: close");
                client.println("Content-Length: " + String(response.length()));
                client.println();
                client.println(response);
              }
            } else {
              String nonMetricsResponse = "<html><body><p>Please see <a href=\"/metrics\">/metrics</a> for data.</p></body></html>";
              Serial.println(" -> 302, redirect!");
              client.println("HTTP/1.1 302 Found");
              client.println("Content-type: text/html");
              client.println("Connection: close");
              client.println("Location: /metrics");
              client.println("Content-Length: " + String(nonMetricsResponse.length()));
              client.println();
              client.println(nonMetricsResponse);
            }

            // The HTTP response ends with another blank line
            client.println();
            // Break out of the while loop
            break;
          } else {  // if you got a newline, then clear currentLine
            currentLine = "";
          }
        } else if (c != '\r') {  // if you got anything else but a carriage return character,
          currentLine += c;      // add it to the end of the currentLine
        }
      }
    }
    client.stop();
  }
}

void loop() {
  if (state != DEVICE_STATE_ERROR) {
    if (state != DEVICE_STATE_IDLE) {
      state = DEVICE_STATE_IDLE;
    }
    handleAvailableClient();
    vTaskDelay(pdMS_TO_TICKS(50));
  }
}