WARNING: Spurious .github folder in 'WiFiManager' library
G:\003 Projects\ESP8266\arduino\03 sinric\multiwifi_sw\multi_nav_wifi\multi_nav_wifi.ino: In function 'void load(WiFiManager&)':

multi_nav_wifi:51: error: 'class WiFiManager' has no member named 'addAP'

			   wifiManager.addAP(obj["SSID"], obj["Password"]);

						   ^

G:\003 Projects\ESP8266\arduino\03 sinric\multiwifi_sw\multi_nav_wifi\multi_nav_wifi.ino: In function 'void save(WiFiManager&)':

multi_nav_wifi:76: error: 'class WiFiManager' has no member named 'getAP'

	 for (int i = 0; auto ap = wifiManager.getAP(i); i++ ) {

										   ^

exit status 1
'class WiFiManager' has no member named 'addAP'

    else if(action == "SetColor") {
      String hue = json ["value"]["hue"]["value"];
      Serial.println (" Color is set too: " + hue);          
    }

  //set static ip
  IPAddress _ip,_gw,_sn;
  _ip.fromString(static_ip);
  _gw.fromString(static_gw);
  _sn.fromString(static_sn);

  wifiManager.setSTAStaticIPConfig(_ip, _gw, _sn);

#include <FS.h>  // this needs to be first, or it all crashes and burns...

#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <WebSocketsClient.h>   // get it from https://github.com/Links2004/arduinoWebSockets/releases 
#include <ArduinoJson.h>        // get it from https://arduinojson.org/ or install via Arduino library manager
#include <DNSServer.h>
#include <ESP8266WebServer.h>
#include <WiFiManager.h>        // get it from https://github.com/the-real-orca/WiFiManager
#include <WiFiUDP.h>  //get it from https://github.com/esp8266/Arduino/tree/master/libraries/ESP8266WiFi/src


/* This version of the sinric switch uses the multi wifi manager to input wifi, API, and two device ids.
 * It is designed to work with an ESP8266-01 with the following pin use:
 * GPIO_2 = device 1. LOW is ON.  HIGH is OFF.  Intended to sink to an optoisolator with pin 1 connected to Vcc and pin 2 to GPIO_2.
 * GPIO_0 = device 2. LOW is ON.  HIGH is OFF.  Intended to sink to an optoisolator with pin 1 connected to Vcc and pin 2 to GPIO-0.
 * RX (pin 3) = Used to manually toggle device_ID 1. Connect a momentary N/O switch to GROUND and RX with a 220 ohm pullup resistor to Vcc.
 * TX (pin 1) = Used to manually toggle device_ID 2. Connect a momentary N/O switch to GROUND and RX with a 220 ohm pullup resistor to Vcc.
 * Pressing both TX and RX buttons (to low) will cause the ESP to reset and go into AP WiFiManager mode.
 * All other ESP pins are connected per usual ESP set up.
 */

 
 /*ESP8266-01 Flash settings:
  * Board - Generic ESP8266
  * Flash Mode - DIO
  * Flash Size - 1M (512K SPIFFS)
  * Debug Port - Disabled
  * Debug Level - None
  * lwIP Variant - V2 prebuilt (MSS=536)
  * Reset Method - ck
  * Crystal Frequency - 26M
  * Flash Frequency - 40MHz
  * CPU Frequency - 80MHz
  * Upload Speed - 115200
  * Port - TBD by your setup
  * Programmer - Arduino as ISP
  */
 
WebSocketsClient webSocket;
WiFiClient client;
WiFiUDP Udp;

//Swithc Contols variables
int GPIO_2 = 2; //To control Device 1
int GPIO_0 = 0; //To control Device 2
int RX = 3;  //To manually toggle device 1
int TX = 1;  //To manually toggle device 2
int RXState; //State of RX pin
int TXState; //State of TX pin
int GPIO_2State; //State of device 1
int GPIO_0State; //State of device 2

#define API_ENDPOINT "http://sinric.com"
#define HEARTBEAT_INTERVAL 300000 // 5 Minutes

//Set variables for UDP server
char udp_port[6]; //used to store in json the udp port from user input on WiFi Manager page
unsigned int udpPort;  // used by udp.begin()command (it is udpPort converted for use)
char pktBuf[25]; //buffer for UDP packets

 //Define the local IP variables
char ap_SSID[25] = "NewBox"; //SSID for ESP when in AP mode
char static_ip[16]; // ip address for ESP when in client mode
char static_gw[16]; // gateway address for ESP when in client mode
char static_sn[16]; // subnet address for ESP when in client mode

//Define the Alexa variables
char api_key[37]; //Sinric API Key
char first_deviceId[25]; //alexa device 1
char second_deviceId[25]; //alexa device 2

//Define the heartbeat timer variables
uint64_t heartbeatTimestamp = 0; //heartbeat timer reset
bool isConnected = false;

//flag for saving data
bool shouldSaveConfig = false;

//callback notifying us of the need to save config
void saveConfigCallback () {
//  Serial.println("Should save config");
  shouldSaveConfig = true;
}

  //if a udp command is received, toggle the appropriate device
void toggle(String device_Id) {
  if (device_Id == (first_deviceId)) {
    GPIO_2State = digitalRead(GPIO_2);
    digitalWrite(GPIO_2, !GPIO_2State);
//       Serial.println("Device 1");
//       Serial.println("Status:");
//       Serial.println(GPIO_2State);
//       Serial.println("Waiting");
  } else if (device_Id == (second_deviceId)) {
    GPIO_0State = digitalRead(GPIO_0);
    digitalWrite(GPIO_0, !GPIO_0State);
//       Serial.println("Device 2:");
//       Serial.println("Status:");
//       Serial.println(GPIO_0State);
//       Serial.println("Waiting");
  }  
}

  //Alexa "ON" response
void turnOn(String deviceId) {
  if (deviceId == (first_deviceId)) {  // Device ID of first device  
//    Serial.print("Turn on 1st-device id: ");
//    Serial.println(deviceId);
        digitalWrite(GPIO_2, LOW);
  } else if (deviceId == (second_deviceId)) {  // Device ID of second device 
//    Serial.print("Turn on 2nd-device id: ");
//    Serial.println(deviceId);
        digitalWrite(GPIO_0, LOW);
  } else { 
//    Serial.print("Turn on for unknown device id: ");
//    Serial.println(deviceId);
  }     
}

  //Alexa "OFF" response
void turnOff(String deviceId) {
   if (deviceId == (first_deviceId)) {  // Device ID of first device  
//     Serial.print("Turn off 1st-Device ID: ");
//     Serial.println(deviceId);
        digitalWrite(GPIO_2, HIGH);
   } else if (deviceId == (second_deviceId)) { // Device ID of second device
//     Serial.print("Turn off 2nd-Device ID: ");
//     Serial.println(deviceId);
        digitalWrite(GPIO_0, HIGH);
  } else {
//     Serial.print("Turn off for unknown device id: ");
//     Serial.println(deviceId);
  }
}


  //Receive and process an Alexa command
void webSocketEvent(WStype_t type, uint8_t * payload, size_t length) {
  switch(type) {
    case WStype_DISCONNECTED:{
      isConnected = false;    
//      Serial.printf("[WSc] Webservice disconnected from sinric.com!\n");
      break;
    case WStype_CONNECTED: {
      isConnected = true;
//      Serial.printf("[WSc] Service connected to sinric.com at url: %s\n", payload);
//      Serial.printf("Waiting for commands from sinric.com ...\n");        
      }
      break;
    case WStype_TEXT: {
        DynamicJsonBuffer jsonBuffer;
        JsonObject& json = jsonBuffer.parseObject((char*)payload); 
        String deviceId = json ["deviceId"];     
        String action = json ["action"];

        if(action == "setPowerState") { // Switch or Light
            String value = json ["value"];
            if(value == "ON") {
                turnOn(deviceId);
            } else {
                turnOff(deviceId);
            }
        } else if(action == "setBrightness") {
          
        } else if(action == "AdjustBrightness") {
          
        } else if (action == "test") {
//            Serial.println("[WSc] received test command from sinric.com");
        }
      }
      break;
    case WStype_BIN:
//      Serial.printf("[WSc] get binary length: %u\n", length);
      break;
    }
  }
}

void setup() {
  Serial.begin(115200);
//  Serial.println();

  // Setup pins to off position
  pinMode(GPIO_2, OUTPUT);
  digitalWrite(GPIO_2, HIGH);
  pinMode(GPIO_0, OUTPUT);
  digitalWrite(GPIO_0, HIGH);
  pinMode(RX, INPUT_PULLUP);
  pinMode(TX, INPUT_PULLUP);


  
//  SPIFFS.format();  //clean FS, for testing

  //read configuration from FS json
//  Serial.println("mounting FS...");

  if (SPIFFS.begin()) {
//    Serial.println("mounted file system");
    if (SPIFFS.exists("/config.json")) {
      //file exists, reading and loading
//      Serial.println("reading config file");
      File configFile = SPIFFS.open("/config.json", "r");
      if (configFile) {
//        Serial.println("opened config file");
        size_t size = configFile.size();
        // Allocate a buffer to store contents of the file.
        std::unique_ptr<char[]> buf(new char[size]);

        configFile.readBytes(buf.get(), size);
        DynamicJsonBuffer jsonBuffer;
        JsonObject& json = jsonBuffer.parseObject(buf.get());
        json.printTo(Serial);
        if (json.success()) {
//          Serial.println("\nparsed json");

          strcpy(ap_SSID, json["ap_SSID"]);
          strcpy(udp_port, json["udp_port"]);
          strcpy(api_key, json["api_key"]);
          strcpy(first_deviceId, json["first_deviceId"]);
          strcpy(second_deviceId, json["second_deviceId"]);

          if(json["ip"]) {
            Serial.println("setting custom ip from config");
            //static_ip = json["ip"];
            strcpy(static_ip, json["ip"]);
            strcpy(static_gw, json["gateway"]);
            strcpy(static_sn, json["subnet"]);
//            Serial.println(static_ip);
          } else { 
//            Serial.println("no custom ip in config");
          }
        } else {
//          Serial.println("failed to load json config");
        }
      }
    }
  } else {
//    Serial.println("failed to mount FS");
  }
  //end read
//  Serial.println(static_ip);
//  Serial.println(udp_port);
//  Serial.println(api_key);
//  Serial.println(first_deviceId);
//  Serial.println(second_deviceId);


  // The extra parameters to be configured (can be either global or just in the setup)
  // After connecting, parameter.getValue() will get you the configured value
  // id/name placeholder/prompt default length
  WiFiManagerParameter custom_ap_SSID("ap_SSID", "Box name and SSID", ap_SSID, 25);
  WiFiManagerParameter custom_udp_port("udp_port", "UDP Port", udp_port, 6);
  WiFiManagerParameter custom_api_key("api key", "api key", api_key, 37);
  WiFiManagerParameter custom_first_deviceId("1st-deviceId", "1st deviceId", first_deviceId, 25);
  WiFiManagerParameter custom_second_deviceId("2nd-deviceId", "2nd deviceId", second_deviceId, 25);

  //WiFiManager
  //Local intialization. Once its business is done, there is no need to keep it around
  WiFiManager wifiManager;

  //set config save notify callback
  wifiManager.setSaveConfigCallback(saveConfigCallback);

  //set static ip
  IPAddress _ip,_gw,_sn;
  _ip.fromString(static_ip);
  _gw.fromString(static_gw);
  _sn.fromString(static_sn);

  wifiManager.setSTAStaticIPConfig(_ip, _gw, _sn);
  
  //add all your parameters here
  wifiManager.addParameter(&custom_ap_SSID);
  wifiManager.addParameter(&custom_udp_port);
  wifiManager.addParameter(&custom_api_key);
  wifiManager.addParameter(&custom_first_deviceId);
  wifiManager.addParameter(&custom_second_deviceId);

  //reset settings - for testing
  //wifiManager.resetSettings();

  //set minimu quality of signal so it ignores AP's under that quality
  //defaults to 8%
  wifiManager.setMinimumSignalQuality();
  
  //sets timeout until configuration portal gets turned off
  //useful to make it all retry or go to sleep
  //in seconds
  //wifiManager.setTimeout(120);

  //fetches ssid and pass and tries to connect
  //if it does not connect it starts an access point with the specified name
  //here  "AutoConnectAP"
  //and goes into a blocking loop awaiting configuration
  if (!wifiManager.autoConnect(ap_SSID)) {
//    Serial.println("failed to connect and hit timeout");
    delay(3000);
    //reset and try again, or maybe put it to deep sleep
    ESP.reset();
    delay(3000);
  }

  //if you get here you have connected to the WiFi
//  Serial.println("connected to WiFi...");

  //read updated parameters
  strcpy(ap_SSID, custom_ap_SSID.getValue());
  strcpy(udp_port, custom_udp_port.getValue());
  strcpy(api_key, custom_api_key.getValue());
  strcpy(first_deviceId, custom_first_deviceId.getValue());
  strcpy(second_deviceId, custom_second_deviceId.getValue());

  //save the custom parameters to FS
  if (shouldSaveConfig) {
    Serial.println("saving config");
    DynamicJsonBuffer jsonBuffer;
    JsonObject& json = jsonBuffer.createObject();
    json["ap_SSID"] = ap_SSID;
    json["udp_port"] = udp_port;
    json["api_key"] = api_key;
    json["first_deviceId"] = first_deviceId;
    json["second_deviceId"] = second_deviceId;

    json["ip"] = WiFi.localIP().toString();
    json["gateway"] = WiFi.gatewayIP().toString();
    json["subnet"] = WiFi.subnetMask().toString();

    File configFile = SPIFFS.open("/config.json", "w");
    if (!configFile) {
//      Serial.println("failed to open config file for writing");
    }

    json.prettyPrintTo(Serial);
    json.printTo(configFile);
    configFile.close();
    //end save
  }

//  Serial.println("local ip");
//  Serial.println(WiFi.localIP());
//  Serial.println(WiFi.gatewayIP());
//  Serial.println(WiFi.subnetMask());
    delay(500);

  // Alexa server address, port and URL
  webSocket.begin("iot.sinric.com", 80, "/");


  // Alexa event handler
  webSocket.onEvent(webSocketEvent);
  webSocket.setAuthorization("apikey", api_key);
  // try again every 5000ms if connection has failed
  webSocket.setReconnectInterval(5000);   // If you see 'class WebSocketsClient' has no member named 'setReconnectInterval' error update arduinoWebSockets


  //Start UDP server
  udpPort = atoi(udp_port);
  Udp.begin(udpPort);
//  Serial.println("UDP Target IP");
//  Serial.println(WiFi.localIP());
//  Serial.println("UDP port");
//  Serial.println(udpPort);
  
} //end void setup()


void loop() {
  
  //Get the state of all four pins
  RXState = digitalRead(RX); //Toggle button for device 1 (LOW is pressed)
  TXState = digitalRead(TX); //Toggle button for device 2 (LOW is pressed)
  GPIO_2State = digitalRead(GPIO_2); //State of device 1 (on/Off)
  GPIO_0State = digitalRead(GPIO_0); //State of device 2 (on/Off)

  //Receive incoming Udp packet and parse information
  int pktSize = Udp.parsePacket();
  if (pktSize) {
//    Serial.print(Udp.remoteIP());
//    Serial.print(":");
//    Serial.println(Udp.remotePort());
    Udp.read(pktBuf, pktSize);
   }

  String packetbuffer (pktBuf);

  //What to do with Udp packet
  if (packetbuffer.startsWith(first_deviceId)) {  //Toggle first_deviceId
    String device_Id = (first_deviceId);
    toggle(device_Id);
    String packetbuffer = "";
    for (int i = 0; i<25; i++){
      pktBuf[i] = (char) 0;
      }
    Udp.flush();
    delay(1000);
        
    } else if (packetbuffer.startsWith(second_deviceId)) {  //Toggle second_deviceId
      String device_Id = (second_deviceId);
      toggle(device_Id);
      String packetbuffer = "";
      for (int i = 0; i<25; i++){
        pktBuf[i] = (char) 0;
        }
      Udp.flush();
      delay(1000);
    }

  if (RXState ==LOW && TXState == LOW) {  //If RX & TX are LOW then reset the ESP into AP mode
    WiFiManager wifiManager;
//    SPIFFS.format();
    delay(1000);
    wifiManager.resetSettings();
    delay(1000);
    {
      ESP.reset();  //reset and try again, or maybe put it to deep sleep
      delay(5000);
    }
    
  } else if (RXState == LOW && TXState == HIGH) {  //Else if RX is LOW and TX is HIGH flip device_id 1
    digitalWrite(GPIO_2, !GPIO_2State);
    delay(1000);
    
  } else if (RXState == HIGH && TXState == LOW) {  // Else if RX is HIGH and TX is LOW flip device_id 2
    digitalWrite(GPIO_0, !GPIO_0State);
    delay(1000);
  }

  webSocket.loop();
  
  if(isConnected) {
    uint64_t now = millis();
      
    // Send heartbeat in order to avoid disconnections during ISP resetting IPs over night.
    if((now - heartbeatTimestamp) > HEARTBEAT_INTERVAL) {
      heartbeatTimestamp = now;
      webSocket.sendTXT("H");          
    }
  }   
}