Added Software

Software/libraries/ArduinoOTA/ArduinoOTA.cpp

@@ -0,0 +1,371 @@
+#ifndef LWIP_OPEN_SRC
+#define LWIP_OPEN_SRC
+#endif
+#include <functional>
+#include <WiFiUdp.h>
+#include "ArduinoOTA.h"
+#include "MD5Builder.h"
+#include "StreamString.h"
+
+extern "C" {
+  #include "osapi.h"
+  #include "ets_sys.h"
+  #include "user_interface.h"
+}
+
+#include "lwip/opt.h"
+#include "lwip/udp.h"
+#include "lwip/inet.h"
+#include "lwip/igmp.h"
+#include "lwip/mem.h"
+#include "include/UdpContext.h"
+
+#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_MDNS)
+#include <ESP8266mDNS.h>
+#endif
+
+#ifdef DEBUG_ESP_OTA
+#ifdef DEBUG_ESP_PORT
+#define OTA_DEBUG DEBUG_ESP_PORT
+#endif
+#endif
+
+ArduinoOTAClass::ArduinoOTAClass()
+{
+}
+
+ArduinoOTAClass::~ArduinoOTAClass(){
+  if(_udp_ota){
+    _udp_ota->unref();
+    _udp_ota = 0;
+  }
+}
+
+void ArduinoOTAClass::onStart(THandlerFunction fn) {
+    _start_callback = fn;
+}
+
+void ArduinoOTAClass::onEnd(THandlerFunction fn) {
+    _end_callback = fn;
+}
+
+void ArduinoOTAClass::onProgress(THandlerFunction_Progress fn) {
+    _progress_callback = fn;
+}
+
+void ArduinoOTAClass::onError(THandlerFunction_Error fn) {
+    _error_callback = fn;
+}
+
+void ArduinoOTAClass::setPort(uint16_t port) {
+  if (!_initialized && !_port && port) {
+    _port = port;
+  }
+}
+
+void ArduinoOTAClass::setHostname(const char * hostname) {
+  if (!_initialized && !_hostname.length() && hostname) {
+    _hostname = hostname;
+  }
+}
+
+String ArduinoOTAClass::getHostname() {
+  return _hostname;
+}
+
+void ArduinoOTAClass::setPassword(const char * password) {
+  if (!_initialized && !_password.length() && password) {
+    MD5Builder passmd5;
+    passmd5.begin();
+    passmd5.add(password);
+    passmd5.calculate();
+    _password = passmd5.toString();
+  }
+}
+
+void ArduinoOTAClass::setPasswordHash(const char * password) {
+  if (!_initialized && !_password.length() && password) {
+    _password = password;
+  }
+}
+
+void ArduinoOTAClass::setRebootOnSuccess(bool reboot){
+  _rebootOnSuccess = reboot;
+}
+
+void ArduinoOTAClass::begin(bool useMDNS) {
+  if (_initialized)
+    return;
+
+  _useMDNS = useMDNS;
+
+  if (!_hostname.length()) {
+    char tmp[15];
+    sprintf(tmp, "esp8266-%06x", ESP.getChipId());
+    _hostname = tmp;
+  }
+  if (!_port) {
+    _port = 8266;
+  }
+
+  if(_udp_ota){
+    _udp_ota->unref();
+    _udp_ota = 0;
+  }
+
+  _udp_ota = new UdpContext;
+  _udp_ota->ref();
+
+  if(!_udp_ota->listen(IP_ADDR_ANY, _port))
+    return;
+  _udp_ota->onRx(std::bind(&ArduinoOTAClass::_onRx, this));
+  
+#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_MDNS)
+  if(_useMDNS) {
+    MDNS.begin(_hostname.c_str());
+
+    if (_password.length()) {
+      MDNS.enableArduino(_port, true);
+    } else {
+      MDNS.enableArduino(_port);
+    }
+  }
+#endif
+  _initialized = true;
+  _state = OTA_IDLE;
+#ifdef OTA_DEBUG
+  OTA_DEBUG.printf("OTA server at: %s.local:%u\n", _hostname.c_str(), _port);
+#endif
+}
+
+int ArduinoOTAClass::parseInt(){
+  char data[16];
+  uint8_t index;
+  char value;
+  while(_udp_ota->peek() == ' ') _udp_ota->read();
+  for(index = 0; index < sizeof(data); ++index){
+    value = _udp_ota->peek();
+    if(value < '0' || value > '9'){
+      data[index] = '\0';
+      return atoi(data);
+    }
+    data[index] = _udp_ota->read();
+  }
+  return 0;
+}
+
+String ArduinoOTAClass::readStringUntil(char end){
+  String res;
+  int value;
+  while(true){
+    value = _udp_ota->read();
+    if(value < 0 || value == '\0' || value == end){
+      return res;
+    }
+    res += static_cast<char>(value);
+  }
+  return res;
+}
+
+void ArduinoOTAClass::_onRx(){
+  if(!_udp_ota->next()) return;
+  IPAddress ota_ip;
+
+  if (_state == OTA_IDLE) {
+    int cmd = parseInt();
+    if (cmd != U_FLASH && cmd != U_FS)
+      return;
+    _ota_ip = _udp_ota->getRemoteAddress();
+    _cmd  = cmd;
+    _ota_port = parseInt();
+    _ota_udp_port = _udp_ota->getRemotePort();
+    _size = parseInt();
+    _udp_ota->read();
+    _md5 = readStringUntil('\n');
+    _md5.trim();
+    if(_md5.length() != 32)
+      return;
+
+    ota_ip = _ota_ip;
+
+    if (_password.length()){
+      MD5Builder nonce_md5;
+      nonce_md5.begin();
+      nonce_md5.add(String(micros()));
+      nonce_md5.calculate();
+      _nonce = nonce_md5.toString();
+
+      char auth_req[38];
+      sprintf(auth_req, "AUTH %s", _nonce.c_str());
+      _udp_ota->append((const char *)auth_req, strlen(auth_req));
+      _udp_ota->send(ota_ip, _ota_udp_port);
+      _state = OTA_WAITAUTH;
+      return;
+    } else {
+      _state = OTA_RUNUPDATE;
+    }
+  } else if (_state == OTA_WAITAUTH) {
+    int cmd = parseInt();
+    if (cmd != U_AUTH) {
+      _state = OTA_IDLE;
+      return;
+    }
+    _udp_ota->read();
+    String cnonce = readStringUntil(' ');
+    String response = readStringUntil('\n');
+    if (cnonce.length() != 32 || response.length() != 32) {
+      _state = OTA_IDLE;
+      return;
+    }
+
+    String challenge = _password + ':' + String(_nonce) + ':' + cnonce;
+    MD5Builder _challengemd5;
+    _challengemd5.begin();
+    _challengemd5.add(challenge);
+    _challengemd5.calculate();
+    String result = _challengemd5.toString();
+
+    ota_ip = _ota_ip;
+    if(result.equalsConstantTime(response)) {
+      _state = OTA_RUNUPDATE;
+    } else {
+      _udp_ota->append("Authentication Failed", 21);
+      _udp_ota->send(ota_ip, _ota_udp_port);
+      if (_error_callback) _error_callback(OTA_AUTH_ERROR);
+      _state = OTA_IDLE;
+    }
+  }
+
+  while(_udp_ota->next()) _udp_ota->flush();
+}
+
+void ArduinoOTAClass::_runUpdate() {
+  IPAddress ota_ip = _ota_ip;
+
+  if (!Update.begin(_size, _cmd)) {
+#ifdef OTA_DEBUG
+    OTA_DEBUG.println("Update Begin Error");
+#endif
+    if (_error_callback) {
+      _error_callback(OTA_BEGIN_ERROR);
+    }
+    
+    StreamString ss;
+    Update.printError(ss);
+    _udp_ota->append("ERR: ", 5);
+    _udp_ota->append(ss.c_str(), ss.length());
+    _udp_ota->send(ota_ip, _ota_udp_port);
+    delay(100);
+    _udp_ota->listen(IP_ADDR_ANY, _port);
+    _state = OTA_IDLE;
+    return;
+  }
+  _udp_ota->append("OK", 2);
+  _udp_ota->send(ota_ip, _ota_udp_port);
+  delay(100);
+
+  Update.setMD5(_md5.c_str());
+  WiFiUDP::stopAll();
+  WiFiClient::stopAll();
+
+  if (_start_callback) {
+    _start_callback();
+  }
+  if (_progress_callback) {
+    _progress_callback(0, _size);
+  }
+
+  WiFiClient client;
+  if (!client.connect(_ota_ip, _ota_port)) {
+#ifdef OTA_DEBUG
+    OTA_DEBUG.printf("Connect Failed\n");
+#endif
+    _udp_ota->listen(IP_ADDR_ANY, _port);
+    if (_error_callback) {
+      _error_callback(OTA_CONNECT_ERROR);
+    }
+    _state = OTA_IDLE;
+  }
+  // OTA sends little packets
+  client.setNoDelay(true);
+
+  uint32_t written, total = 0;
+  while (!Update.isFinished() && (client.connected() || client.available())) {
+    int waited = 1000;
+    while (!client.available() && waited--)
+      delay(1);
+    if (!waited){
+#ifdef OTA_DEBUG
+      OTA_DEBUG.printf("Receive Failed\n");
+#endif
+      _udp_ota->listen(IP_ADDR_ANY, _port);
+      if (_error_callback) {
+        _error_callback(OTA_RECEIVE_ERROR);
+      }
+      _state = OTA_IDLE;
+    }
+    written = Update.write(client);
+    if (written > 0) {
+      client.print(written, DEC);
+      total += written;
+      if(_progress_callback) {
+        _progress_callback(total, _size);
+      }
+    }
+  }
+
+  if (Update.end()) {
+    // Ensure last count packet has been sent out and not combined with the final OK
+    client.flush();
+    delay(1000);
+    client.print("OK");
+    client.flush();
+    delay(1000);
+    client.stop();
+#ifdef OTA_DEBUG
+    OTA_DEBUG.printf("Update Success\n");
+#endif
+    if (_end_callback) {
+      _end_callback();
+    }
+    if(_rebootOnSuccess){
+#ifdef OTA_DEBUG
+    OTA_DEBUG.printf("Rebooting...\n");
+#endif
+      //let serial/network finish tasks that might be given in _end_callback
+      delay(100);
+      ESP.restart();
+    }
+  } else {
+    _udp_ota->listen(IP_ADDR_ANY, _port);
+    if (_error_callback) {
+      _error_callback(OTA_END_ERROR);
+    }
+    Update.printError(client);
+#ifdef OTA_DEBUG
+    Update.printError(OTA_DEBUG);
+#endif
+    _state = OTA_IDLE;
+  }
+}
+
+//this needs to be called in the loop()
+void ArduinoOTAClass::handle() {
+  if (_state == OTA_RUNUPDATE) {
+    _runUpdate();
+    _state = OTA_IDLE;
+  }
+
+#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_MDNS)
+  if(_useMDNS)
+    MDNS.update(); //handle MDNS update as well, given that ArduinoOTA relies on it anyways
+#endif
+}
+
+int ArduinoOTAClass::getCommand() {
+  return _cmd;
+}
+
+#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_ARDUINOOTA)
+ArduinoOTAClass ArduinoOTA;
+#endif

Software/libraries/ArduinoOTA/ArduinoOTA.h

@@ -0,0 +1,103 @@
+#ifndef __ARDUINO_OTA_H
+#define __ARDUINO_OTA_H
+
+#include <ESP8266WiFi.h>
+#include <WiFiUdp.h>
+#include <functional>
+
+class UdpContext;
+
+typedef enum {
+  OTA_IDLE,
+  OTA_WAITAUTH,
+  OTA_RUNUPDATE
+} ota_state_t;
+
+typedef enum {
+  OTA_AUTH_ERROR,
+  OTA_BEGIN_ERROR,
+  OTA_CONNECT_ERROR,
+  OTA_RECEIVE_ERROR,
+  OTA_END_ERROR
+} ota_error_t;
+
+class ArduinoOTAClass
+{
+  public:
+	typedef std::function<void(void)> THandlerFunction;
+	typedef std::function<void(ota_error_t)> THandlerFunction_Error;
+	typedef std::function<void(unsigned int, unsigned int)> THandlerFunction_Progress;
+
+    ArduinoOTAClass();
+    ~ArduinoOTAClass();
+
+    //Sets the service port. Default 8266
+    void setPort(uint16_t port);
+
+    //Sets the device hostname. Default esp8266-xxxxxx
+    void setHostname(const char *hostname);
+    String getHostname();
+
+    //Sets the password that will be required for OTA. Default NULL
+    void setPassword(const char *password);
+
+    //Sets the password as above but in the form MD5(password). Default NULL
+    void setPasswordHash(const char *password);
+
+    //Sets if the device should be rebooted after successful update. Default true
+    void setRebootOnSuccess(bool reboot);
+
+    //This callback will be called when OTA connection has begun
+    void onStart(THandlerFunction fn);
+
+    //This callback will be called when OTA has finished
+    void onEnd(THandlerFunction fn);
+
+    //This callback will be called when OTA encountered Error
+    void onError(THandlerFunction_Error fn);
+
+    //This callback will be called when OTA is receiving data
+    void onProgress(THandlerFunction_Progress fn);
+
+    //Starts the ArduinoOTA service
+    void begin(bool useMDNS = true);
+
+    //Call this in loop() to run the service. Also calls MDNS.update() when begin() or begin(true) is used.
+    void handle();
+
+    //Gets update command type after OTA has started. Either U_FLASH or U_FS
+    int getCommand();
+
+  private:
+    void _runUpdate(void);
+    void _onRx(void);
+    int parseInt(void);
+    String readStringUntil(char end);
+
+    int _port = 0;
+    String _password;
+    String _hostname;
+    String _nonce;
+    UdpContext *_udp_ota = nullptr;
+    bool _initialized = false;
+    bool _rebootOnSuccess = true;
+    bool _useMDNS = true;
+    ota_state_t _state = OTA_IDLE;
+    int _size = 0;
+    int _cmd = 0;
+    uint16_t _ota_port = 0;
+    uint16_t _ota_udp_port = 0;
+    IPAddress _ota_ip;
+    String _md5;
+
+    THandlerFunction _start_callback = nullptr;
+    THandlerFunction _end_callback = nullptr;
+    THandlerFunction_Error _error_callback = nullptr;
+    THandlerFunction_Progress _progress_callback = nullptr;
+};
+
+#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_ARDUINOOTA)
+extern ArduinoOTAClass ArduinoOTA;
+#endif
+
+#endif /* __ARDUINO_OTA_H */

Software/libraries/ArduinoOTA/examples/BasicOTA/BasicOTA.ino

@@ -0,0 +1,77 @@
+#include <ESP8266WiFi.h>
+#include <ESP8266mDNS.h>
+#include <WiFiUdp.h>
+#include <ArduinoOTA.h>
+
+#ifndef STASSID
+#define STASSID "your-ssid"
+#define STAPSK  "your-password"
+#endif
+
+const char* ssid = STASSID;
+const char* password = STAPSK;
+
+void setup() {
+  Serial.begin(115200);
+  Serial.println("Booting");
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
+  while (WiFi.waitForConnectResult() != WL_CONNECTED) {
+    Serial.println("Connection Failed! Rebooting...");
+    delay(5000);
+    ESP.restart();
+  }
+
+  // Port defaults to 8266
+  // ArduinoOTA.setPort(8266);
+
+  // Hostname defaults to esp8266-[ChipID]
+  // ArduinoOTA.setHostname("myesp8266");
+
+  // No authentication by default
+  // ArduinoOTA.setPassword("admin");
+
+  // Password can be set with it's md5 value as well
+  // MD5(admin) = 21232f297a57a5a743894a0e4a801fc3
+  // ArduinoOTA.setPasswordHash("21232f297a57a5a743894a0e4a801fc3");
+
+  ArduinoOTA.onStart([]() {
+    String type;
+    if (ArduinoOTA.getCommand() == U_FLASH) {
+      type = "sketch";
+    } else { // U_FS
+      type = "filesystem";
+    }
+
+    // NOTE: if updating FS this would be the place to unmount FS using FS.end()
+    Serial.println("Start updating " + type);
+  });
+  ArduinoOTA.onEnd([]() {
+    Serial.println("\nEnd");
+  });
+  ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
+    Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
+  });
+  ArduinoOTA.onError([](ota_error_t error) {
+    Serial.printf("Error[%u]: ", error);
+    if (error == OTA_AUTH_ERROR) {
+      Serial.println("Auth Failed");
+    } else if (error == OTA_BEGIN_ERROR) {
+      Serial.println("Begin Failed");
+    } else if (error == OTA_CONNECT_ERROR) {
+      Serial.println("Connect Failed");
+    } else if (error == OTA_RECEIVE_ERROR) {
+      Serial.println("Receive Failed");
+    } else if (error == OTA_END_ERROR) {
+      Serial.println("End Failed");
+    }
+  });
+  ArduinoOTA.begin();
+  Serial.println("Ready");
+  Serial.print("IP address: ");
+  Serial.println(WiFi.localIP());
+}
+
+void loop() {
+  ArduinoOTA.handle();
+}

Software/libraries/ArduinoOTA/examples/OTALeds/OTALeds.ino

@@ -0,0 +1,75 @@
+#include <ESP8266WiFi.h>
+#include <ESP8266mDNS.h>
+#include <WiFiUdp.h>
+#include <ArduinoOTA.h>
+
+#ifndef STASSID
+#define STASSID "your-ssid"
+#define STAPSK  "your-password"
+#endif
+
+const char* ssid = STASSID;
+const char* password = STAPSK;
+const char* host = "OTA-LEDS";
+
+int led_pin = 13;
+#define N_DIMMERS 3
+int dimmer_pin[] = {14, 5, 15};
+
+void setup() {
+  Serial.begin(115200);
+
+  /* switch on led */
+  pinMode(led_pin, OUTPUT);
+  digitalWrite(led_pin, LOW);
+
+  Serial.println("Booting");
+  WiFi.mode(WIFI_STA);
+
+  WiFi.begin(ssid, password);
+
+  while (WiFi.waitForConnectResult() != WL_CONNECTED) {
+    WiFi.begin(ssid, password);
+    Serial.println("Retrying connection...");
+  }
+  /* switch off led */
+  digitalWrite(led_pin, HIGH);
+
+  /* configure dimmers, and OTA server events */
+  analogWriteRange(1000);
+  analogWrite(led_pin, 990);
+
+  for (int i = 0; i < N_DIMMERS; i++) {
+    pinMode(dimmer_pin[i], OUTPUT);
+    analogWrite(dimmer_pin[i], 50);
+  }
+
+  ArduinoOTA.setHostname(host);
+  ArduinoOTA.onStart([]() { // switch off all the PWMs during upgrade
+    for (int i = 0; i < N_DIMMERS; i++) {
+      analogWrite(dimmer_pin[i], 0);
+    }
+    analogWrite(led_pin, 0);
+  });
+
+  ArduinoOTA.onEnd([]() { // do a fancy thing with our board led at end
+    for (int i = 0; i < 30; i++) {
+      analogWrite(led_pin, (i * 100) % 1001);
+      delay(50);
+    }
+  });
+
+  ArduinoOTA.onError([](ota_error_t error) {
+    (void)error;
+    ESP.restart();
+  });
+
+  /* setup the OTA server */
+  ArduinoOTA.begin();
+  Serial.println("Ready");
+
+}
+
+void loop() {
+  ArduinoOTA.handle();
+}

Software/libraries/ArduinoOTA/keywords.txt

@@ -0,0 +1,26 @@
+#######################################
+# Syntax Coloring Map For Ultrasound
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+ArduinoOTA	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+begin	KEYWORD2
+setup	KEYWORD2
+handle	KEYWORD2
+onStart	KEYWORD2
+onEnd	KEYWORD2
+onError	KEYWORD2
+onProgress	KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+

Software/libraries/ArduinoOTA/library.properties

@@ -0,0 +1,10 @@
+name=ArduinoOTA
+version=1.0
+author=Ivan Grokhotkov and Miguel Angel Ajo
+maintainer=Ivan Grokhtkov <ivan@esp8266.com>
+sentence=Enables Over The Air upgrades, via wifi and espota.py UDP request/TCP download.
+paragraph=With this library you can enable your sketch to be upgraded over network. Includes mdns anounces to get discovered by the arduino IDE.
+category=Communication
+url=
+architectures=esp8266
+dot_a_linkage=true