main.cpp

/* OpenGarage Firmware
 *
 * Main loop
 * Mar 2016 @ OpenGarage.io
 *
 * This file is part of the OpenGarage library
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see
 * <http://www.gnu.org/licenses/>.
 */

 #if defined(SERIAL_DEBUG)
	#define BLYNK_DEBUG
	#define BLYNK_PRINT Serial
#endif

#include <BlynkSimpleEsp8266.h>
#include <DNSServer.h>
#include <PubSubClient.h>
#include <OpenThingsFramework.h>
#include <Request.h>
#include <Response.h>

#include "pitches.h"
#include "OpenGarage.h"
#include "espconnect.h"

OpenGarage og;
OTF::OpenThingsFramework *otf = NULL;
ESP8266WebServer *updateServer = NULL;
DNSServer *dns = NULL;

WidgetLED blynk_door(BLYNK_PIN_DOOR);
WidgetLED blynk_car(BLYNK_PIN_CAR);
WidgetLED blynk_dval(BLYNK_PIN_DVAL);

static Ticker aux_ticker;
static Ticker ip_ticker;
static Ticker restart_ticker;

static WiFiClient wificlient;
static WiFiClient httpclient;
PubSubClient mqttclient(wificlient);
String mqtt_topic;
String mqtt_id;

static String scanned_ssids;
static byte read_cnt = 0;
static uint distance = 0;
static byte sn2_value = 0;
static float tempC = 0;
static float humid = 0;
static byte door_status = DOOR_STATUS_UNKNOWN; //door_status enum
static byte last_door_status = DOOR_STATUS_UNKNOWN;
static byte secplus_door_status = DOOR_STATUS_UNKNOWN;
static byte door_status_hist = 0;
static bool light_status = 0;
static bool lock_status = 0;
static bool obstruction_status = 0;
static uint16_t opening_count = 0;
static int vehicle_status = OG_VEH_ABSENT;
static uint led_blink_ms = LED_FAST_BLINK;
static ulong justopen_timestamp = 0;
static byte curr_mode;
extern bool fullbuffer;
// this is one byte storing the door status histogram
// maximum 8 bits
static ulong start_utc_time = 0;
static ulong curr_utc_time = 0;
static ulong curr_utc_hour= 0;
static HTTPClient http;
static bool light_blink_enabled = true;
// security+ objects
SecPlus1::Garage secplus1_garage(PIN_SW_RX, PIN_SW_TX);
#include "secplus2_identity_store.h"
#include "body_device_key.h"
#include "health_stats.h"
#include "audio_timing.h"
struct BuzzerSink {
	void note(unsigned frequency, unsigned duration) { tone(PIN_BUZZER, frequency, duration); }
	void silence() { noTone(PIN_BUZZER); }
};
static BuzzerSink buzzer;
static og_audio::Warning<BuzzerSink> warning_audio(buzzer);
static og_audio::Melody<BuzzerSink> startup_audio(buzzer);
static bool ip_audio_active=false, setup_reboot_pending=false;
static byte ip_note=0, ip_digit=0;

void cancel_diagnostic_audio() {
	startup_audio.cancel();
	ip_ticker.detach();
	if (ip_audio_active) buzzer.silence();
	ip_audio_active=false; ip_note=ip_digit=0;
}
void start_tune(og_audio::Tune tune) {
	if (!og.alarm && !ip_audio_active) startup_audio.start(millis(),tune);
}
static HealthStats health_stats;
struct LoopMeasurement {
	uint32_t started=micros();
	LoopMeasurement() { health_stats.enter(millis()); }
	~LoopMeasurement() { health_stats.finish(started,micros(),ESP.getFreeHeap()); }
};
static uint32_t secplus2_client_id = 0;
static bool secplus2_identity_ready = false;
static bool identity_restart_pending = false;
SecPlus2::Garage secplus2_garage(0, PIN_SW_RX, PIN_SW_TX);

void do_setup();

void otf_send_html_P(OTF::Response &res, const __FlashStringHelper *content) {
	res.writeStatus(200, F("OK"));
	res.writeHeader(F("Content-Type"), F("text/html"));
	res.writeHeader(F("Access-Control-Allow-Origin"), F("*")); // from esp8266 2.4 this has to be sent explicitly
	res.writeHeader(F("Content-Length"), strlen_P((char *) content));
	res.writeHeader(F("Connection"), F("close"));
	res.writeBodyData(content, strlen_P((char*)content));
	DEBUG_PRINT(strlen_P((char *) content));
	DEBUG_PRINTLN(F(" bytes sent."));
}

void otf_send_compressed_P(OTF::Response& res, const __FlashStringHelper* content, size_t len) {
	res.writeStatus(200, F("OK"));
	res.writeHeader(F("Content-Type"), F("text/html; charset=utf-8"));
	res.writeHeader(F("Access-Control-Allow-Origin"), F("*")); // from esp8266 2.4 this has to be sent explicitly
	res.writeHeader(F("Content-Length"), len);
	res.writeHeader(F("Vary"), F("Accept-Encoding"));
	res.writeHeader(F("Content-Encoding"), F("gzip"));
	res.writeHeader(F("Cache-Control"), F("public, max-age=86400"));
	res.writeHeader(F("Connection"), F("close"));
	res.writeBodyData(content, len);
	DEBUG_PRINT(len);
	DEBUG_PRINTLN(F(" bytes sent."));
}

void otf_send_json(OTF::Response &res, String json) {
	res.writeStatus(200, F("OK"));
	res.writeHeader(F("Content-Type"), F("application/json"));
	res.writeHeader(F("Access-Control-Allow-Origin"), F("*")); // from esp8266 2.4 this has to be sent explicitly
	res.writeHeader(F("Content-Length"), json.length());
	res.writeHeader(F("Connection"), F("close"));
	res.writeBodyData(json.c_str(), json.length());
}

void otf_send_result(OTF::Response &res, byte code, const char *item = NULL) {
	String json = F("{\"result\":");
	json += code;
	if (!item) item = "";
	json += F(",\"item\":\"");
	json += item;
	json += F("\"");
	json += F("}");
	otf_send_json(res, json);
}

void updateserver_send_result(byte code, const char* item = NULL) {
	String json = F("{\"result\":");
	json += code;
	if (!item) item = "";
	json += F(",\"item\":\"");
	json += item;
	json += F("\"");
	json += F("}");
	updateServer->sendHeader("Access-Control-Allow-Origin", "*"); // from esp8266 2.4 this has to be sent explicitly
	updateServer->send(200, "application/json", json);
}

// this is simplified version to check if MQTT / NTP server is valid domain name
bool valid_url(String s) {
	return (s.length()>0 && s[0]!='-' && s.indexOf('.')>0);
}

String ipString;

static void append_age(String &json, uint32_t age) {
	if (age==UINT32_MAX) json += F("-1");
	else json += age;
}

static void append_health_json(String &json) {
	json += F(",\"active_security_protocol\":"); json += og.options[OPTION_SECV].ival;
	json += F(",\"free_heap\":"); json += ESP.getFreeHeap();
	json += F(",\"reset_reason\":\""); json += ESP.getResetReason(); json += F("\"");
	json += F(",\"reset_reason_code\":"); json += ESP.getResetInfoPtr()->reason;
	json += F(",\"uptime_s\":"); json += health_stats.uptime_s();
	json += F(",\"min_free_heap\":");
	if (health_stats.min_heap()==UINT32_MAX) json += ESP.getFreeHeap();
	else json += health_stats.min_heap();
	json += F(",\"max_loop_us\":"); json += health_stats.max_loop_us();
	if (!og.has_swrx) return;
	if (og.options[OPTION_SECV].ival == 1) {
		json += F(",\"secplus1_parity_errors\":"); json += secplus1_garage.get_parity_errors();
		json += F(",\"secplus1_invalid_frames\":"); json += secplus1_garage.get_invalid_frames();
		json += F(",\"secplus1_rx_overflows\":"); json += secplus1_garage.get_overflows();
		json += F(",\"secplus1_tx_deferrals\":"); json += secplus1_garage.get_tx_deferrals();
		json += F(",\"secplus1_expired_commands\":"); json += secplus1_garage.get_expired_commands();
		json += F(",\"secplus1_door_age_ms\":"); append_age(json,secplus1_garage.get_door_age());
		json += F(",\"secplus1_light_lock_age_ms\":"); append_age(json,secplus1_garage.get_light_lock_age());
#ifdef OG_SEC1_DIAGNOSTICS
		const auto &gap=secplus1_garage.diagnostic_gap();
		const auto &gd=gap.diagnostic;
		const auto &td=secplus1_garage.diagnostic;
		json += F(",\"secplus1_diag\":{\"exchanges\":"); json += gd.exchanges;
		json += F(",\"resets\":"); json += gd.resets;
		json += F(",\"bad_latency\":"); json += gd.bad_latency;
		json += F(",\"zero_latency\":"); json += gd.zero_latency;
		json += F(",\"bad_interval\":"); json += gd.bad_interval;
		json += F(",\"last_latency_ms\":"); json += gd.latency;
		json += F(",\"last_interval_ms\":"); json += gd.interval;
		json += F(",\"learned_count\":"); json += gap.learned_count();
		json += F(",\"max_learned_count\":"); json += gd.max_count;
		json += F(",\"minimum_ms\":"); json += gap.learned_minimum();
		json += F(",\"maximum_ms\":"); json += gap.learned_maximum();
		json += F(",\"reply_age_ms\":"); append_age(json,gap.reply_age(millis()));
		json += F(",\"loops\":"); json += td.loops;
		json += F(",\"gap_ready_loops\":"); json += td.gap_ready_loops;
		json += F(",\"last_block\":"); json += td.last_block;
		json += F(",\"blocked\":[");
		for(unsigned i=0;i<9;++i) { if(i) json += ','; json += td.blocked[i]; }
		json += F("]}");
#endif
	} else if (og.options[OPTION_SECV].ival == 2) {
		json += F(",\"secplus2_status_age_ms\":"); append_age(json,secplus2_garage.get_status_age());
		json += F(",\"secplus2_query_failures\":"); json += secplus2_garage.get_query_failures();
		json += F(",\"secplus2_action_write_failures\":"); json += secplus2_garage.get_write_failures();
		json += F(",\"secplus2_tx_deferrals\":"); json += secplus2_garage.get_tx_deferrals();
		json += F(",\"secplus2_expired_commands\":"); json += secplus2_garage.get_expired_commands();
		json += F(",\"secplus2_control_fault\":"); json += secplus2_garage.controls_faulted() ? 1 : 0;
		json += F(",\"secplus2_recovery\":\""); json += secplus2_garage.recovery_status(); json += F("\"");
	}
}

void report_ip() {
	static uint notes[] = {NOTE_C4, NOTE_CS4, NOTE_D4, NOTE_DS4, NOTE_E4, NOTE_F4, NOTE_FS4, NOTE_G4, NOTE_GS4, NOTE_A4};
	if (!ip_audio_active || og.alarm) return;
	byte &note=ip_note, &digit=ip_digit;

	if(digit == ipString.length()) { // play ending note
		og.play_note(NOTE_C6); digit++; note=0;
		ip_ticker.once_ms(1000, report_ip);
		return;
	} else if(digit == ipString.length()+1) { // end
		og.play_note(0); note=0; digit=0;
		ip_audio_active=false;
		return;
	}
	char c = ipString.charAt(digit);
	if (c==' ') {
		og.play_note(0); digit++; note=0;
		ip_ticker.once_ms(1000, report_ip);
	} else if (c=='.') {
		og.play_note(NOTE_C5);
		digit++; note=0;
		ip_ticker.once_ms(500, report_ip);
	} else if (c>='0' && c<='9') {
		byte idx=9; // '0' maps to index 9;
		if(c>='1') idx=c-'1';
		if(note==idx+1) {
			og.play_note(0); note++;
			ip_ticker.once_ms(1000, report_ip);
		} else if(note==idx+2) {
			digit++; note=0;
			ip_ticker.once_ms(100, report_ip);
		} else {
			og.play_note(notes[note]);
			note++;
			ip_ticker.once_ms(500, report_ip);
		}
	}
}

void restart_in(uint32_t ms) {
	if(og.state != OG_STATE_WAIT_RESTART) {
		og.state = OG_STATE_WAIT_RESTART;
		DEBUG_PRINTLN(F("Prepare to restart..."));
		restart_ticker.once_ms(ms, og.restart);
	}
}

// Both the provisioning poll and the normal loop can notice association first.
// Persist once, play the complete success tune, then restart to enter STA mode.
void complete_ap_setup() {
	if (setup_reboot_pending || og.options[OPTION_MOD].ival==OG_MOD_STA) return;
	og.options[OPTION_MOD].ival=OG_MOD_STA;
	og.options_save();
	setup_reboot_pending=true;
	start_tune(og_audio::Tune::SETUP_SUCCESS);
}

void on_home(const OTF::Request &req, OTF::Response &res) {
	if(curr_mode == OG_MOD_AP) {
		otf_send_compressed_P(res, (const __FlashStringHelper*)ap_home_html_gz, ap_home_html_gz_len);
	} else {
	otf_send_compressed_P(res, (const __FlashStringHelper*)sta_home_html_gz, sta_home_html_gz_len);
	}
}

void on_sta_view_options(const OTF::Request &req, OTF::Response &res) {
	otf_send_compressed_P(res, (const __FlashStringHelper*)sta_options_html_gz, sta_options_html_gz_len);
}

void on_sta_view_logs(const OTF::Request &req, OTF::Response &res) {
	otf_send_compressed_P(res, (const __FlashStringHelper*)sta_logs_html_gz, sta_logs_html_gz_len);
}

char dec2hexchar(byte dec) {
	if(dec<10) return '0'+dec;
	else return 'A'+(dec-10);
}

String get_mac() {
	static String hex = "";
	if(!hex.length()) {
		byte mac[6];
		WiFi.macAddress(mac);

		for(byte i=0;i<6;i++) {
			hex += dec2hexchar((mac[i]>>4)&0x0F);
			hex += dec2hexchar(mac[i]&0x0F);
			if(i!=5) hex += ":";
		}
	}
	return hex;
}

String get_ap_ssid() {
	static String ap_ssid = "";
	if(!ap_ssid.length()) {
		byte mac[6];
		WiFi.macAddress(mac);
		ap_ssid = "OG_";
		for(byte i=3;i<6;i++) {
			ap_ssid += dec2hexchar((mac[i]>>4)&0x0F);
			ap_ssid += dec2hexchar(mac[i]&0x0F);
		}
	}
	return ap_ssid;
}

String get_ip() {
	IPAddress _ip = WiFi.localIP();
	String ip = String(_ip[0]);
	ip += ".";
	ip += _ip[1];
	ip += ".";
	ip += _ip[2];
	ip += ".";
	ip += _ip[3];
	return ip;
}

void sta_controller_fill_json(String& json) {
	json.reserve(STRING_RESERVE_SIZE);
	json = "";
	json += F("{\"dist\":");
	json += distance;
	if(og.options[OPTION_SN2].ival>OG_SN2_NONE) {
		json += F(",\"sn2\":");
		json += sn2_value;
	}
	json += F(",\"secv\":");
	json += og.options[OPTION_SECV].ival;
	json += F(",\"door\":");
	json += door_status;
	json += F(",\"vehicle\":");
	json += vehicle_status;
	json += F(",\"rcnt\":");
	json += read_cnt;
json += F(",\"fwv\":");
	json += og.options[OPTION_FWV].ival;
	json += F(",\"has_swrx\":");
	json += og.has_swrx;
	if(og.has_swrx) {
		if(og.options[OPTION_SECV].ival>=1) {
			json += F(",\"light\":");
			json += light_status;
			json += F(",\"lock\":");
			json += lock_status;
			json += F(",\"obstruct\":");
			json += obstruction_status;
			if(og.options[OPTION_SECV].ival==2) {
				const bool valid=secplus2_garage.status_valid();
				json += F(",\"door_valid\":"); json += valid ? 1 : 0;
				json += F(",\"light_lock_valid\":"); json += valid ? 1 : 0;
				json += F(",\"obstruct_valid\":"); json += valid ? 1 : 0;
				json += F(",\"recovery_status\":\"");
				json += secplus2_garage.recovery_status(); json += F("\"");
				json += F(",\"control_fault\":"); json += secplus2_garage.controls_faulted() ? 1 : 0;
				json += F(",\"nopenings\":");
				json += opening_count;
			}
			if(og.options[OPTION_SECV].ival==1) {
				json += F(",\"door_valid\":");
				json += secplus1_garage.door_valid() ? 1 : 0;
				json += F(",\"light_lock_valid\":");
				json += secplus1_garage.light_lock_valid() ? 1 : 0;
				json += F(",\"obstruct_valid\":");
				json += secplus1_garage.obstruction_valid() ? 1 : 0;
				json += F(",\"panel_status\":\"");
				json += secplus1_garage.get_panel_description();
				json += F("\",\"command_status\":\"");
				json += secplus1_garage.get_action_result();
				json += F("\"");
				json += F(",\"pemu\":");
				json += secplus1_garage.get_panel_emu_status();
			}
		}
	}
	json += F(",\"name\":\"");
	json += og.options[OPTION_NAME].sval;
	json += F("\",\"mac\":\"");
	json += get_mac();
	json += F("\",\"cid\":");
	json += ESP.getChipId();
	json += F(",\"rssi\":");
	json += (int16_t)WiFi.RSSI();
	json += F(",\"cld\":");
	byte cld = og.options[OPTION_CLD].ival;
	json += cld;
	if(cld>CLOUD_NONE) {
		json += F(",\"clds\":");
		if(cld==CLOUD_BLYNK) json += (Blynk.connected()?1:0);
		else if(cld==CLOUD_OTC) json += (otf->getCloudStatus());
		else json += "0";
	}
	if(og.options[OPTION_TSN].ival) {
		json += F(",\"temp\":");
		json += tempC;
		json += F(",\"humid\":");
		json += humid;
	}
	json += F("}");
}

void on_sta_controller(const OTF::Request &req, OTF::Response &res) {
	if(curr_mode == OG_MOD_AP) return;
	String json;
	sta_controller_fill_json(json);
	otf_send_json(res, json);
}

static void append_debug_details(const OTF::Request &req, String &json) {
	const char *verbose = req.getQueryParameter("verbose");
	if (!verbose || strcmp(verbose, "1") != 0) return;
	if (og.has_swrx && og.options[OPTION_SECV].ival == 2) {
		json += F(",\"secplus2_client_id\":\"0x");
		json += String(secplus2_client_id, HEX);
		json += F("\"");
		json += F(",\"secplus2_identity_ready\":");
		json += secplus2_identity_ready ? F("true") : F("false");
	}
	append_health_json(json);
}

void on_sta_debug(const OTF::Request &req, OTF::Response &res) {
	String json = "";
	json.reserve(STRING_RESERVE_SIZE);
	json += F("{");
	json += F("\"rcnt\":");
	json += read_cnt;
	json += F(",\"fwv\":");
	json += og.options[OPTION_FWV].ival;
	json += F(",\"name\":\"");
	json += og.options[OPTION_NAME].sval;
	json += F("\",\"mac\":\"");
	json += get_mac();
	json += F("\",\"mqtt_topic\":\"");
	json += mqtt_topic;
	json += F("\",\"devip\":\"");
	json += WiFi.localIP().toString();
	json += F("\",\"cid\":");
	json += ESP.getChipId();
	append_debug_details(req, json);
	json += F(",\"rssi\":");
	json += (int16_t)WiFi.RSSI();
	json += F(",\"bssid\":\"");
	json += WiFi.BSSIDstr();
	json += F("\",\"build\":\"");
	json += (F(__DATE__));
	json += F("\",\"Freeheap\":");
	json += (uint16_t)ESP.getFreeHeap();
	json += F(",\"flash_size\":");
	json += (uint32_t)ESP.getFlashChipRealSize();
	json += F(",\"has_swrx\":");
	json += og.has_swrx;
	json += F("}");
	otf_send_json(res, json);
}

void sta_logs_fill_json(String& json, OTF::Response &res) {
	json = "";
	json.reserve(2048); // reserve capacity to reduce the overhead of String's +=
	json += F("{\"name\":\"");
	json += og.options[OPTION_NAME].sval;
	json += F("\",\"starttime\":");
	json += start_utc_time;
	json += F(",\"time\":");
	json += curr_utc_time;
	json += F(",\"ncols\":");
	json += og.options[OPTION_SN2].ival>OG_SN2_NONE ? 4 : 3;
	json += F(",\"logs\":[");
	if(!og.read_log_start()) {
		json += F("]}");
		return;
	}
	LogStruct l;
	for(uint i=0;i<og.options[OPTION_LSZ].ival;i++) {
		if(!og.read_log_next(l)) break;
		if(!l.tstamp) continue;
		json += F("[");
		json += l.tstamp;
		json += F(",");
		json += l.status;
		json += F(",");
		json += l.dist;
		if(og.options[OPTION_SN2].ival>OG_SN2_NONE) {
		  json += F(",");
		  json += l.sn2;
		}
		json += F("],");
	}
	og.read_log_end();
	json.remove(json.length()-1); // remove the extra ,
	json += F("]}");
}

void on_sta_logs(const OTF::Request &req, OTF::Response &res) {
	if(curr_mode == OG_MOD_AP) return;
	String json;
	sta_logs_fill_json(json, res);
	otf_send_json(res, json);
}

bool verify_device_key(const OTF::Request &req) {
	if(req.isCloudRequest()){ // no need for dkey if this is coming from cloud connection
		return true;
	}
	const char *dkey = req.getQueryParameter("dkey");
	if(dkey != NULL && strcmp(dkey, og.options[OPTION_DKEY].sval.c_str()) == 0)
		return true;
	return false;
}

void on_reset_all(const OTF::Request &req, OTF::Response &res){
	if(!verify_device_key(req)) {
		otf_send_result(res, HTML_UNAUTHORIZED, nullptr);
		return;
	}

	og.state = OG_STATE_RESET;
	otf_send_result(res, HTML_SUCCESS, nullptr);
}

// POST only. Keep credentials out of URLs and require a key even over OTC.
void on_regenerate_secplus2_id(const OTF::Request &req, OTF::Response &res) {
	if (!body_device_key_matches(req.getBody(), req.getBodyLength(), og.options[OPTION_DKEY].sval.c_str())) {
		otf_send_result(res, HTML_UNAUTHORIZED, nullptr);
		return;
	}
	if (og.options[OPTION_SECV].ival != 2) {
		otf_send_json(res, F("{\"result\":0,\"message\":\"Select and save Security+ 2.0 first.\"}"));
		return;
	}
	if (identity_restart_pending || og.state != OG_STATE_CONNECTED || og.alarm || secplus2_garage.command_pending()) {
		otf_send_json(res, F("{\"result\":0,\"message\":\"Device busy. Wait for the pending action to finish, then retry.\"}"));
		return;
	}
	// No pending actuation: stop the old identity before touching storage. Inhibit
	// all further work until reboot, including on a failed/uncertain flash write.
	identity_restart_pending = true;
	secplus2_garage.stop();
	Secplus2IdentityStore store;
	uint32_t replacement = 0;
	const bool saved = og_identity::load(store, []() -> uint32_t { return ESP.random(); }, true, replacement);
	if (saved) {
		String json = F("{\"result\":1,\"client_id\":\"0x");
		json += String(replacement, HEX);
		json += F("\",\"message\":\"New client ID saved. Restarting; WiFi and other settings are unchanged.\"}");
		otf_send_json(res, json);
	} else {
		otf_send_json(res, F("{\"result\":0,\"message\":\"Could not verify the new ID. Restarting; check identity diagnostics before using controls.\"}"));
	}
	restart_in(1000);
}

void on_clear_log(const OTF::Request &req, OTF::Response &res) {
	if(!verify_device_key(req)) {
		otf_send_result(res, HTML_UNAUTHORIZED, nullptr);
		return;
	}
	og.log_reset();
	otf_send_result(res, HTML_SUCCESS, nullptr);
}

void secplus_update_door(SecPlusCommon::DoorStatus door_state) {
	switch (door_state) {
		case SecPlusCommon::DoorStatus::OPEN:
			secplus_door_status = DOOR_STATUS_OPEN;
			break;
		case SecPlusCommon::DoorStatus::CLOSED:
			secplus_door_status = DOOR_STATUS_CLOSED;
			break;
		case SecPlusCommon::DoorStatus::STOPPED:
			secplus_door_status = DOOR_STATUS_STOPPED;
			break;
		case SecPlusCommon::DoorStatus::OPENING:
			secplus_door_status = DOOR_STATUS_OPENING;
			break;
		case SecPlusCommon::DoorStatus::CLOSING:
			secplus_door_status = DOOR_STATUS_CLOSING;
			break;
		default:
			secplus_door_status = DOOR_STATUS_UNKNOWN;
	}
}

void secplus1_state_callback(SecPlus1::state_struct_t state) {
	secplus_update_door(state.door_state);
	light_status = state.light_state;
	lock_status = state.lock_state;
	obstruction_status = state.obstruction_state;
}

void secplus2_state_callback(SecPlus2::state_struct_t state) {
	secplus_update_door(state.door_state);
	light_status = state.light_state;
	lock_status = state.lock_state;
	obstruction_status = state.obstruction_state;
	opening_count = state.openings;
}

int run_auto_detect() {
	secplus2_garage.stop();
	secplus1_garage.stop(); // finish any possibly dispatched Sec+ 1.0 release tail
	// Try Sec+ 2.0 first
	if (secplus2_garage.detect()) {
		return 2;
	}
	// If that fails, try Sec+ 1.0
	if (secplus1_garage.detect()) {
		return 1;
	}
	return 0; // Detected nothing
}

void on_auto_detect(const OTF::Request &req, OTF::Response &res) {
	int detected_version = run_auto_detect();
	String json = "{\"version\": " + String(detected_version) + "}";
	otf_send_json(res, json);
}

void performDoorAction(uint8_t action, bool force_alarm_off = false) {
	if (identity_restart_pending) return;
	// Check if the requested action is valid based on the current door state
	bool isValidAction = false;
	if((og.options[OPTION_SECV].ival == 2) || // For Sec+ 2.0, open/close commands are always valid
		(action == ACTION_TOGGLE) || // toggle action is always valid
		(action == ACTION_OPEN && (door_status == DOOR_STATUS_CLOSED || door_status == DOOR_STATUS_CLOSING)) || // can only open from CLOSED or CLOSING states
		(action == ACTION_CLOSE && (door_status == DOOR_STATUS_OPEN || door_status == DOOR_STATUS_STOPPED))) {
			isValidAction = true;
	}

	if (!isValidAction) {
		DEBUG_PRINTLN(F("Requested command not valid, or door already in requested state"));
		return;
	}
	cancel_diagnostic_audio();

	// This is the core logic for deciding whether to trigger the alarm or the door directly.
	bool shouldTriggerAlarm = true;
	if (force_alarm_off || // override is on
		(!og.options[OPTION_ALM].ival) || // alarm not enabled
		(og.options[OPTION_AOO].ival && (door_status==DOOR_STATUS_CLOSED || door_status==DOOR_STATUS_CLOSING || door_status==DOOR_STATUS_OPENING))) { shouldTriggerAlarm = false;
	}

	if (shouldTriggerAlarm) { // if using alarm
		if (og.options[OPTION_SECV].ival == 2) {
			og.set_alarm(0, action);
		} else {
			og.set_alarm();
		}
		return;
	}

	// no alarm
	switch (og.options[OPTION_SECV].ival) {
		case 2: // SecPlus 2.0
			if (action == ACTION_OPEN) secplus2_garage.open_door();
			else if (action == ACTION_CLOSE) secplus2_garage.close_door();
			else secplus2_garage.toggle_door();
			break;
		case 1: // SecPlus 1.0
			secplus1_garage.toggle_door();
			break;
		default: // No SecPlus (standard relay)
			og.click_relay();
			break;
	}
}

void performLightAction(uint8_t action) {
	switch(action) {
		case ACTION_TOGGLE:
			switch (og.options[OPTION_SECV].ival) {
				case 2: // SecPlus 2
					secplus2_garage.toggle_light();
					break;
				case 1: // SecPlus 1
					secplus1_garage.toggle_light();
					break;
				default: // No secplus
					DEBUG_PRINTLN(F("Command request not valid, light requires secplus"));
			}
			break;
		case ACTION_OPEN: // TODO
		case ACTION_CLOSE:
			break;
	}
}

void performLockAction(uint8_t action) {
	switch(action) {
		case ACTION_TOGGLE:
			switch (og.options[OPTION_SECV].ival) {
				case 2: // SecPlus 2
					secplus2_garage.toggle_lock();
					break;
				case 1: // SecPlus 1
					secplus1_garage.toggle_lock();
					break;
				default: // No secplus
					DEBUG_PRINTLN(F("Command request not valid, light requires secplus"));
			}
			break;
		case ACTION_OPEN: // TODO
		case ACTION_CLOSE:
			break;
	}
}
void sta_change_controller_main(const OTF::Request &req, OTF::Response &res) {
	if(curr_mode == OG_MOD_AP) return;

	if(!verify_device_key(req)) {
		otf_send_result(res, HTML_UNAUTHORIZED, nullptr);
		return;
	}

	uint8_t action = 255;
	if((bool)req.getQueryParameter("click")) { action = ACTION_TOGGLE; }
	else if((bool)req.getQueryParameter("close")) { action = ACTION_CLOSE; }
	else if((bool)req.getQueryParameter("open")) { action = ACTION_OPEN; }

	char* light = req.getQueryParameter("light");
	char* lock = req.getQueryParameter("lock");

	if(action < 255) {
		otf_send_result(res, HTML_SUCCESS, nullptr);
		performDoorAction(action);
		return;
	}

	if(light) {
		otf_send_result(res, HTML_SUCCESS, nullptr);
		if(strcmp(light, "toggle")==0) {
			performLightAction(ACTION_TOGGLE);
		}
		return;
	}

	if(lock) {
		otf_send_result(res, HTML_SUCCESS, nullptr);
		if(strcmp(lock, "toggle")==0) {
			performLockAction(ACTION_TOGGLE);
		}
		return;
	}

	if(req.getQueryParameter("reboot") != NULL) {
		otf_send_result(res, HTML_SUCCESS, nullptr);
		restart_in(1000);
	} else if(req.getQueryParameter("apmode") != NULL) {
		otf_send_result(res, HTML_SUCCESS, nullptr);
		og.reset_to_ap();
	} else {
		otf_send_result(res, HTML_NOT_PERMITTED, nullptr);
	}
}

void on_sta_change_controller(const OTF::Request &req, OTF::Response &res) {
	sta_change_controller_main(req, res);
}

void sta_change_options_main(const OTF::Request &req, OTF::Response &res) {
	if(curr_mode == OG_MOD_AP) return;

	if(!verify_device_key(req)) {
		otf_send_result(res, HTML_UNAUTHORIZED, nullptr);
		return;
	}

	byte i;
	OptionStruct *o = og.options;

	byte usi = 0;
	char *pem_value = req.getQueryParameter("pem");
	if (pem_value != NULL) {
		const char *requested_secv = req.getQueryParameter("secv");
		const bool secplus1_selected = requested_secv ? strcmp(requested_secv, "1") == 0 : og.options[OPTION_SECV].ival == 1;
		if (!og.has_swrx || !secplus1_selected ||
			(strcmp(pem_value, "0") != 0 && strcmp(pem_value, "1") != 0)) {
			otf_send_result(res, HTML_DATA_OUTOFBOUND, "pem");
			return;
		}
	}
	// FIRST ROUND: check option validity
	// do not save option values yet
	for(i=0;i<NUM_OPTIONS;i++,o++) {
		const char *key = o->name.c_str();
		// these options cannot be modified here
		if(i==OPTION_FWV || i==OPTION_MOD  || i==OPTION_SSID ||
			i==OPTION_PASS || i==OPTION_DKEY)
			continue;

		if(o->max) {  // integer options
			char *sval = req.getQueryParameter(key);
			if(sval != NULL) {
				uint ival = String(sval).toInt();
				if(ival>o->max) {	// check max limit
					otf_send_result(res, HTML_DATA_OUTOFBOUND, key);
					return;
				}
				// check min limit
				if(i==OPTION_DRI && ival < 50) {
					otf_send_result(res, HTML_DATA_OUTOFBOUND, key);
					return;
				}
				if(i==OPTION_RIV && ival < 1) {
					otf_send_result(res, HTML_DATA_OUTOFBOUND, key);
					return;
				}
				if(i==OPTION_LSZ && ival < 20) {
					// minimal log size is 20
					otf_send_result(res, HTML_DATA_OUTOFBOUND, key);
					return;
				}
				if(i==OPTION_CDT && ival < 50) {
					// click delay time should be at least 50 ms
					otf_send_result(res, HTML_DATA_OUTOFBOUND, key);
					return;
				}
				if(i==OPTION_USI && ival==1) {
					// mark device IP and gateway IP change
					usi = 1;
				}
			}
		}
	}

	// Check device IP and gateway IP changes
	const char* _dvip = "dvip";
	const char* _gwip = "gwip";
	const char* _subn = "subn";
	const char* _dns1 = "dns1";

	String dvip = req.getQueryParameter(_dvip);
	String gwip = req.getQueryParameter(_gwip);
	String subn = req.getQueryParameter(_subn);
	String dns1 = req.getQueryParameter(_dns1);

	if(usi) {
		if(dvip != NULL) {
			if(gwip != NULL) {
				// check validity of IP address
				IPAddress ip;
				if(!ip.fromString(dvip)) { otf_send_result(res, HTML_DATA_FORMATERROR, _dvip); return;}
				if(!ip.fromString(gwip)) { otf_send_result(res, HTML_DATA_FORMATERROR, _gwip); return;}
				if(subn != NULL) {
					if(!ip.fromString(subn)) {
						otf_send_result(res, HTML_DATA_FORMATERROR, _subn);
						return;
					}
				}
				if(dns1 != NULL) {
					if(!ip.fromString(dns1)) {
						otf_send_result(res, HTML_DATA_FORMATERROR, _dns1);
						return;
					}
				}
			} else {
				otf_send_result(res, HTML_DATA_MISSING, _gwip);
				return;
			}
		} else {
			otf_send_result(res, HTML_DATA_MISSING, _dvip);
			return;
		}
	}
	// Check device key change
	const char* _nkey = "nkey";
	const char* _ckey = "ckey";

	char* nkey = req.getQueryParameter(_nkey);
	char* ckey = req.getQueryParameter(_ckey);

	if(nkey != NULL) {
		if(ckey != NULL) {
			if(strcmp(nkey,ckey)!=0) {
				otf_send_result(res, HTML_MISMATCH, _ckey);
				return;
			}
		} else {
			otf_send_result(res, HTML_DATA_MISSING, _ckey);
			return;
		}
	}

	// SECOND ROUND: change option values
	uint old_secv = og.options[OPTION_SECV].ival;
	uint old_pem = og.options[OPTION_PEM].ival;
	o = og.options;
	for(i=0;i<NUM_OPTIONS;i++,o++) {
		const char *key = o->name.c_str();
		// these options cannot be modified here
		if(i==OPTION_FWV || i==OPTION_MOD  || i==OPTION_SSID ||
			i==OPTION_PASS || i==OPTION_DKEY)
			continue;

		char *sval = req.getQueryParameter(key);
		if(sval != NULL) {
			if (o->max) {  // integer options
				uint ival = String(sval).toInt();
				o->ival = ival;
			} else {
				o->sval = String(sval);
			}
		}
	}

	if(usi) {
		og.options[OPTION_DVIP].sval = dvip;
		og.options[OPTION_GWIP].sval = gwip;
		if(subn != NULL) {
			og.options[OPTION_SUBN].sval = subn;
		}
		if(dns1 != NULL) {
			og.options[OPTION_DNS1].sval = dns1;
		}
	}

	if(nkey != NULL) {
			og.options[OPTION_DKEY].sval = nkey;
	}

	og.options_save();

	uint new_secv = og.options[OPTION_SECV].ival;
	secplus1_garage.set_panel_emulation_disabled(og.options[OPTION_PEM].ival != 0);
	if(old_secv != new_secv) { // sec+ version changed
		if (old_secv == 2) secplus2_garage.stop();
		if (old_secv == 1) secplus1_garage.stop();
		switch(new_secv) {
			case 2:
				secplus2_garage.begin();
				secplus2_garage.reset_state();
				secplus_door_status = DOOR_STATUS_UNKNOWN;
				secplus2_garage.enable_callback(secplus2_state_callback);
				break;
			case 1:
				secplus1_garage.begin();
				secplus1_garage.reset_state();
				secplus_door_status = DOOR_STATUS_UNKNOWN;
				secplus1_garage.enable_callback(secplus1_state_callback);
				break;
		}
	} else if (new_secv == 1 && old_pem != og.options[OPTION_PEM].ival) {
		secplus1_garage.reset_state();
		secplus_door_status = DOOR_STATUS_UNKNOWN;
	}

	otf_send_result(res, HTML_SUCCESS, nullptr);
}

void on_sta_change_options(const OTF::Request &req, OTF::Response &res) {
	sta_change_options_main(req, res);
}

void sta_options_fill_json(String& json) {
	json.reserve(STRING_RESERVE_SIZE*2); // reserve capacity to reduce the overhead of String's +=
	json = "{";
	OptionStruct *o = og.options;
	for(byte i=0;i<NUM_OPTIONS;i++,o++) {
		if(!o->max) {
			if(i==OPTION_PASS || i==OPTION_DKEY || i==OPTION_MQPW) { // do not output password or device key or MQTT password
				continue;
			} else {
				json += F("\"");
				json += o->name;
				json += F("\":");
				json += F("\"");
				// fill in default string values for certain options
				if(o->sval.length()==0) {
					switch(i) {
					case OPTION_MQTP:
						json += og.options[OPTION_NAME].sval;
						break;
					case OPTION_HOST:
						json += get_ap_ssid();
						break;
					//case OPTION_NTP1: // leave NPT1 empty if using default
					//json += DEFAULT_NTP1;
					//break;
					}
				} else {
					json += o->sval;
				}
				json += F("\"");
				json += ",";
			}
		} else {  // if this is a int option
			json += F("\"");
			json += o->name;
			json += F("\":");
			json += o->ival;
			json += ",";
		}
	}
	// append has_swrx variable
	json += F("\"has_swrx\":");
	json += og.has_swrx;
	json += F(",\"s2id\":\"");
	if (secplus2_identity_ready) {
		json += F("0x");
		json += String(secplus2_client_id, HEX);
	} else {
		json += F("Unavailable");
	}
	json += F("\"");
	json += F("}");
}

void on_sta_options(const OTF::Request &req, OTF::Response &res) {
	if(curr_mode == OG_MOD_AP) return;
	String json;
	sta_options_fill_json(json);
	otf_send_json(res, json);
}

void on_ap_scan(const OTF::Request &req, OTF::Response &res) {
	if(curr_mode == OG_MOD_STA) return;
	otf_send_json(res, scanned_ssids);
}

void on_ap_change_config(const OTF::Request &req, OTF::Response &res) {
	if(curr_mode == OG_MOD_STA) return;
	char *ssid = req.getQueryParameter("ssid");
	if(ssid!=NULL&&strlen(ssid)!=0) {
		og.options[OPTION_SSID].sval = ssid;
		og.options[OPTION_PASS].sval = req.getQueryParameter("pass");
		og.options[OPTION_HOST].sval = req.getQueryParameter("host");
		// if cloud token is provided, save it
		char *cld = req.getQueryParameter("cld");
		char *auth = req.getQueryParameter("auth");
		if(cld!=NULL&&strlen(cld)!=0&&auth!=NULL&&strlen(auth)!=0) {
			if(strcmp(cld, "blynk")==0 || strcmp(cld, "otc")==0) {
				char *bdmn = req.getQueryParameter("bdmn");
				char *bprt = req.getQueryParameter("bprt");
				if(strcmp(cld, "blynk")==0) {
					og.options[OPTION_BDMN].sval=(bdmn==NULL||strlen(bdmn)==0)?DEFAULT_BLYNK_DMN:bdmn;
					og.options[OPTION_BPRT].ival=(bprt==NULL||strlen(bprt)==0)?DEFAULT_BLYNK_PRT:String(bprt).toInt();
					og.options[OPTION_CLD].ival = CLOUD_BLYNK;
				} else {
					og.options[OPTION_BDMN].sval=(bdmn==NULL||strlen(bdmn)==0)?DEFAULT_OTC_DMN:bdmn;
					og.options[OPTION_BPRT].ival=(bprt==NULL||strlen(bprt)==0)?DEFAULT_OTC_PRT:String(bprt).toInt();
					og.options[OPTION_CLD].ival = CLOUD_OTC;
				}
				og.options[OPTION_AUTH].sval = auth;
				og.options_save();
				DEBUG_PRINTLN(og.options[OPTION_CLD].ival);
				DEBUG_PRINTLN(og.options[OPTION_AUTH].sval);
				DEBUG_PRINTLN(og.options[OPTION_BDMN].sval);
				DEBUG_PRINTLN(og.options[OPTION_BPRT].ival);
			} else {
				otf_send_result(res, HTML_DATA_OUTOFBOUND, "cld");
				return;
			}
		}
		// if secplus is provided
		char *secv = req.getQueryParameter("secv");
		if(og.has_swrx && secv != NULL && strlen(secv)!=0) {
			uint8_t v = String(secv).toInt();
			if(v>2) v=2;
			og.options[OPTION_SECV].ival=v;
		}
		otf_send_result(res, HTML_SUCCESS, nullptr);
		og.state = OG_STATE_TRY_CONNECT;
	} else {
		otf_send_result(res, HTML_DATA_MISSING, "ssid");
	}
}

void on_ap_try_connect(const OTF::Request &req, OTF::Response &res) {
	if(curr_mode == OG_MOD_STA) return;
	String json = "{";
	json += F("\"ip\":");
	json += (WiFi.status() == WL_CONNECTED) ? (uint32_t)WiFi.localIP() : 0;
	json += F("}");
	otf_send_json(res, json);
	if(WiFi.status() == WL_CONNECTED && WiFi.localIP()) {
		DEBUG_PRINTLN(F("IP received by client, restart."));
		complete_ap_setup();
	}
}

void on_ap_debug(const OTF::Request &req, OTF::Response &res) {
	String json = "";
	json += F("{");
	json += F("\"dist\":");
	json += og.read_distance();
	json += F(",\"fwv\":");
	json += og.options[OPTION_FWV].ival;
	json += F(",\"has_swrx\":");
	json += og.has_swrx;
	append_debug_details(req, json);
	json += F("}");
	otf_send_json(res, json);
}

// MQTT callback to read "Button" requests
void mqtt_callback(char* topic, byte* payload, unsigned int length) {
	payload[length]=0;
	String Payload((char*)payload);
	String Topic(topic);

	//Accept button on any topic for backwards compat with existing code - use IN messages below if possible
	if (Payload=="Button") {
		DEBUG_PRINTLN(F("MQTT Button request received, change door state"));
		performDoorAction(ACTION_TOGGLE);
		return;
	}

	//Accept click for consistency with api, open and close should be used instead, use IN topic if possible
	if (Topic==(mqtt_topic+"/IN/STATE")){
		DEBUG_PRINT(F("MQTT IN Message detected, check data for action, Data:"));
		DEBUG_PRINTLN(Payload);
		if(Payload == "click")      { performDoorAction(ACTION_TOGGLE); }
		else if(Payload == "close") { performDoorAction(ACTION_CLOSE); }
		else if(Payload == "open")  { performDoorAction(ACTION_OPEN); }
		else if(Payload == "togglelight") performLightAction(ACTION_TOGGLE);
		else if(Payload == "togglelock") performLockAction(ACTION_TOGGLE);
		else {
			DEBUG_PRINT(F("Payload command not recognized"));
		}
		return;
	}
}

void do_setup() {
	Serial.begin(115200);
	DEBUG_PRINTLN("started.");
	if(otf) {
		delete otf;
		otf = NULL;
	}
	if(updateServer) {
		delete updateServer;
		updateServer = NULL;
	}
	WiFi.persistent(false); // turn off persistent, fixing flash crashing issue
	og.begin();
	Secplus2IdentityStore identity_store;
	secplus2_identity_ready = og_identity::load(identity_store,
		[]() -> uint32_t { return ESP.random(); },
		!FILESYS.exists(CONFIG_FNAME), secplus2_client_id);
	if (secplus2_identity_ready) {
		secplus2_identity_ready = secplus2_garage.set_client_id(secplus2_client_id);
	}
	Serial.print(F("Security+ 2.0 client ID: 0x"));
	Serial.println(secplus2_client_id, HEX);
	if (!secplus2_identity_ready) Serial.println(F("Security+ 2.0 disabled: identity storage unavailable or invalid"));
	og.options_setup();
	secplus1_garage.set_panel_emulation_disabled(og.options[OPTION_PEM].ival != 0);
	og.init_sensors();
	curr_mode = og.get_mode();

	// initialize secplus objects and enable callbacks
	switch(og.options[OPTION_SECV].ival) {
		case 2:
			secplus2_garage.begin();
			secplus2_garage.reset_state();
			secplus2_garage.enable_callback(secplus2_state_callback);
			break;
		case 1:
			secplus1_garage.begin();
			secplus1_garage.reset_state();
			secplus1_garage.enable_callback(secplus1_state_callback);
			break;
	}

	if(!otf) {
		const String otfDeviceKey = og.options[OPTION_AUTH].sval;

		if((og.options[OPTION_CLD].ival==CLOUD_OTC) && (otfDeviceKey.length() >= 32)) {
			// Initialize with remote connection if a device key was specified.
			otf = new OTF::OpenThingsFramework(og.options[OPTION_HTP].ival, og.options[OPTION_BDMN].sval, og.options[OPTION_BPRT].ival, otfDeviceKey, false);
			DEBUG_PRINTLN(F("Started OTF with remote connection"));
		} else {
			// Initialize just the local server if no device key was specified.
			otf = new OTF::OpenThingsFramework(og.options[OPTION_HTP].ival);
			DEBUG_PRINTLN(F("Started OTF with just local connection"));
		}
		if(curr_mode == OG_MOD_AP) dns = new DNSServer();
		DEBUG_PRINT(F("server started @ "));
		DEBUG_PRINTLN(og.options[OPTION_HTP].ival);
	}
	if(!updateServer) {
		updateServer = new ESP8266WebServer(8080);
		DEBUG_PRINT(F("update server started"));
	}
	led_blink_ms = LED_FAST_BLINK;
}

void process_ui() {
	// process button
	static ulong button_down_time = 0;
	if(og.get_button() == LOW) {
		if(!button_down_time) {
			button_down_time = millis();
		} else {
			ulong curr = millis();
			long diff = (long)(curr - button_down_time);
			if(diff > BUTTON_FACRESET_TIMEOUT) {
				led_blink_ms = 0;
				og.set_led(LOW);
			} else if(diff > BUTTON_APRESET_TIMEOUT) {
				led_blink_ms = 0;
				og.set_led(HIGH);
			}
		}
	} else {
		if (button_down_time > 0) {
			ulong curr = millis();
			long diff = (long)(curr - button_down_time);
			if(diff > BUTTON_FACRESET_TIMEOUT) {
				og.state = OG_STATE_RESET;
			} else if(diff > BUTTON_APRESET_TIMEOUT) {
				og.reset_to_ap();
			} else if(diff > BUTTON_REPORTIP_TIMEOUT) {
				// report IP
				if (!og.alarm) {
					cancel_diagnostic_audio();
					ipString = get_ip();
					ipString.replace(".", ". ");
					ip_audio_active=true;
					report_ip();
				}
			} else if(curr > button_down_time + 50) {
				performDoorAction(ACTION_TOGGLE, true); // no alarm since manual operation
			}
			button_down_time = 0;
		}
	}
	// process led
	static ulong led_toggle_timeout = 0;
	if(led_blink_ms) {
		if((long)(millis() - led_toggle_timeout) > 0) {
			// toggle led
			og.set_led(1-og.get_led());
			led_toggle_timeout = millis() + led_blink_ms;
		}
	}
}

void on_update(const OTF::Request &req, OTF::Response &res) {
	if(curr_mode == OG_MOD_AP) {
		otf_send_compressed_P(res, (const __FlashStringHelper*)ap_update_html_gz, ap_update_html_gz_len);
	} else {
		if(req.isCloudRequest()) otf_send_result(res, HTML_NOT_PERMITTED, "fw update");
		otf_send_compressed_P(res, (const __FlashStringHelper*)sta_update_html_gz, sta_update_html_gz_len);
	}
}

void on_firmware_upload_fin() {

	// Verify the device key.
	if(!(updateServer->hasArg("dkey") && (updateServer->arg("dkey") == og.options[OPTION_DKEY].sval))) {
		updateserver_send_result(HTML_UNAUTHORIZED);
		Update.end(false); // Update.reset(); FAB
		return;
	}

	// finish update and check error
	if(!Update.end(true) || Update.hasError()) {
		updateserver_send_result(HTML_UPLOAD_FAILED);
		DEBUG_PRINTLN(F("OTA update failed: "));
		Update.printError(Serial);
		return;
	}

	updateserver_send_result(HTML_SUCCESS);
	//restart_ticker.once_ms(1000, og.restart);
	restart_in(1000);
}

void on_update_options() {
	updateServer->sendHeader("Access-Control-Allow-Origin", "*");
	updateServer->sendHeader("Access-Control-Max-Age", "10000");
	updateServer->sendHeader("Access-Control-Allow-Methods", "POST,GET,OPTIONS");
	updateServer->sendHeader("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
	updateServer->send(200, "text/plain", "");
}

void on_firmware_upload() {
	HTTPUpload& upload = updateServer->upload();
	if(upload.status == UPLOAD_FILE_START){
		if (og.options[OPTION_SECV].ival == 2) secplus2_garage.finish_release();
		if (og.options[OPTION_SECV].ival == 1) secplus1_garage.finish_release();
		if(curr_mode == OG_MOD_STA) {
			DEBUG_PRINTLN(F("Stopping all network clients"));
			WiFiUDP::stopAll();
			Blynk.disconnect(); // disconnect Blynk during firmware upload
			mqttclient.disconnect();
		}
		DEBUG_PRINT(F("prepare to upload: "));
		DEBUG_PRINTLN(upload.filename);
		uint32_t maxSketchSpace = (ESP.getFreeSketchSpace()-0x1000)&0xFFFFF000;
		if(!Update.begin(maxSketchSpace)) {
			DEBUG_PRINTLN(F("not enough space"));
		}
	} else if(upload.status == UPLOAD_FILE_WRITE) {
		DEBUG_PRINT(".");
		if(Update.write(upload.buf, upload.currentSize) != upload.currentSize) {
			DEBUG_PRINTLN(F("size mismatch"));
		}
	} else if(upload.status == UPLOAD_FILE_END) {
		DEBUG_PRINTLN(F("upload completed"));
	} else if(upload.status == UPLOAD_FILE_ABORTED){
		Update.end();
		DEBUG_PRINTLN(F("upload aborted"));
	}
	delay(0);
}

void check_status_ap() {
	static ulong cs_timeout = 0;
	if((long)(millis() - cs_timeout) > 0) {
		Serial.print(og.read_distance());
		Serial.print("/");
		Serial.println(OG_FWV);
		if(og.has_swrx) {
			Serial.println(F("secplus"));
		}
		cs_timeout = millis() + 2000;
	}
}

bool mqtt_connect_subscribe() {
	static ulong mqtt_subscribe_timeout = 0;
	if(curr_utc_time > mqtt_subscribe_timeout) {
		if (!mqttclient.connected()) {
			DEBUG_PRINT(F("MQTT Not connected- (Re)connect MQTT"));
			boolean ret;
			if(og.options[OPTION_MQUR].sval.length()>0) { // if MQTT user name is defined
				DEBUG_PRINT(F(" (authenticated)"));
				ret = mqttclient.connect(mqtt_id.c_str(), og.options[OPTION_MQUR].sval.c_str(), og.options[OPTION_MQPW].sval.c_str(), (mqtt_topic+"/OUT/STATUS").c_str(), 1, true, "offline");
			}
			else {
				DEBUG_PRINT(F(" [anonymous]"));
				ret = mqttclient.connect(mqtt_id.c_str(), (mqtt_topic+"/OUT/STATUS").c_str(), 1, true, "offline");
			}
			if(ret) {
				mqttclient.subscribe(mqtt_topic.c_str());
				mqttclient.subscribe((mqtt_topic +"/IN/#").c_str());
				mqttclient.publish((mqtt_topic+"/OUT/STATUS").c_str(), "online", true);
				DEBUG_PRINTLN(F("......Success, Subscribed to MQTT Topic"));
				mqtt_subscribe_timeout = curr_utc_time + 5; // if successful, don't check for 5 seconds
				return true;
			}else {
				DEBUG_PRINTLN(F("......Failed to Connect to MQTT"));
				mqtt_subscribe_timeout = curr_utc_time + 60; // if unsuccessful, try again in 60 seconds
				return false;
			}
		}
	}
	return false;
}

void blynkNotify(String s){
	// Blynk notification
	DEBUG_PRINTLN(F(" Sending blynk notification"));
	Blynk.notify(s);
}

void iftttNotify(String s){
	DEBUG_PRINTLN(" Sending IFTTT Notification");
	http.begin(httpclient, "http://maker.ifttt.com/trigger/opengarage/with/key/"+og.options[OPTION_IFTT].sval);
	http.addHeader("Content-Type", "application/json");
	http.POST("{\"value1\":\""+s+"\"}");
	String payload = http.getString();
	http.end();
	if(payload.indexOf("Congratulations") >= 0) {
		DEBUG_PRINTLN(" Successfully updated IFTTT");
	}else{
		DEBUG_PRINT(" Error from IFTTT: ");
		DEBUG_PRINTLN(payload);
	}
}

void emailNotify(String s){
	DEBUG_PRINTLN(" Sending EMail notification");
	DEBUG_PRINTLN(GET_FREE_HEAP);
	EMailSender::EMailMessage email_message;
	email_message.subject = og.options[OPTION_NAME].sval.c_str();
	email_message.message = s;
	const char *email_host = og.options[OPTION_SMTP].sval.c_str();
	const char *email_pword = og.options[OPTION_APWD].sval.c_str();
	const char *email_sender = og.options[OPTION_SEND].sval.c_str();
	const char *email_recip = og.options[OPTION_RECP].sval.c_str();
	unsigned int email_port = og.options[OPTION_SPRT].ival;
	if(email_host && email_pword && email_sender && email_recip){
		EMailSender emailSend(email_sender, email_pword);
		emailSend.setSMTPServer(email_host);
		emailSend.setSMTPPort(email_port);
		DEBUG_PRINTLN(GET_FREE_HEAP);
		EMailSender::Response resp = emailSend.send(email_recip, email_message);
	}
}

void mqttNotify(String s){
	if (mqttclient.connected()) {
		DEBUG_PRINTLN(" Sending MQTT Notification");
		mqttclient.publish((mqtt_topic + "/OUT/NOTIFY").c_str(),s.c_str());
	}
}

void perform_notify(String s) {
	DEBUG_PRINT(F("Sending Notify to connected systems, value:"));
	DEBUG_PRINTLN(s);

	if(og.options[OPTION_CLD].ival==CLOUD_BLYNK && Blynk.connected()){
		blynkNotify(s);
	}

	// IFTTT notification
	if(og.options[OPTION_IFTT].sval.length()>7) { // key size is at least 8
		iftttNotify(s);
	}

	// Email notification
	if(og.options[OPTION_EMEN].ival>0) {
		emailNotify(s);
	}

	//Mqtt notification
	if(og.options[OPTION_MQEN].ival>0 && valid_url(og.options[OPTION_MQTT].sval)) {
		mqttNotify(s);
	}
}

void process_dynamics(byte event) {
	static bool automationclose_triggered=false;
	byte ato = og.options[OPTION_ATO].ival;
	byte atob = og.options[OPTION_ATOB].ival;
	byte noto = og.options[OPTION_NOTO].ival;
	if(!ato && !atob && !noto) {
		justopen_timestamp = 0;
		return;
	}
	if(event == DOOR_EVENT_JUST_OPENED) {
		justopen_timestamp = curr_utc_time; // record time stamp
		if (noto & OG_NOTIFY_DO) { perform_notify(og.options[OPTION_NAME].sval + " just OPENED!");}

		// If the door is set to auto close at a certain hour, ensure if manually opened it doesn't autoshut
		if( (curr_utc_hour == og.options[OPTION_ATIB].ival) && (!automationclose_triggered) ){
			DEBUG_PRINTLN(" Door opened during automation hour, set to not auto-close ");
			automationclose_triggered=true;
		}

	} else if (event == DOOR_EVENT_JUST_CLOSED) {
		justopen_timestamp = 0; // reset time stamp
		if (noto & OG_NOTIFY_DC) { perform_notify(og.options[OPTION_NAME].sval + " just CLOSED!");}

	} else if (event == DOOR_EVENT_JUST_STOPPED) {
		justopen_timestamp = 0; // reset time stamp
		if (noto & OG_NOTIFY_DS) { perform_notify(og.options[OPTION_NAME].sval + " just STOPPED!");}

	}	else if (event == DOOR_EVENT_REMAIN_OPEN) {
		if (!justopen_timestamp) justopen_timestamp = curr_utc_time; // record time stamp
		else {
			if(curr_utc_time > justopen_timestamp + (ulong)og.options[OPTION_ATI].ival*60L) {
				// reached timeout, perform action
				if(ato & OG_AUTO_NOTIFY) {
					// send notification
					String s = og.options[OPTION_NAME].sval+" is left open for more than ";
					s+= og.options[OPTION_ATI].ival;
					s+= " minutes.";
					if(ato & OG_AUTO_CLOSE) {
						s+= " It will be auto-closed shortly";
					} else {
						s+= " This is a reminder for you.";
					}
					perform_notify(s);
				}
				if(ato & OG_AUTO_CLOSE) {
					// auto close door
					// alarm is mandatory in auto-close
					if(!og.options[OPTION_ALM].ival) { og.set_alarm(OG_ALM_5); }
					else { og.set_alarm(); }
				}
				justopen_timestamp = 0;
			}

			if(( curr_utc_hour == og.options[OPTION_ATIB].ival) && (!automationclose_triggered)) {
				// still open past time, perform action
				DEBUG_PRINTLN("Door is open at specified close time and automation not yet triggered: ");
				automationclose_triggered=true;
				if(atob & OG_AUTO_NOTIFY) {
					// send notification
					String s = og.options[OPTION_NAME].sval+" is open after ";
					s+= og.options[OPTION_ATIB].ival;
					s+= " UTC. Current hour:";
					s+= curr_utc_hour;
					if(atob & OG_AUTO_CLOSE) {
						s+= " It will be auto-closed shortly";
					} else {
						s+= " This is a reminder for you.";
					}
					perform_notify(s);
				}
				if(atob & OG_AUTO_CLOSE) {
					// auto close door
					// alarm is mandatory in auto-close
					if(!og.options[OPTION_ALM].ival) { og.set_alarm(OG_ALM_5); }
					else { og.set_alarm(); }
				}
				justopen_timestamp = 0;
			}
			else if ((curr_utc_hour > og.options[OPTION_ATIB].ival) && (automationclose_triggered)) {
				DEBUG_PRINTLN("Unlocking automation close function");
				automationclose_triggered=false; //Unlock the hour after the setting
			}
		}
	} else {
		justopen_timestamp = 0;
	}
}

byte check_door_event() {
	// perform pattern matching of door status histogram
	// and return the corresponding results
	const byte allones = (1<<DOOR_STATUS_HIST_K)-1;       // 0b1111
	const byte lowones = (1<<(DOOR_STATUS_HIST_K/2))-1; // 0b0011
	const byte highones= lowones << (DOOR_STATUS_HIST_K/2); // 0b1100

	if (!og.options[OPTION_SECV].ival) { // non security+
		byte _hist = door_status_hist & allones;  // get the lowest K bits
		if(_hist == 0) return DOOR_EVENT_REMAIN_CLOSED;
		if(_hist == allones) return DOOR_EVENT_REMAIN_OPEN;
		if(_hist == lowones) return DOOR_EVENT_JUST_OPENED;
		if(_hist == highones) return DOOR_EVENT_JUST_CLOSED;
		return DOOR_EVENT_NONE;
	} else { // security+
		if(door_status<DOOR_STATUS_UNKNOWN && last_door_status<DOOR_STATUS_UNKNOWN) {
			if(door_status == last_door_status) {
				switch(door_status) {
					case DOOR_STATUS_CLOSED:
						return DOOR_EVENT_REMAIN_CLOSED;
					case DOOR_STATUS_OPEN:
						return DOOR_EVENT_REMAIN_OPEN;
					case DOOR_STATUS_STOPPED:
						return DOOR_EVENT_REMAIN_STOPPED;
					case DOOR_STATUS_CLOSING:
						return DOOR_EVENT_STILL_CLOSING;
					case DOOR_STATUS_OPENING:
						return DOOR_EVENT_STILL_OPENING;
				}
			} else {
				switch(door_status) {
					case DOOR_STATUS_CLOSED:
						return DOOR_EVENT_JUST_CLOSED;
					case DOOR_STATUS_OPEN:
						return DOOR_EVENT_JUST_OPENED;
					case DOOR_STATUS_STOPPED:
						return DOOR_EVENT_JUST_STOPPED;
					case DOOR_STATUS_CLOSING:
						return DOOR_EVENT_START_CLOSING;
					case DOOR_STATUS_OPENING:
						return DOOR_EVENT_START_OPENING;
				}
			}
		}
		return DOOR_EVENT_NONE;
	}
}

void check_status() {
	static ulong checkstatus_timeout = 0;

	if((curr_utc_time > checkstatus_timeout) || (checkstatus_timeout == 0))  { //also check on first boot
		last_door_status = door_status; // save the current status to last_door_status
		if(light_blink_enabled) {
			og.set_led(HIGH);
			aux_ticker.once_ms(OG_LIGHT_BLINK_TIME, og.set_led, (byte)LOW);
		}

		// Read SN1 -- ultrasonic sensor
		uint dth = og.options[OPTION_DTH].ival;
		uint vth = og.options[OPTION_VTH].ival;
		bool sn1_status;
		distance = og.read_distance();
		if((distance==0 || distance>500 || !fullbuffer) && og.options[OPTION_SNO].ival!=OG_SNO_2ONLY) {
			// invalid distance value or non full buffer, return immediately except if using SN2 only
			DEBUG_PRINTLN(F("invalid distance or non-full buffer"));
			checkstatus_timeout = curr_utc_time + og.options[OPTION_RIV].ival;
			return;
		}

		sn1_status = (distance>dth)?0:1;
		if(og.options[OPTION_SN1].ival == OG_SN1_SIDE) {
			sn1_status = 1-sn1_status; // reverse logic for side mount
			// for side-mount, we can't decide vehicle status
			vehicle_status = OG_VEH_NOTAVAIL;
		} else {
			vehicle_status = OG_VEH_NOTAVAIL;
		  if (vth>0) { // if vehicle distance threshold is defined
				if(og.options[OPTION_SECV].ival>0 || og.options[OPTION_SNO].ival==OG_SNO_2ONLY) {
					// if door status is not determined using distance sensor (either using security+ or using SN2 only)
					// vehicle status can be deduced by checking if distance is less than vth
					vehicle_status = (distance <=vth) ? OG_VEH_PRESENT:OG_VEH_ABSENT;
				} else if (!sn1_status) {
					// if door is currently closed, vehicle status can be deduced by checking if distance is within bracket [dth, vth]
					vehicle_status = ((distance>dth) && (distance <=vth)) ? OG_VEH_PRESENT:OG_VEH_ABSENT;
				} else {
					// otherwise, door status is determined by distance sensor and door is open, blocking its view
					// so we can't deduce vehicle status
					vehicle_status = OG_VEH_UNKNOWN;
				}
			}
		}

		// Read SN2 -- optional switch sensor
		sn2_value = og.get_switch();
		byte sn2_status = 0;
		if(og.options[OPTION_SN2].ival == OG_SN2_NC) {	// if SN2 is normally closed type
			sn2_status = sn2_value;
		} else if(og.options[OPTION_SN2].ival == OG_SN2_NO) {	// if SN2 is normally open type
			sn2_status = 1-sn2_value;
		}

		switch (og.options[OPTION_SECV].ival) {
			case 1: // SecPlus 1
			case 2: // SecPlus 2
				// Handled by the callback function
				door_status = secplus_door_status;
				break;
			default: // No secplus
				// Process Sensor Logic
				bool status = false;
				if(og.options[OPTION_SN2].ival==OG_SN2_NONE || og.options[OPTION_SNO].ival==OG_SNO_1ONLY) {
					// if SN2 not installed or logic is SN1 only
					status = sn1_status;
				} else if(og.options[OPTION_SNO].ival==OG_SNO_2ONLY) {
					status = sn2_status;
				} else if(og.options[OPTION_SNO].ival==OG_SNO_AND) {
					status = sn1_status && sn2_status;
				} else if(og.options[OPTION_SNO].ival==OG_SNO_OR) {
					status = sn1_status || sn2_status;
				}
				door_status = status ? DOOR_STATUS_OPEN : DOOR_STATUS_CLOSED;
				break;
		}

		if (checkstatus_timeout == 0){
			DEBUG_PRINTLN(F("First time checking status don't trigger a status change, set full history to current value"));
			if (door_status) { door_status_hist = B11111111; }
			else { door_status_hist = B00000000; }
			last_door_status = door_status;
		} else {
			door_status_hist = (door_status_hist<<1) | door_status;
		}

		// get temperature readings
		og.read_TH_sensor(tempC, humid);

		read_cnt = (read_cnt+1)%100;

		// once the light is disabled, quit blinking until a restart or a reset to 0.
		byte blink_limit = og.options[OPTION_BAS].ival;
		bool current_light_blink_enabled = light_blink_enabled;
		light_blink_enabled = blink_limit == OG_LIGHT_BLINK_FOREVER || (light_blink_enabled && read_cnt <= blink_limit);

		// do a long blink to notify that we are turning the light off
		if(current_light_blink_enabled && !light_blink_enabled){
			og.set_led(HIGH);
			aux_ticker.once_ms(OG_LIGHT_BLINK_NOTIFY, og.set_led, (byte)LOW);
		}

		byte event = check_door_event();

		// Log door status changes (only record opened, closed, stopped status changes, as the other statuses are transient)
		if(event == DOOR_EVENT_JUST_OPENED || event == DOOR_EVENT_JUST_CLOSED || event == DOOR_EVENT_JUST_STOPPED) {
			// write log record
			DEBUG_PRINTLN(" Update Local Log");
			LogStruct l;
			l.tstamp = curr_utc_time;
			l.status = door_status;
			l.dist = distance;
			l.sn2 = 255;	// use 255 to indicate invalid value
			if(og.options[OPTION_SN2].ival>OG_SN2_NONE) l.sn2 = sn2_value;
			og.write_log(l);

		} //End state change updates

		static ulong force_mqtt_update_timeout = 0;
		// Send current status on change, or on status_report interval
		if ((curr_utc_time > force_mqtt_update_timeout) ||
				(event == DOOR_EVENT_JUST_OPENED || event == DOOR_EVENT_JUST_CLOSED || event == DOOR_EVENT_JUST_STOPPED || event == DOOR_EVENT_START_OPENING || event == DOOR_EVENT_START_CLOSING) ){
			// Mqtt update
			if(og.options[OPTION_MQEN].ival>0 && valid_url(og.options[OPTION_MQTT].sval) && (mqttclient.connected())) {
				//DEBUG_PRINTLN(F(" Update MQTT (State Refresh)"));
				if(event == DOOR_EVENT_REMAIN_OPEN) {
					mqttclient.publish((mqtt_topic + "/OUT/STATE").c_str(),"OPEN");
					mqttclient.publish(mqtt_topic.c_str(),"Open"); //Support existing mqtt code
				} else if(event == DOOR_EVENT_REMAIN_CLOSED) {					// MQTT: If door closed...
					mqttclient.publish((mqtt_topic + "/OUT/STATE").c_str(),"CLOSED");
					mqttclient.publish(mqtt_topic.c_str(),"Closed"); //Support existing mqtt code
				} else if (event == DOOR_EVENT_REMAIN_STOPPED) {					// MQTT: If door closed...
					mqttclient.publish((mqtt_topic + "/OUT/STATE").c_str(),"STOPPED");
					mqttclient.publish(mqtt_topic.c_str(),"Stopped"); //Support existing mqtt code
				}
				String msg;
				sta_controller_fill_json(msg);
				mqttclient.publish((mqtt_topic + "/OUT/JSON").c_str(),msg.c_str());
			}
			// Send status report every 15 seconds: we don't need to send updates frequently if there is no status change.
			force_mqtt_update_timeout= curr_utc_time + 15;
		}

		// Process dynamics: automation and notifications
		// report status to Blynk
		if(og.options[OPTION_CLD].ival==CLOUD_BLYNK && Blynk.connected()) {
			DEBUG_PRINTLN(F(" Update Blynk (State Refresh)"));

			static uint old_distance = 0;
			static byte old_door_status = 0xff, old_vehicle_status = 0xff;
			static float old_tempC = -100;
			static float old_humid = -100;
			static byte old_light_status = 255;
			static byte old_lock_status = 255;

			// to reduce traffic, only send updated values
			if(distance != old_distance) {  Blynk.virtualWrite(BLYNK_PIN_DIST, distance); old_distance = distance; }
			if(door_status != old_door_status) {
				switch(door_status) {
					case DOOR_STATUS_OPEN:
						blynk_door.setColor("#E02040"); // Red for Open
						blynk_door.on();
						break;
					case DOOR_STATUS_STOPPED:
						blynk_door.setColor("#E0E000"); // Yellow for Stopped
						blynk_door.on();
						break;
					case DOOR_STATUS_OPENING:
						blynk_door.setColor("#D000D0"); // Purple for Opening
						blynk_door.on();
						break;
					case DOOR_STATUS_CLOSING:
						blynk_door.setColor("#20A0E0"); // Cyan for Closing
						blynk_door.on();
						break;
					case DOOR_STATUS_CLOSED:
						//blynk_door.setColor("#20E080"); // Green for Closed
						blynk_door.off();
						break;
					default:
						blynk_door.setColor("#808080"); // Gray for Unknown
						blynk_door.on();
						break;
				}
				blynk_dval.setValue(door_status);
				old_door_status = door_status;
			}
			if(vehicle_status != old_vehicle_status) { (vehicle_status==1) ? blynk_car.on() : blynk_car.off(); old_vehicle_status = vehicle_status; }
			// hack to simulate temp humid changes
			if(old_tempC != tempC) { Blynk.virtualWrite(BLYNK_PIN_TEMP, tempC); old_tempC = tempC; }
			if(old_humid != humid) { Blynk.virtualWrite(BLYNK_PIN_HUMID,humid); old_humid = humid; }
			if(old_light_status != light_status) { Blynk.virtualWrite(BLYNK_PIN_LIGHT, light_status); old_light_status = light_status; }
			if(old_lock_status != lock_status) { Blynk.virtualWrite(BLYNK_PIN_LOCK, lock_status); old_lock_status = lock_status; }
		}

		process_dynamics(event);
		checkstatus_timeout = curr_utc_time + og.options[OPTION_RIV].ival;
	}
}

void time_keeping() {
	static bool configured = false;
	static ulong prev_millis = 0;
	static ulong time_keeping_timeout = 0;
	static unsigned char failed_ntp_calls = 0;
	const unsigned char MAX_FAILED_NTP_CALLS = 20;
	const ulong NTP_VALID_TIME = 1577836800UL;

	if(!configured) {
		if(valid_url(og.options[OPTION_NTP1].sval)) {
			DEBUG_PRINT(F("NTP1:"));
			DEBUG_PRINTLN(og.options[OPTION_NTP1].sval);
			configTime(0, 0, og.options[OPTION_NTP1].sval.c_str(), DEFAULT_NTP1, DEFAULT_NTP2);
		} else {
			DEBUG_PRINT(F("NTP1:"));
			DEBUG_PRINTLN(DEFAULT_NTP1);
			configTime(0, 0, DEFAULT_NTP1, DEFAULT_NTP2, DEFAULT_NTP3);
		}
		configured = true;
		delay(1000);
	}

	if(!curr_utc_time || (curr_utc_time > time_keeping_timeout)) {
		ulong gt = 0;
		gt = time(nullptr);
		if(gt<NTP_VALID_TIME) {
			// we didn't get a valid response
			if(failed_ntp_calls >= MAX_FAILED_NTP_CALLS) { // if already reached max failed calls
				time_keeping_timeout = curr_utc_time + 60; // re-try after a minute
				DEBUG_PRINTLN(F("max failed ntp reached! re-try in 60 seconds"));
			} else {
				failed_ntp_calls ++;
				time_keeping_timeout = curr_utc_time + 2; // re-try after 2 seconds
				DEBUG_PRINTLN(F("ntp invalid! re-try in 2 seconds"));
			}
		} else {
			failed_ntp_calls = 0;
			curr_utc_time = gt;
			curr_utc_hour = (curr_utc_time % 86400)/3600;
			DEBUG_PRINT(F("Updated time from NTP: "));
			DEBUG_PRINT(curr_utc_time);
			DEBUG_PRINT(" Hour: ");
			DEBUG_PRINTLN(curr_utc_hour);
			// if we got a response, re-try after TIME_SYNC_TIMEOUT seconds
			time_keeping_timeout = curr_utc_time + TIME_SYNC_TIMEOUT;
			prev_millis = millis();
			if(!start_utc_time) {
				start_utc_time = curr_utc_time - millis()/1000;
			}
		}
	}

	while(millis() - prev_millis >= 1000) {
		curr_utc_time ++;
		curr_utc_hour = (curr_utc_time % 86400)/3600;
		prev_millis += 1000;
	}
}

void process_alarm() {
	static uint32_t sequence=0;
	static bool running=false;
	if (!og.alarm) { warning_audio.cancel(); running=false; return; }
	if (!running || sequence!=og.alarm_sequence) {
		cancel_diagnostic_audio();
		sequence=og.alarm_sequence; running=true;
		warning_audio.start(millis(),uint32_t(og.alarm-1)*500);
		return;
	}
	if (warning_audio.tick(millis())) {
		og.alarm=0; running=false;
			switch (og.options[OPTION_SECV].ival) {
				case 2: // SecPlus 2
					switch (og.alarm_action) {
						case 1: // Close
							secplus2_garage.close_door();
							break;
						case 2: // Open
							secplus2_garage.open_door();
							break;
						default: // Toggle
							secplus2_garage.toggle_door();
					}
					break;
				case 1: // SecPlus 1
					secplus1_garage.toggle_door();
					break;
				default: // No secplus
					og.click_relay();
			}
	}
}

void do_loop() {
	LoopMeasurement loop_measurement;
	static ulong connecting_timeout;
	switch(og.state) {
	case OG_STATE_INITIAL:
		if(curr_mode == OG_MOD_AP) {
			scanned_ssids = scan_network();
			scanned_ssids += F(",\"has_swrx\":");
			scanned_ssids += og.has_swrx;
			scanned_ssids += F(",\"secv\":");
			scanned_ssids += og.options[OPTION_SECV].ival;
			scanned_ssids += F("}");
			String ap_ssid = get_ap_ssid();
			start_network_ap(ap_ssid.c_str(), NULL);
			delay(500);
			dns->setErrorReplyCode(DNSReplyCode::NoError);
			dns->start(53, "*", WiFi.softAPIP());
			otf->on("/",   on_home);
			otf->on("/js", on_ap_scan);
			otf->on("/cc", on_ap_change_config);
			otf->on("/jt", on_ap_try_connect);
			otf->on("/db", on_ap_debug);
			otf->on("/ad", on_auto_detect);
			// FIXME get update ap updates working.
			otf->on("/update", on_update, OTF::HTTP_GET);
			updateServer->on("/update", HTTP_POST, on_firmware_upload_fin, on_firmware_upload);
			updateServer->on("/update", HTTP_OPTIONS, on_update_options);
			otf->on("/resetall",on_reset_all);
			otf->onMissingPage(on_home);
			updateServer->begin();
			DEBUG_PRINTLN(F("Web Server endpoints (AP mode) registered"));
			og.state = OG_STATE_CONNECTED;
			DEBUG_PRINTLN(WiFi.softAPIP());
			connecting_timeout = 0;
			start_tune(og_audio::Tune::AP);
		} else {
			led_blink_ms = LED_SLOW_BLINK;
			DEBUG_PRINT(F("Attempting to connect to SSID: "));
			DEBUG_PRINTLN(og.options[OPTION_SSID].sval.c_str());

			String host = og.options[OPTION_HOST].sval;
			const char* hostname = host.length() == 0 ? NULL : host.c_str(); // use the hostname provided if one is specified

			start_network_sta(og.options[OPTION_SSID].sval.c_str(), og.options[OPTION_PASS].sval.c_str(), hostname);
			og.config_ip();
			og.state = OG_STATE_CONNECTING;
			connecting_timeout = millis() + 60000;
		}
		break;

	case OG_STATE_TRY_CONNECT:
		{
			led_blink_ms = LED_SLOW_BLINK;
			DEBUG_PRINT(F("Attempting to connect to SSID: "));
			DEBUG_PRINTLN(og.options[OPTION_SSID].sval.c_str());

			String host = og.options[OPTION_HOST].sval;
			const char* hostname = host.length() == 0 ? NULL : host.c_str(); // use the hostname provided if one is specified

			start_network_sta_with_ap(og.options[OPTION_SSID].sval.c_str(), og.options[OPTION_PASS].sval.c_str(), hostname);
			og.config_ip();
			og.state = OG_STATE_CONNECTED;
			break;
		}

	case OG_STATE_CONNECTING:
		if(WiFi.status() == WL_CONNECTED) {
			DEBUG_PRINT(F("Wireless connected, IP: "));
			DEBUG_PRINTLN(WiFi.localIP());

			time_keeping();
			otf->on("/", on_home);
			otf->on("/jc", on_sta_controller);
			otf->on("/jo", on_sta_options);
			otf->on("/jl", on_sta_logs);
			otf->on("/ad", on_auto_detect);
			otf->on("/vo", on_sta_view_options);
			otf->on("/vl", on_sta_view_logs);
			otf->on("/cc", on_sta_change_controller);
			otf->on("/co", on_sta_change_options);
			otf->on("/db", on_sta_debug);
			// FIXME get sta updates working.
			otf->on("/update", on_update, OTF::HTTP_GET);
			updateServer->on("/update", HTTP_POST, on_firmware_upload_fin, on_firmware_upload);
			updateServer->on("/update", HTTP_OPTIONS, on_update_options);
			otf->on("/clearlog", on_clear_log);
			otf->on("/s2id_gen", on_regenerate_secplus2_id, OTF::HTTP_POST);
			otf->on("/resetall",on_reset_all);
			updateServer->begin();
			DEBUG_PRINTLN(F("Web Server endpoints (STA mode) registered"));

			// request mDNS host name
			String host = og.options[OPTION_HOST].sval;
			if(host.length()==0) host=get_ap_ssid(); // if undefined, AP name as host
			if(MDNS.begin(host.c_str(), WiFi.localIP())) {
				DEBUG_PRINT(F("MDNS registered: "));
				DEBUG_PRINT(host);
				DEBUG_PRINTLN(F(".local"));

				MDNS.addService("http", "tcp", og.options[OPTION_HTP].ival);
				//DEBUG_PRINTLN(og.options[OPTION_HTP].ival);
			}

			if(og.options[OPTION_CLD].ival==CLOUD_BLYNK) {
				DEBUG_PRINTLN(F("Attempt to connect to Blynk:"));
				DEBUG_PRINT(og.options[OPTION_BDMN].sval);
				DEBUG_PRINT(":");
				DEBUG_PRINTLN(og.options[OPTION_BPRT].ival);
				Blynk.config(og.options[OPTION_AUTH].sval.c_str(), og.options[OPTION_BDMN].sval.c_str(), (uint16_t) og.options[OPTION_BPRT].ival); // use the config function
				if(Blynk.connect()) {DEBUG_PRINTLN(F("Blynk connected"));}
				else {DEBUG_PRINTLN(F("Blynk failed!"));}
			}
			led_blink_ms = 0;
			og.set_led(LOW);
			og.state = OG_STATE_CONNECTED;
			connecting_timeout = 0;
			start_tune(og_audio::Tune::STATION);
		} else {
			if(connecting_timeout && millis() > connecting_timeout) {
				DEBUG_PRINTLN(F("Wifi Connecting timeout, restart"));
				og.restart();
			}
		}
		break;

	case OG_STATE_RESET:
		og.state = OG_STATE_INITIAL;
		og.options_reset();
		og.log_reset();
		og.restart();
		break;

	case OG_STATE_WAIT_RESTART:
		if(dns) dns->processNextRequest();
		if(otf) otf->loop();
		if(updateServer) updateServer->handleClient();
		break;

	case OG_STATE_CONNECTED: //THIS IS THE MAIN LOOP
		if(curr_mode == OG_MOD_AP) {
			dns->processNextRequest();
			otf->loop();
			updateServer->handleClient();
			check_status_ap();
			connecting_timeout = 0;
			if(og.options[OPTION_MOD].ival == OG_MOD_STA) {
				// already in STA mode, waiting to reboot
				break;
			}
			if(WiFi.status() == WL_CONNECTED && WiFi.localIP()) {
				DEBUG_PRINTLN(F("STA connected, updating option file"));
				complete_ap_setup();
			}

		} else {
			if(WiFi.status() == WL_CONNECTED) {
				MDNS.update();
				time_keeping();
				check_status(); //This checks the door, sends info to services and processes the automation rules
				otf->loop();
				updateServer->handleClient();

				if(og.options[OPTION_CLD].ival==CLOUD_BLYNK) {
					Blynk.run();
				}

				//Handle MQTT
				if(og.options[OPTION_MQEN].ival>0 && valid_url(og.options[OPTION_MQTT].sval)) { // if enabled and mqtt server looks valid
					if (!mqttclient.connected()) {
						mqtt_id = get_ap_ssid();
						mqtt_topic = og.options[OPTION_MQTP].sval;
						if(mqtt_topic.length()==0) mqtt_topic = og.options[OPTION_NAME].sval;
						mqttclient.setServer(og.options[OPTION_MQTT].sval.c_str(), og.options[OPTION_MQPT].ival);
						mqttclient.setCallback(mqtt_callback);
						mqtt_connect_subscribe();
					}
					else {mqttclient.loop();} //Processes MQTT Pings/keep alives
				}
				connecting_timeout = 0;
			} else {
				//og.state = OG_STATE_INITIAL;
				DEBUG_PRINTLN(F("WiFi connection lost."));
			}
		}
		break;
	}

	// secplus process loop
	if (identity_restart_pending) return;
	switch (og.options[OPTION_SECV].ival) {
		case 2: // SecPlus 2
			secplus2_garage.loop();
			break;
		case 1: // SecPlus 1
			secplus1_garage.loop();
			break;
	}

	process_ui();

	process_alarm();
	if (!og.alarm && !ip_audio_active) startup_audio.tick(millis());
	if (setup_reboot_pending && !startup_audio.active() && !og.alarm) {
		setup_reboot_pending=false;
		restart_in(1000);
	}
}

BLYNK_WRITE(BLYNK_PIN_RELAY) {
	static bool last_button_state = 0;
	bool current_button_state = param.asInt();
	if (last_button_state && !current_button_state) { // on button release
		DEBUG_PRINTLN(F("Received Blynk generated button request"));
		performDoorAction(ACTION_TOGGLE);
	}
	last_button_state = current_button_state;
}

BLYNK_WRITE(BLYNK_PIN_LIGHT) {
	if (og.options[OPTION_SECV].ival == 2 && !secplus2_garage.status_valid()) return;
	if (og.options[OPTION_SECV].ival == 1 && !secplus1_garage.light_lock_valid()) return;
	bool requested_light_state = param.asInt();
	if (requested_light_state != light_status) {
		DEBUG_PRINTLN(F("Received Blynk generated light change request"));
		performLightAction(ACTION_TOGGLE);
	}
}

BLYNK_WRITE(BLYNK_PIN_LOCK) {
	if (og.options[OPTION_SECV].ival == 2 && !secplus2_garage.status_valid()) return;
	if (og.options[OPTION_SECV].ival == 1 && !secplus1_garage.light_lock_valid()) return;
	bool requested_lock_state = param.asInt();
	if (requested_lock_state != lock_status) {
		DEBUG_PRINTLN(F("Received Blynk generated lock change request"));
		performLockAction(ACTION_TOGGLE);
	}
}