Add FireThing, main class for project. Includes config storage and retrieval from eeprom.

ed7coyne · ed7coyne · commit fc1ca027a223 · 2016-12-02T16:43:49.000-08:00
diff --git a/src/Thing.h b/src/Thing.h
@@ -1,3 +1,4 @@
+#include "thing/FireThing.h"
 #include "thing/Transcriber.h"
 #include "thing/Portal.h"
 #include "thing/WiFiManager.h"
diff --git a/src/thing/Config.cpp b/src/thing/Config.cpp
@@ -0,0 +1,48 @@
+#include "Arduino.h"
+#include "thing/Config.h"
+#include "third-party/arduino-json-5.6.7/include/ArduinoJson.h"
+
+namespace thing {
+
+void Config::SerializeToJson(Stream* output, std::function<void(int size)> handle_size) const {
+  DynamicJsonBuffer jsonBuffer;
+  JsonObject& root = jsonBuffer.createObject();
+  root["host"] = host.c_str();
+  root["auth"] = auth.c_str();
+  root["path"] = path.c_str();
+  root["wifi_ssid"] = wifi_ssid.c_str();
+  root["wifi_key"] = wifi_key.c_str();
+  root["analog_activation"] = analog_activation_threshold;
+  root["wifi_connect_attempts"] = wifi_connect_attempts;
+
+  JsonObject& pins_root = root.createNestedObject("pins");
+  pins_root["digital_in"] = pins.digital_in;
+  pins_root["digital_out"] = pins.digital_out;
+  pins_root["analog_in"] = pins.analog_in;
+  pins_root["analog_out"] = pins.analog_out;
+  pins_root["config_mode_button"] = pins.config_mode_button;
+
+  handle_size(root.measureLength());
+  root.printTo(*output);
+}
+
+void Config::ReadFromJson(const char* string) {
+  DynamicJsonBuffer jsonBuffer;
+  JsonObject& root = jsonBuffer.parseObject(string);
+  host = root["host"].asString();
+  auth = root["auth"].asString();
+  path = root["path"].asString();
+  wifi_ssid = root["wifi_ssid"].asString();
+  wifi_key = root["wifi_key"].asString();
+  analog_activation_threshold = root["activation_threshold"];
+  wifi_connect_attempts = root["wifi_connect_attempts"];
+
+  pins.digital_in = root["pins"]["digital_in"];
+  pins.digital_out = root["pins"]["digital_out"];
+  pins.analog_in = root["pins"]["analog_in"];
+  pins.analog_out = root["pins"]["analog_out"];
+  pins.config_mode_button = root["pins"]["config_mode_button"];
+}
+
+};
+
diff --git a/src/thing/Config.h b/src/thing/Config.h
@@ -1,8 +1,20 @@
 #ifndef THING_CONFIG_H
 #define THING_CONFIG_H
 
+#include "Arduino.h"
+#include <string>
+#include <functional>
+
 namespace thing {
 
+struct Pins {
+  int digital_in;
+  int digital_out;
+  int analog_in;
+  int analog_out;
+  int config_mode_button;
+};
+
 struct Config {
   std::string host;
   std::string auth;
@@ -14,11 +26,12 @@ struct Config {
   // If the change is analog value is less than this amount we don't send an
   // update.
   float analog_activation_threshold;
+  int wifi_connect_attempts;
+
+  Pins pins;
 
-  int pin_digital_in;
-  int pin_digital_out;
-  int pin_analog_in;
-  int pin_analog_out;
+  void SerializeToJson(Stream* output, std::function<void(int size)> handle_size) const;
+  void ReadFromJson(const char* string);
 };
 
 }  // namespace thing
diff --git a/src/thing/FireThing.cpp b/src/thing/FireThing.cpp
@@ -0,0 +1,125 @@
+#include "thing/FireThing.h"
+#include "Arduino.h"
+#include "FS.h"
+
+namespace thing {
+namespace {
+
+Config kDefaultConfig = {
+  "",  // firebase host
+  "",  // firebase auth
+  "/fthing",  // path in firebase
+  "",  // wifi ssid
+  "",  // wifi key
+  0.1,  // analog activation threshold
+  D1,  // digital in
+  BUILTIN_LED,  // digital out
+  A0,  // analog in
+  D1, // analog out
+  D0, // config mode button
+};
+
+}  // namespace
+
+FireThing::FireThing() : debug_([](const char*) {}) {}
+
+bool FireThing::Setup() {
+  Config config;
+  if (!ReadConfigFromStorage(&config)) {
+    debug_("Failed to read config from storage.");
+    return false;
+  }
+  SetPinModes(config);
+
+  if (digitalRead(config.pins.config_mode_button) || !ConnectToWiFi(config)) {
+    wifi_.StartAP();
+  }
+
+  portal_.NotifyOnUpdate([this](const Config& config) {
+    if (!WriteConfigToStorage(config)) {
+      debug_("Failed to write config to storage.");
+    }
+    SetPinModes(config);
+    transcriber_.UpdateConfig(config);
+    ConnectToWiFi(config);
+  });
+  portal_.Start(config);
+}
+
+void FireThing::Loop() {
+  wifi_.Loop();
+  portal_.Loop();
+  transcriber_.Loop();
+}
+
+bool FireThing::ConnectToWiFi(const Config& config) {
+  debug_("Connecting to wifi:");
+  debug_(config.wifi_ssid.c_str());
+  debug_(config.wifi_key.c_str());
+  if (wifi_.Connect(config.wifi_ssid, config.wifi_key)) {
+    debug_("Connected");
+    return true;
+  }
+  debug_("Failed to Connect.");
+  return false;
+}
+
+void FireThing::SetPinModes(const Config& config) {
+  pinMode(config.pins.digital_in, INPUT);
+  pinMode(config.pins.digital_out, OUTPUT);
+  pinMode(config.pins.analog_in, INPUT);
+  pinMode(config.pins.analog_out, OUTPUT);
+
+  pinMode(config.pins.config_mode_button, INPUT);
+}
+
+bool FireThing::ReadConfigFromStorage(Config* config) {
+  if (!SPIFFS.begin()) {
+    debug_("Failed to mount FS.");
+    return false;
+  }
+
+  if (!SPIFFS.exists("fthing.cfg")) {
+    debug_("Config not found, using default.");
+    *config = kDefaultConfig;
+  } else {
+    File cfg = SPIFFS.open("fthing.cfg", "r");
+    if (!cfg) {
+      debug_("Failed to open config for read");
+      SPIFFS.end();
+      return false;
+    }
+    config->ReadFromJson(cfg.readString().c_str());
+    debug_("Config read from disk.");
+  }
+
+  SPIFFS.end();
+  return true;
+}
+
+bool FireThing::WriteConfigToStorage(const Config& config) {
+  if (!SPIFFS.begin()) {
+    debug_("Failed to mount FS.");
+    return false;
+  }
+
+  File cfg = SPIFFS.open("fthing.cfg", "w");
+  if (!cfg) {
+    debug_("Failed to open config for write");
+    SPIFFS.end();
+    return false;
+  }
+  config.SerializeToJson(&cfg, [](int){});
+
+  SPIFFS.end();
+  return true;
+}
+
+void FireThing::SetDebugHandler(std::function<void(const char* message)> debug) {
+  debug_ = debug;
+  wifi_.SetDebugHandler(debug);
+  portal_.SetDebugHandler(debug);
+  transcriber_.SetDebugHandler(debug);
+}
+
+}  // namespace thing
diff --git a/src/thing/FireThing.h b/src/thing/FireThing.h
@@ -0,0 +1,38 @@
+#ifndef THING_FIRETHING_H
+#define THING_FIRETHING_H
+
+#include "thing/Config.h"
+#include "thing/WiFiManager.h"
+#include "thing/Transcriber.h"
+#include "thing/Portal.h"
+
+namespace thing {
+
+// Operates the device as a FireThing which manages a connection
+// between several pins and a firebase database. The configuration
+// will be read from and persisted too flash.
+class FireThing {
+ public:
+  FireThing();
+  bool Setup();
+  void Loop();
+
+  void SetDebugHandler(std::function<void(const char* message)> debug);
+
+ private:
+  bool ReadConfigFromStorage(Config* config);
+  bool WriteConfigToStorage(const Config& config);
+
+  bool ConnectToWiFi(const Config& config);
+  void SetPinModes(const Config& config);
+
+  WiFiManager wifi_;
+  Portal portal_;
+  Transcriber transcriber_;
+  std::function<void(const char* message)> debug_;
+};
+
+}  // namespace thing
+
+
+#endif  // THING_FIRETHING_H
diff --git a/src/thing/Portal.cpp b/src/thing/Portal.cpp
@@ -3,16 +3,16 @@
 
 namespace thing {
 
-Portal::Portal(const Config& config)
-    : config_(config),
-      callback_([](const Config&){}),
+Portal::Portal()
+    : callback_([](const Config&){}),
       debug_([](const char*){}) {}
 
 void Portal::SetDebugHandler(std::function<void(const char* message)> handler) {
   debug_ = std::move(handler);
 }
 
-void Portal::Start() {
+void Portal::Start(const Config& config) {
+  config_ = config;
   server_.on("/", [&] () {
     static const PROGMEM char page[] = R"(
       <head>
@@ -109,32 +109,24 @@ void Portal::Start() {
   });
 
   server_.on("/config", [&] () {
-    DynamicJsonBuffer jsonBuffer;
     if (server_.method() == HTTP_GET) {
-      JsonObject& root = jsonBuffer.createObject();
-      root["host"] = config_.host.c_str();
-      root["auth"] = config_.auth.c_str();
-      root["path"] = config_.path.c_str();
-      root["wifi_ssid"] = config_.wifi_ssid.c_str();
-      root["wifi_key"] = config_.wifi_key.c_str();
+      auto client = server_.client();
+      config_.SerializeToJson(&client,
+                              [this](int size) {
+                                server_.setContentLength(size);
+                                server_.send(200, "application/json");
+                              });
 
-      String buffer;
-      root.printTo(buffer);
-      server_.send(200, "application/json", buffer);
       debug_("config retrieved");
     } else if (server_.method() == HTTP_POST) {
+      DynamicJsonBuffer jsonBuffer;
       if (!server_.hasArg("config")) {
         server_.send(500, "text/plain", "Missing config.\r\n");
         debug_("Config updated called without param.");
         return;
       }
       String config = server_.arg("config");
-      JsonObject& root = jsonBuffer.parseObject(config.c_str());
-      config_.host = root["host"].asString();
-      config_.auth = root["auth"].asString();
-      config_.path = root["path"].asString();
-      config_.wifi_ssid = root["wifi_ssid"].asString();
-      config_.wifi_key = root["wifi_key"].asString();
+      config_.ReadFromJson(config.c_str());
       callback_(config_);
       server_.send(200, "text/plain", "");
       debug_("config updated.");
diff --git a/src/thing/Portal.h b/src/thing/Portal.h
@@ -8,9 +8,9 @@ namespace thing {
 
 class Portal {
  public:
-  Portal(const Config& config);
+  Portal();
 
-  void Start();
+  void Start(const Config& config);
   void Loop();
   void NotifyOnUpdate(std::function<void(const Config& config)> cb);
 
diff --git a/src/thing/Transcriber.cpp b/src/thing/Transcriber.cpp
@@ -10,7 +10,9 @@ namespace {
 }  // namespace
 
 
-Transcriber::Transcriber(const Config& config) {
+Transcriber::Transcriber() : debug_([](const char*) {}) {}
+
+void Transcriber::Setup(const Config& config) {
   Init(config);
 }
 
@@ -21,13 +23,12 @@ void Transcriber::UpdateConfig(const Config& config) {
 void Transcriber::Init(const Config& config) {
   path_ = config.path;
   analog_activation_threshold_ = config.analog_activation_threshold;
-  pin_digital_out_ = config.pin_digital_out;
-  pin_digital_in_ = config.pin_digital_in;
-  pin_analog_out_ = config.pin_analog_out;
-  pin_analog_in_ = config.pin_analog_in;
+  pin_digital_out_ = config.pins.digital_out;
+  pin_digital_in_ = config.pins.digital_in;
+  pin_analog_out_ = config.pins.analog_out;
+  pin_analog_in_ = config.pins.analog_in;
 
   fbase_.reset(new Firebase(config.host, config.auth));
-  stream_ = fbase_->streamPtr(path_);
 }
 
 void Transcriber::SetValue(const std::string& path, const std::string& value) {
@@ -38,9 +39,17 @@ void Transcriber::SetValue(const std::string& path, const std::string& value) {
 
 void Transcriber::Loop() {
   if (WiFi.status() != WL_CONNECTED) {
+    connected_ = false;
     return;
   }
 
+  // If first time connecting start stream.
+  if (!connected_) {
+    debug_("Transcriber connected.");
+    stream_ = fbase_->streamPtr(path_);
+    connected_ = true;
+  }
+
   // Read incoming data
   if (stream_->available()) {
     std::string event_str;
@@ -98,4 +107,8 @@ void Transcriber::ProcessIncrementalUpdate(const FirebaseObject& update) {
   }
 }
 
+void Transcriber::SetDebugHandler(std::function<void(const char* message)> debug) {
+  debug_ = debug;
+}
+
 }  // thing
diff --git a/src/thing/Transcriber.h b/src/thing/Transcriber.h
