flow-based programming

code/espurna/button.ino

@@ -15,10 +15,17 @@ Copyright (C) 2016-2018 by Xose Pérez <xose dot perez at gmail dot com>
 #include <DebounceEvent.h>
 #include <vector>
 
+#if FLOW_SUPPORT
+class FlowButtonComponent; // forward declaration
+#endif
+
 typedef struct {
     DebounceEvent * button;
     unsigned long actions;
     unsigned int relayID;
+    #if FLOW_SUPPORT
+    std::vector<FlowButtonComponent *> flow_components;
+    #endif
 } button_t;
 
 std::vector<button_t> _buttons;
@@ -42,6 +49,45 @@ bool _buttonWebSocketOnReceive(const char * key, JsonVariant& value) {
 
 #endif
 
+// -----------------------------------------------------------------------------
+// FLOW
+// -----------------------------------------------------------------------------
+
+#if FLOW_SUPPORT
+
+PROGMEM const char flow_data2[] = "Data";
+PROGMEM const char* const flow_data2_array[] = {flow_data2};
+
+PROGMEM const FlowConnections flow_button_component = {
+    0, NULL,
+    1, flow_data2_array,
+};
+
+PROGMEM const char flow_button_component_json[] =
+    "\"Button\": "
+    "{"
+        "\"name\":\"Button\","
+        "\"icon\":\"toggle-on\","
+        "\"inports\":[],"
+        "\"outports\":[{\"name\":\"Data\",\"type\":\"int\"}],"
+        "\"properties\":[{\"name\":\"Button\",\"type\":\"list\"}]"
+    "}";
+
+class FlowButtonComponent : public FlowComponent {
+    public:
+        FlowButtonComponent(JsonObject& properties) {
+            int button_id = properties["Button"];
+            _buttons[button_id].flow_components.push_back(this);
+        }
+
+        void buttonEvent(unsigned char event) {
+            JsonVariant data((int)event);
+            processOutput(data, 0);
+        }
+};
+
+#endif // FLOW_SUPPORT
+
 int buttonFromRelay(unsigned int relayID) {
     for (unsigned int i=0; i < _buttons.size(); i++) {
         if (_buttons[i].relayID == relayID) return i;
@@ -105,6 +151,12 @@ void buttonEvent(unsigned int id, unsigned char event) {
        }
     #endif
 
+    #if FLOW_SUPPORT
+        for (FlowButtonComponent* component : _buttons[id].flow_components) {
+            component->buttonEvent(event);
+        }
+    #endif
+
     if (BUTTON_MODE_TOGGLE == action) {
         if (_buttons[id].relayID > 0) {
             relayToggle(_buttons[id].relayID - 1);
@@ -122,11 +174,11 @@ void buttonEvent(unsigned int id, unsigned char event) {
             relayStatus(_buttons[id].relayID - 1, false);
         }
     }
-    
+
     if (BUTTON_MODE_AP == action) {
         wifiStartAP();
     }
-    
+
     if (BUTTON_MODE_RESET == action) {
         deferredReset(100, CUSTOM_RESET_HARDWARE);
     }
@@ -142,13 +194,13 @@ void buttonEvent(unsigned int id, unsigned char event) {
             wifiStartWPS();
         }
     #endif // defined(JUSTWIFI_ENABLE_WPS)
-    
+
     #if defined(JUSTWIFI_ENABLE_SMARTCONFIG)
         if (BUTTON_MODE_SMART_CONFIG == action) {
             wifiStartSmartConfig();
         }
     #endif // defined(JUSTWIFI_ENABLE_SMARTCONFIG)
-    
+
     #if LIGHT_PROVIDER != LIGHT_PROVIDER_NONE
     if (BUTTON_MODE_DIM_UP == action) {
         lightBrightnessStep(1);
@@ -233,6 +285,17 @@ void buttonSetup() {
         wsOnReceiveRegister(_buttonWebSocketOnReceive);
     #endif
 
+    #if FLOW_SUPPORT
+        std::vector<String>* buttons = new std::vector<String>();
+        for (unsigned int i=0; i < _buttons.size(); i++) {
+            buttons->push_back(String(i));
+        }
+
+        flowRegisterComponent("Button", &flow_button_component, flow_button_component_json,
+            (flow_component_factory_f)([] (JsonObject& properties) { return new FlowButtonComponent(properties); }));
+        flowRegisterComponentValues("Button", "Button", buttons);
+    #endif
+
     // Register loop
     espurnaRegisterLoop(buttonLoop);
 

code/espurna/config/general.h

@@ -1492,3 +1492,15 @@
 #ifndef RFM69_IS_RFM69HW
 #define RFM69_IS_RFM69HW            0
 #endif
+
+#ifndef FLOW_SUPPORT
+#define FLOW_SUPPORT                0
+#endif
+
+#ifndef FLOW_SPIFFS_FILE
+#define FLOW_SPIFFS_FILE            "/flow.json"
+#endif
+
+#ifndef FLOW_MQTT_TOPIC
+#define FLOW_MQTT_TOPIC             "flow"
+#endif

code/espurna/config/prototypes.h

@@ -210,3 +210,16 @@ void webRequestRegister(web_request_callback_f callback);
 typedef std::function<void(justwifi_messages_t code, char * parameter)> wifi_callback_f;
 void wifiRegister(wifi_callback_f callback);
 bool wifiConnected();
+
+// -----------------------------------------------------------------------------
+// FLOW
+// -----------------------------------------------------------------------------
+
+#if FLOW_SUPPORT
+    #include "flow.h"
+    typedef std::function<FlowComponent* (JsonObject&)> flow_component_factory_f;
+    void flowRegisterComponentValues(String component, String property, std::vector<String>* values);
+#else
+    #define FlowConnections void
+    #define flow_component_factory_f void *
+#endif

code/espurna/espurna.ino

@@ -114,6 +114,13 @@ void setup() {
         apiSetup();
     #endif
 
+    #if FLOW_SUPPORT
+        // register default flow components first
+        flowSetup();
+        // settings component after
+        settingsFlowSetup();
+    #endif
+
     // lightSetup must be called before relaySetup
     #if LIGHT_PROVIDER != LIGHT_PROVIDER_NONE
         lightSetup();
@@ -189,6 +196,9 @@ void setup() {
     #if UART_MQTT_SUPPORT
         uartmqttSetup();
     #endif
+    #if FLOW_SUPPORT && SPIFFS_SUPPORT
+        flowStart();
+    #endif
 
 
     // 3rd party code hook

code/espurna/flow.h

@@ -0,0 +1,139 @@
+#pragma once
+
+#include <vector>
+#include <map>
+
+struct FlowConnections {
+    int inputsNumber;
+    const char* const* inputs;
+    int outputsNumber;
+    const char* const* outputs;
+};
+
+class FlowComponent {
+    private:
+        typedef struct {
+            FlowComponent* component;
+            int inputNumber;
+        } output_t;
+
+        std::vector<std::vector<output_t>> _outputs;
+
+    protected:
+        void processOutput(JsonVariant& data, int outputNumber) {
+            if (outputNumber < _outputs.size()) {
+                for (output_t output : _outputs[outputNumber])
+                    output.component->processInput(data, output.inputNumber);
+            }
+        }
+
+        JsonVariant* clone(JsonVariant& data) {
+            if (data.is<int>()) {
+                return new JsonVariant(data.as<int>());
+            } else if (data.is<double>()) {
+                return new JsonVariant(data.as<double>());
+            } else if (data.is<bool>()) {
+                return new JsonVariant(data.as<bool>());
+            } else if (data.is<char*>()) {
+                char *str = strdup(data.as<const char*>());
+                return new JsonVariant(str);
+            } else {
+                return new JsonVariant(data);
+            }
+        }
+
+        String toString(JsonVariant& data) {
+            if (data.is<int>()) {
+                return String(data.as<int>());
+            } else if (data.is<double>()) {
+                return String(data.as<double>(), 3);
+            } else if (data.is<bool>()) {
+                return String(data.as<bool>() ? "<true>" : "<false>");
+            } else if (data.is<char*>()) {
+                return String(data.as<const char*>());
+            } else {
+                return String();
+            }
+        }
+
+        void release(JsonVariant* data) {
+            if (data == NULL)
+                return;
+
+            if (data->is<char*>()) {
+                void* str = (void*)data->as<char*>();
+                free(str);
+            }
+            delete data;
+        }
+
+    public:
+        FlowComponent() {
+        }
+
+        void addOutput(int outputNumber, FlowComponent* component, int inputNumber) {
+            if (outputNumber >= _outputs.size())
+                _outputs.resize(outputNumber + 1);
+            _outputs[outputNumber].push_back({component, inputNumber});
+        }
+
+        virtual void processInput(JsonVariant& data, int inputNumber) {
+        }
+};
+
+typedef std::function<FlowComponent* (JsonObject&)> flow_component_factory_f;
+
+class FlowComponentLibrary {
+    private:
+        std::vector<const char*> _jsons;
+        std::map<String, const FlowConnections*> _connectionsMap;
+        std::map<String, flow_component_factory_f> _factoryMap;
+
+    public:
+        void addType(String name, const FlowConnections* connections, const char* json, flow_component_factory_f factory) {
+            _jsons.push_back(json);
+            _connectionsMap[name] = connections;
+            _factoryMap[name] = factory;
+        }
+
+        const char* getComponentJson(int index) {
+            if (index >= _jsons.size())
+                return NULL;
+            return _jsons[index];
+        }
+
+        FlowComponent* createComponent(String& name, JsonObject& properties) {
+            flow_component_factory_f& factory = _factoryMap[name];
+            return factory != NULL ? factory(properties) : NULL;
+        }
+
+        int getInputNumber(String& name, String& input) {
+            const FlowConnections* connections = _connectionsMap[name];
+            if (connections == NULL)
+                return -1;
+
+            FlowConnections temp;
+            memcpy_P (&temp, connections, sizeof (FlowConnections));
+            for (int i = 0; i < temp.inputsNumber; i++) {
+                if (strcmp_P(input.c_str(), temp.inputs[i]) == 0)
+                    return i;
+            }
+
+            return -1;
+        }
+
+        int getOutputNumber(String& name, String& output) {
+            const FlowConnections* connections = _connectionsMap[name];
+            if (connections == NULL)
+                return -1;
+
+            FlowConnections temp;
+            memcpy_P (&temp, connections, sizeof (FlowConnections));
+            for (int i = 0; i < temp.outputsNumber; i++) {
+                if (strcmp_P(output.c_str(), temp.outputs[i]) == 0)
+                    return i;
+            }
+
+            return -1;
+        }
+};