first commit

libraries/FastLED/examples/Chromancer/net.h

@@ -0,0 +1,168 @@
+#pragma once
+
+#include <Arduino.h>
+#include <FastLED.h>
+
+#define OTA_SUPPORTED 0
+#define WIFI_SUPPORTED 0
+
+#if OTA_SUPPORTED && !WIFI_SUPPORTED
+#error "You can't have OTA without WiFi, dummy"
+#endif
+
+#if WIFI_SUPPORTED
+#include <ArduinoOSC.h>
+#include <ESPmDNS.h>
+#include <WiFi.h>
+#include <WiFiUdp.h>
+const char *ssid = "YourMom";
+const char *password = "is a nice lady";
+// WiFi stuff - CHANGE FOR YOUR OWN NETWORK!
+const IPAddress ip(4, 20, 6, 9); // IP address that THIS DEVICE should request
+const IPAddress gateway(192, 168, 1, 1); // Your router
+const IPAddress
+    subnet(255, 255, 254,
+           0); // Your subnet mask (find it from your router's admin panel)
+const int recv_port = 42069; // Port that OSC data should be sent to (pick one,
+                             // put same one in EmotiBit's OSC Config XML file)
+#endif
+
+#if OTA_SUPPORTED
+#include <ArduinoOTA.h>
+#endif
+
+void net_init();
+void net_loop();
+
+void net_init() {
+#if WIFI_SUPPORTED
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(ssid, password);
+    WiFi.config(ip, gateway, subnet);
+    while (WiFi.waitForConnectResult() != WL_CONNECTED) {
+        Serial.println("Connection Failed! Rebooting...");
+        delay(5000);
+        ESP.restart();
+    }
+
+    Serial.print("WiFi connected, IP = ");
+    Serial.println(WiFi.localIP());
+
+    // Subscribe to OSC transmissions for important data
+    OscWiFi.subscribe(
+        recv_port, "/EmotiBit/0/EDA",
+        [](const OscMessage &m) { // This weird syntax is a lambda expression
+                                  // (anonymous nameless function)
+            lastKnownTemperature = m.arg<float>(0);
+        });
+
+    OscWiFi.subscribe(recv_port, "/EmotiBit/0/GYRO:X", [](const OscMessage &m) {
+        gyroX = m.arg<float>(0) * gyroAlpha + gyroX * (1 - gyroAlpha);
+    });
+
+    OscWiFi.subscribe(recv_port, "/EmotiBit/0/GYRO:Y", [](const OscMessage &m) {
+        gyroY = m.arg<float>(0) * gyroAlpha + gyroY * (1 - gyroAlpha);
+    });
+
+    OscWiFi.subscribe(recv_port, "/EmotiBit/0/GYRO:Z", [](const OscMessage &m) {
+        gyroZ = m.arg<float>(0) * gyroAlpha + gyroZ * (1 - gyroAlpha);
+    });
+
+    // Heartbeat detection and visualization happens here
+    OscWiFi.subscribe(recv_port, "/EmotiBit/0/PPG:IR", [](const OscMessage &m) {
+        float reading = m.arg<float>(0);
+        Serial.println(reading);
+
+        int hue = 0;
+
+        //  Ignore heartbeat when finger is wiggling around - it's not accurate
+        float gyroTotal = abs(gyroX) + abs(gyroY) + abs(gyroZ);
+
+        if (gyroTotal < gyroThreshold && lastIrReading >= reading) {
+            // Our hand is sitting still and the reading dropped - let's pulse!
+            Serial.print("> ");
+            Serial.println(highestIrReading - reading);
+            if (highestIrReading - reading >= heartbeatDelta) {
+                if (millis() - lastHeartbeat >= heartbeatLockout) {
+                    hue = fmap(lastKnownTemperature, lowTemperature,
+                               highTemperature, 0xFFFF, 0);
+                    for (int i = 0; i < 6; i++) {
+                        if (nodeConnections[15][i] > 0) {
+                            bool firedRipple = false;
+                            // Find a dead ripple to reuse it
+                            for (int j = 0; j < 30; j++) {
+                                if (!firedRipple && ripples[j].state == dead) {
+                                    ripples[j].start(
+                                        15, i, strip0.ColorHSV(hue, 255, 255),
+                                        float(random(100)) / 100.0 * .2 + .8,
+                                        500, 2);
+
+                                    firedRipple = true;
+                                }
+                            }
+                        }
+                    }
+                }
+
+                lastHeartbeat = millis();
+            }
+        } else {
+            highestIrReading = 0;
+        }
+
+        lastIrReading = reading;
+        if (reading > highestIrReading)
+            highestIrReading = reading;
+    });
+#endif // WIFI_SUPPORTED
+
+#if OTA_SUPPORTED
+    // Wireless OTA updating? On an ARDUINO?! It's more likely than you think!
+    ArduinoOTA
+        .onStart([]() {
+            String type;
+            if (ArduinoOTA.getCommand() == U_FLASH)
+                type = "sketch";
+            else // U_SPIFFS
+                type = "filesystem";
+
+            // NOTE: if updating SPIFFS this would be the place to unmount
+            // SPIFFS using SPIFFS.end()
+            Serial.println("Start updating " + type);
+        })
+        .onEnd([]() { Serial.println("\nEnd"); })
+        .onProgress([](unsigned int progress, unsigned int total) {
+            Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
+        })
+        .onError([](ota_error_t error) {
+            Serial.printf("Error[%u]: ", error);
+            if (error == OTA_AUTH_ERROR)
+                Serial.println("Auth Failed");
+            else if (error == OTA_BEGIN_ERROR)
+                Serial.println("Begin Failed");
+            else if (error == OTA_CONNECT_ERROR)
+                Serial.println("Connect Failed");
+            else if (error == OTA_RECEIVE_ERROR)
+                Serial.println("Receive Failed");
+            else if (error == OTA_END_ERROR)
+                Serial.println("End Failed");
+        });
+
+    ArduinoOTA.begin();
+
+    Serial.println("Ready for WiFi OTA updates");
+    Serial.print("IP address: ");
+    Serial.println(WiFi.localIP());
+#endif
+}
+
+void net_loop() {
+#if WIFI_SUPPORTED
+    OscWiFi.parse();
+#endif
+
+#if OTA_SUPPORTED
+    ArduinoOTA.handle();
+#endif
+
+}