Merge branch 'master' into poc-cache-config

Author: mhightower83

cores/esp8266/IPAddress.h

@@ -32,6 +32,13 @@
 struct ip_addr: ipv4_addr { };
 #endif // !LWIP_IPV6
 
+// to display a netif id with printf:
+#define NETIFID_STR "%c%c%u"
+#define NETIFID_VAL(netif) \
+ ((netif)? (netif)->name[0]: '-'), \
+ ((netif)? (netif)->name[1]: '-'), \
+ ((netif)? netif_get_index(netif): 42)
+
 // A class to make it easier to handle and pass around IP addresses
 // IPv6 update:
 // IPAddress is now a decorator class for lwIP's ip_addr_t

cores/esp8266/LwipIntf.h

@@ -0,0 +1,26 @@
+
+#ifndef _LWIPINTF_H
+#define _LWIPINTF_H
+
+#include <lwip/netif.h>
+
+#include <functional>
+
+class LwipIntf
+{
+public:
+
+ using CBType = std::function <void(netif*)>;
+
+ static bool stateUpCB (LwipIntf::CBType&& cb);
+
+private:
+
+ LwipIntf () { } // private, cannot be directly allocated
+
+protected:
+
+ static bool stateChangeSysCB (LwipIntf::CBType&& cb);
+};
+
+#endif // _LWIPINTF_H

cores/esp8266/LwipIntfCB.cpp

@@ -0,0 +1,42 @@
+
+#include <LwipIntf.h>
+#include <Schedule.h>
+#include <debug.h>
+
+#define NETIF_STATUS_CB_SIZE 3
+
+static int netifStatusChangeListLength = 0;
+LwipIntf::CBType netifStatusChangeList [NETIF_STATUS_CB_SIZE];
+
+extern "C" void netif_status_changed (struct netif* netif)
+{
+ // override the default empty weak function
+ for (int i = 0; i < netifStatusChangeListLength; i++)
+ netifStatusChangeList[i](netif);
+}
+
+bool LwipIntf::stateChangeSysCB (LwipIntf::CBType&& cb)
+{
+ if (netifStatusChangeListLength >= NETIF_STATUS_CB_SIZE)
+ {
+#if defined(DEBUG_ESP_CORE)
+ DEBUGV("NETIF_STATUS_CB_SIZE is too low\n");
+#endif
+ return false;
+ }
+
+ netifStatusChangeList[netifStatusChangeListLength++] = cb;
+ return true;
+}
+
+bool LwipIntf::stateUpCB (LwipIntf::CBType&& cb)
+{
+ return stateChangeSysCB([cb](netif* nif)
+ {
+ if (netif_is_up(nif))
+ schedule_function([cb, nif]()
+ {
+ cb(nif);
+ });
+ });
+}

cores/esp8266/Print.cpp

@@ -146,35 +146,39 @@ size_t Print::print(unsigned int n, int base) {
 }
 
 size_t Print::print(long n, int base) {
- if(base == 0) {
- return write(n);
- } else if(base == 10) {
- if(n < 0) {
- int t = print('-');
- n = -n;
- return printNumber(n, 10) + t;
- }
- return printNumber(n, 10);
- } else {
- return printNumber(n, base);
+ int t = 0;
+ if (base == 10 && n < 0) {
+ t = print('-');
+ n = -n;
  }
+ return printNumber(static_cast<unsigned long>(n), base) + t;
 }
 
 size_t Print::print(unsigned long n, int base) {
- if(base == 0)
+ if (base == 0) {
  return write(n);
- else
-  return printNumber(n, base);
+ }
+ return printNumber(n, base);
 }
 
-size_t Print::print(double n, int digits) {
- return printFloat(n, digits);
+size_t Print::print(long long n, int base) {
+ int t = 0;
+ if (base == 10 && n < 0) {
+ t = print('-');
+ n = -n;
+ }
+ return printNumber(static_cast<unsigned long long>(n), base) + t;
 }
 
-size_t Print::println(const __FlashStringHelper *ifsh) {
- size_t n = print(ifsh);
- n += println();
- return n;
+size_t Print::print(unsigned long long n, int base) {
+ if (base == 0) {
+ return write(n);
+ }
+ return printNumber(n, base);
+}
+
+size_t Print::print(double n, int digits) {
+ return printNumber(n, digits);
 }
 
 size_t Print::print(const Printable& x) {
@@ -185,89 +189,90 @@ size_t Print::println(void) {
  return print("\r\n");
 }
 
+size_t Print::println(const __FlashStringHelper* ifsh) {
+ return _println<const __FlashStringHelper*>(ifsh);
+}
+
 size_t Print::println(const String &s) {
- size_t n = print(s);
- n += println();
- return n;
+ return _println(s);
 }
 
 size_t Print::println(const char c[]) {
- size_t n = print(c);
- n += println();
- return n;
+ return _println(c);
 }
 
 size_t Print::println(char c) {
- size_t n = print(c);
- n += println();
- return n;
+ return _println(c);
 }
 
 size_t Print::println(unsigned char b, int base) {
- size_t n = print(b, base);
- n += println();
- return n;
+ return _println(b, base);
 }
 
 size_t Print::println(int num, int base) {
- size_t n = print(num, base);
- n += println();
- return n;
+ return _println(num, base);
 }
 
 size_t Print::println(unsigned int num, int base) {
- size_t n = print(num, base);
- n += println();
- return n;
+ return _println(num, base);
 }
 
 size_t Print::println(long num, int base) {
- size_t n = print(num, base);
- n += println();
- return n;
+ return _println(num, base);
 }
 
 size_t Print::println(unsigned long num, int base) {
- size_t n = print(num, base);
- n += println();
- return n;
+ return _println(num, base);
+}
+
+size_t Print::println(long long num, int base) {
+ return _println(num, base);
+}
+
+size_t Print::println(unsigned long long num, int base) {
+ return _println(num, base);
 }
 
 size_t Print::println(double num, int digits) {
- size_t n = print(num, digits);
- n += println();
- return n;
+ return _println(num, digits);
 }
 
 size_t Print::println(const Printable& x) {
- size_t n = print(x);
- n += println();
- return n;
+ return _println<const Printable&>(x);
 }
 
 // Private Methods /////////////////////////////////////////////////////////////
 
-size_t Print::printNumber(unsigned long n, uint8_t base) {
- char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
- char *str = &buf[sizeof(buf) - 1];
+template<typename T, typename... P> inline size_t Print::_println(T v, P... args)
+{
+ size_t n = print(v, args...);
+ n += println();
+ return n;
+};
+
+template<typename T> size_t Print::printNumber(T n, uint8_t base) {
+ char buf[8 * sizeof(n) + 1]; // Assumes 8-bit chars plus zero byte.
+ char* str = &buf[sizeof(buf) - 1];
 
  *str = '\0';
 
  // prevent crash if called with base == 1
- if(base < 2)
+ if (base < 2) {
  base = 10;
+ }
 
  do {
- unsigned long m = n;
+ auto m = n;
  n /= base;
  char c = m - base * n;
+
  *--str = c < 10 ? c + '0' : c + 'A' - 10;
- } while(n);
+ } while (n);
 
  return write(str);
 }
 
-size_t Print::printFloat(double number, uint8_t digits) {
+template<> size_t Print::printNumber(double number, uint8_t digits) {
  char buf[40];
  return write(dtostrf(number, 0, digits, buf));
 }

cores/esp8266/Print.h

@@ -36,9 +36,9 @@
 class Print {
  private:
  int write_error;
- size_t printNumber(unsigned long, uint8_t);
- size_t printFloat(double, uint8_t);
- protected:
+ template<typename T> size_t printNumber(T n, uint8_t base);
+ template<typename T, typename... P> inline size_t _println(T v, P... args);
+protected:
  void setWriteError(int err = 1) {
  write_error = err;
  }
@@ -71,6 +71,8 @@ class Print {
  inline size_t write(unsigned int t) { return write((uint8_t)t); }
  inline size_t write(long t) { return write((uint8_t)t); }
  inline size_t write(unsigned long t) { return write((uint8_t)t); }
+ inline size_t write(long long t) { return write((uint8_t)t); }
+ inline size_t write(unsigned long long t) { return write((uint8_t)t); }
  // Enable write(char) to fall through to write(uint8_t)
  inline size_t write(char c) { return write((uint8_t) c); }
  inline size_t write(int8_t c) { return write((uint8_t) c); }
@@ -86,6 +88,8 @@ class Print {
  size_t print(unsigned int, int = DEC);
  size_t print(long, int = DEC);
  size_t print(unsigned long, int = DEC);
+ size_t print(long long, int = DEC);
+ size_t print(unsigned long long, int = DEC);
  size_t print(double, int = 2);
  size_t print(const Printable&);
 
@@ -98,11 +102,15 @@ class Print {
  size_t println(unsigned int, int = DEC);
  size_t println(long, int = DEC);
  size_t println(unsigned long, int = DEC);
+ size_t println(long long, int = DEC);
+ size_t println(unsigned long long, int = DEC);
  size_t println(double, int = 2);
  size_t println(const Printable&);
  size_t println(void);
 
  virtual void flush() { /* Empty implementation for backward compatibility */ }
 };
 
+template<> size_t Print::printNumber(double number, uint8_t digits);
+
 #endif