initial implementation of the bluetooth proxy for divoom devices

Author: d03n3rfr1tz3

.gitignore

@@ -0,0 +1,4 @@
+.pio
+.vs/**
+.vscode/**
+config_local.h

platformio.ini

@@ -0,0 +1,24 @@
+; PlatformIO Project Configuration File
+;
+;   Build options: build flags, source filter
+;   Upload options: custom upload port, speed and extra flags
+;   Library options: dependencies, extra library storages
+;   Advanced options: extra scripting
+;
+; Please visit documentation for the other options and examples
+; https://docs.platformio.org/page/projectconf.html
+
+[env:esp32dev]
+platform = espressif32
+board = esp32dev
+board_build.partitions = min_spiffs.csv
+framework = arduino
+build_type = release
+lib_deps = AsyncTCP@>=1.1.1
+build_unflags = 
+	-std=gnu++11
+build_flags = 
+	-std=gnu++17
+	-DCONFIG_WIFI_LWIP_ALLOCATION_FROM_SPIRAM_FIRST=1
+	-DCONFIG_BT_ALLOCATION_FROM_SPIRAM_FIRST=1
+monitor_speed = 9600

src/config.h

@@ -0,0 +1,20 @@
+#ifndef _CONFIG_H
+    #define _CONFIG_H
+    
+    #define BLUETOOTH_NAME   "ESP32-Divoom"
+
+    #define WIFI_NAME        "ESP32-Divoom"
+
+    #define WIFISSID1        ""
+    #define WIFIPASS1        ""
+
+    #define WIFISSID2        ""
+    #define WIFIPASS2        ""
+
+    #define TCP_PORT         7777
+    #define TCP_MAX          5
+#endif
+
+#if __has_include("config_local.h")
+# include "config_local.h"
+#endif

src/divoom/divoom.cpp

@@ -0,0 +1,107 @@
+
+#include "bluetoothctl.h"
+
+#include "util.h"
+#include "input/base.h"
+#include "output/base.h"
+
+/**
+ * setup functionality
+*/
+void BluetoothHandler::setup(void) {
+    serialBT.begin(BLUETOOTH_NAME, true);
+    serialBT.register_callback(received);
+    serialBT.discoverAsync(discovered, 500);
+}
+
+/**
+ * loop functionality
+*/
+void BluetoothHandler::loop(void) {
+    if (getElapsed(timer) > 15000) {
+        timer = millis();
+
+        check();
+    }
+}
+
+/**
+ * checks connection and scanning state and keeps background tasks up
+*/
+bool BluetoothHandler::check() {
+    if (!isScanning && serialBT.connected(1000)) {
+        isConnected = true;
+        return true;
+    } else {
+        isConnected = false;
+
+        if (isScanning) {
+            serialBT.discoverAsyncStop();
+            serialBT.discoverClear();
+            isScanning = false;
+        } else {
+            serialBT.discoverAsync(discovered, 2500);
+            isScanning = true;
+        }
+
+        return false;
+    }
+}
+
+/**
+ * connects to the given bluetooth device
+*/
+bool BluetoothHandler::connect(BTAddress address, uint16_t channel) { return connect(address, channel, nullptr); };
+bool BluetoothHandler::connect(BTAddress address, uint16_t channel, const char *pin) {
+    serialBT.discoverAsyncStop();
+    serialBT.discoverClear();
+    
+    if (pin != nullptr) serialBT.setPin(pin);
+    return serialBT.connect(address, channel);
+}
+
+/**
+ * disconnects from the current bluetooth device
+*/
+bool BluetoothHandler::disconnect(void) {
+    return serialBT.disconnect();
+}
+
+/**
+ * callback for when a bluetooth device was discovered
+*/
+void BluetoothHandler::discovered(BTAdvertisedDevice* device) {
+    if (!device->haveName()) return;
+
+    esp_bd_addr_t* address = device->getAddress().getNative();
+    std::string name = device->getName();
+
+    // pass it into the input handlers for an advertise announcement
+    BaseInput::advertise((const uint8_t*)address, name.c_str(), name.size());
+}
+
+/**
+ * callback for when some data from a bluetooth device was received
+*/
+void BluetoothHandler::received(esp_spp_cb_event_t event, esp_spp_cb_param_t *param) {
+    switch (event) {
+        case ESP_SPP_DATA_IND_EVT:
+            size_t available;
+            uint8_t buffer[64];
+            while (available = serialBT.available()) {
+                size_t size = serialBT.readBytes(buffer, available);
+
+                // pass it into the output handlers backward channel
+                BluetoothOutput::backward(buffer, size);
+            }
+            break;
+    }
+}
+
+/**
+ * sends data to the bluetooth device
+*/
+size_t BluetoothHandler::send(const uint8_t *buffer, size_t size) {
+    if (!isConnected) return 0;
+    return serialBT.write(buffer, size);
+}

src/divoom/divoom.h

@@ -0,0 +1,31 @@
+
+#ifndef _BLUETOOTH_H
+    #define _BLUETOOTH_H
+
+    #include "config.h"
+    
+    #include "Arduino.h"
+    #include "BluetoothSerial.h"
+
+    class BluetoothHandler {
+        public:
+            static void setup(void);
+            static void loop(void);
+            static bool check(void);
+
+            static bool connect(BTAddress address, uint16_t channel, const char *pin);
+            static bool connect(BTAddress address, uint16_t channel);
+            static bool disconnect(void);
+
+            static size_t send(const uint8_t *buffer, size_t size);
+
+        private:
+            inline static bool isConnected;
+            inline static bool isScanning;
+            inline static unsigned long timer;
+            inline static BluetoothSerial serialBT;
+
+            static void discovered(BTAdvertisedDevice* device);
+            static void received(esp_spp_cb_event_t event, esp_spp_cb_param_t *param);
+    };
+#endif

src/hardware/bluetoothctl.cpp

@@ -0,0 +1,104 @@
+
+#include "util.h"
+#include "wifictl.h"
+
+WifiHandler::WifiHandler() {
+    timer = millis();
+}
+
+/**
+ * setup functionality
+*/
+void WifiHandler::setup(void) {
+    WiFi.disconnect(true);
+    WiFi.persistent(true);
+    WiFi.setAutoConnect(true);
+    WiFi.setAutoReconnect(true);
+    WiFi.setHostname(WIFI_NAME);
+    WiFi.onEvent(scanned, WiFiEvent_t::ARDUINO_EVENT_WIFI_SCAN_DONE);
+    WiFi.onEvent(connected, WiFiEvent_t::ARDUINO_EVENT_WIFI_STA_GOT_IP);
+    WiFi.onEvent(disconnected, WiFiEvent_t::ARDUINO_EVENT_WIFI_STA_DISCONNECTED);
+    WiFi.scanNetworks(true, false, false, 250);
+}
+
+/**
+ * loop functionality
+*/
+void WifiHandler::loop(void) {
+    if (getElapsed(timer) > 15000) {
+        timer = millis();
+
+        check();
+    }
+}
+
+/**
+ * checks connection and scanning state and keeps background tasks up
+*/
+bool WifiHandler::check(void) {
+    if (WiFi.status() == WL_CONNECTED)
+    {
+        isConnected = true;
+        return true;
+    }
+    else
+    {
+        isConnected = false;
+
+        int8_t wifiStatus = WiFi.status();
+        int8_t scanStatus = WiFi.scanComplete();
+        if ((wifiStatus == WL_IDLE_STATUS ||
+             wifiStatus == WL_NO_SSID_AVAIL ||
+             wifiStatus == WL_CONNECT_FAILED ||
+             wifiStatus == WL_DISCONNECTED) && scanStatus != -1) {
+            WiFi.scanNetworks(true, false, false, 500);
+        }
+
+        return WiFi.status() == WL_CONNECTED;
+    }
+}
+
+/**
+ * connects to one of the scanned wifi networks
+*/
+void WifiHandler::connect(void) {
+    if (WiFi.status() == WL_CONNECTED) return;
+
+    int16_t count = WiFi.scanComplete();
+    for (uint8_t i = 0; i < count && i < 99; i++) {
+        auto ssid = WiFi.SSID(i);
+        if (ssid == NULL || ssid.length() == 0) continue;
+
+        if (ssid == WIFISSID1) { WiFi.begin(WIFISSID1, WIFIPASS1); break; }
+        if (ssid == WIFISSID2) { WiFi.begin(WIFISSID2, WIFIPASS2); break; }
+    }
+
+    WiFi.scanDelete();
+}
+
+/**
+ * callback for when the scan finished
+*/
+void WifiHandler::scanned(WiFiEvent_t event, WiFiEventInfo_t info) {
+    if (info.wifi_scan_done.number > 0) connect();
+}
+
+/**
+ * callback for when we connected to a network
+*/
+void WifiHandler::connected(WiFiEvent_t event, WiFiEventInfo_t info) {
+    isConnected = true;
+
+    WiFi.setTxPower(WIFI_POWER_15dBm);
+    WiFi.setAutoConnect(true);
+    WiFi.setAutoReconnect(true);
+    WiFi.setHostname(WIFI_NAME);
+    WiFi.persistent(true);
+}
+
+/**
+ * callback for when we disconnected from a network
+*/
+void WifiHandler::disconnected(WiFiEvent_t event, WiFiEventInfo_t info) {
+    isConnected = false;
+}

src/hardware/bluetoothctl.h

@@ -0,0 +1,26 @@
+
+#ifndef _WIFI_H
+    #define _WIFI_H
+
+    #include "config.h"
+    
+    #include "Arduino.h"
+    #include "WiFi.h"
+
+    class WifiHandler {
+        public:
+            WifiHandler();
+            static void setup(void);
+            static void loop(void);
+            static bool check(void);
+            static void connect(void);
+
+        private:
+            inline static bool isConnected;
+            inline static unsigned long timer;
+
+            static void scanned(WiFiEvent_t event, WiFiEventInfo_t info);
+            static void connected(WiFiEvent_t event, WiFiEventInfo_t info);
+            static void disconnected(WiFiEvent_t event, WiFiEventInfo_t info);
+    };
+#endif

src/hardware/wifictl.cpp

@@ -0,0 +1,50 @@
+
+#include "base.h"
+
+/**
+ * setup functionality
+*/
+void BaseInput::setup() {
+    TcpInput::setup();
+    SerialInput::setup();
+}
+
+/**
+ * loop functionality
+*/
+void BaseInput::loop() {
+    TcpInput::loop();
+    SerialInput::loop();
+}
+
+/**
+ * the forward channel for a bluetooth connection
+*/
+void BaseInput::forward(const char *address, uint16_t port) {
+    TcpInput::forward(address, port);
+    SerialInput::forward(address, port);
+}
+
+/**
+ * the forward channel for bluetooth data
+*/
+void BaseInput::forward(const uint8_t *buffer, size_t size) {
+    TcpInput::forward(buffer, size);
+    SerialInput::forward(buffer, size);
+}
+
+/**
+ * the backward channel for bluetooth data
+*/
+void BaseInput::backward(const uint8_t *buffer, size_t size) {
+    TcpInput::backward(buffer, size);
+    SerialInput::backward(buffer, size);
+}
+
+/**
+ * the channel for an advertised bluetooth device
+*/
+void BaseInput::advertise(const uint8_t* address, const char* name, size_t size) {
+    TcpInput::advertise(address, name, size);
+    SerialInput::advertise(address, name, size);
+}