initial import

cores/esp32/Arduino.h

@@ -0,0 +1,63 @@
+/*
+ Arduino.h - Main include file for the Arduino SDK
+ Copyright (c) 2005-2013 Arduino Team.  All right reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef Arduino_h
+#define Arduino_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/semphr.h"
+#include "esp32-hal.h"
+#include "pins_arduino.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+
+typedef bool boolean;
+typedef uint8_t byte;
+
+#include "binary.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+#include "WCharacter.h"
+#include "WString.h"
+#include "Stream.h"
+#include "Printable.h"
+#include "Print.h"
+#include "IPAddress.h"
+#include "Client.h"
+#include "Server.h"
+#include "Udp.h"
+#include "HardwareSerial.h"
+#include "Esp.h"
+
+#endif /* _ESP32_CORE_ARDUINO_H_ */

cores/esp32/Client.h

@@ -0,0 +1,48 @@
+/*
+ Client.h - Base class that provides Client
+ Copyright (c) 2011 Adrian McEwen.  All right reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef client_h
+#define client_h
+#include "Print.h"
+#include "Stream.h"
+#include "IPAddress.h"
+
+class Client: public Stream
+{
+public:
+    virtual int connect(IPAddress ip, uint16_t port) =0;
+    virtual int connect(const char *host, uint16_t port) =0;
+    virtual size_t write(uint8_t) =0;
+    virtual size_t write(const uint8_t *buf, size_t size) =0;
+    virtual int available() = 0;
+    virtual int read() = 0;
+    virtual int read(uint8_t *buf, size_t size) = 0;
+    virtual int peek() = 0;
+    virtual void flush() = 0;
+    virtual void stop() = 0;
+    virtual uint8_t connected() = 0;
+    virtual operator bool() = 0;
+protected:
+    uint8_t* rawIPAddress(IPAddress& addr)
+    {
+        return addr.raw_address();
+    }
+};
+
+#endif

cores/esp32/Esp.cpp

@@ -0,0 +1,223 @@
+/*
+ Esp.cpp - ESP31B-specific APIs
+ Copyright (c) 2015 Ivan Grokhotkov. All rights reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "Arduino.h"
+#include "Esp.h"
+#include "rom/spi_flash.h"
+#include <memory>
+
+//#define DEBUG_SERIAL Serial
+
+
+/**
+ * User-defined Literals
+ *  usage:
+ *
+ *   uint32_t = test = 10_MHz; // --> 10000000
+ */
+
+unsigned long long operator"" _kHz(unsigned long long x)
+{
+    return x * 1000;
+}
+
+unsigned long long operator"" _MHz(unsigned long long x)
+{
+    return x * 1000 * 1000;
+}
+
+unsigned long long operator"" _GHz(unsigned long long x)
+{
+    return x * 1000 * 1000 * 1000;
+}
+
+unsigned long long operator"" _kBit(unsigned long long x)
+{
+    return x * 1024;
+}
+
+unsigned long long operator"" _MBit(unsigned long long x)
+{
+    return x * 1024 * 1024;
+}
+
+unsigned long long operator"" _GBit(unsigned long long x)
+{
+    return x * 1024 * 1024 * 1024;
+}
+
+unsigned long long operator"" _kB(unsigned long long x)
+{
+    return x * 1024;
+}
+
+unsigned long long operator"" _MB(unsigned long long x)
+{
+    return x * 1024 * 1024;
+}
+
+unsigned long long operator"" _GB(unsigned long long x)
+{
+    return x * 1024 * 1024 * 1024;
+}
+
+
+EspClass ESP;
+
+uint32_t EspClass::getCycleCount()
+{
+    uint32_t ccount;
+    __asm__ __volatile__("esync; rsr %0,ccount":"=a" (ccount));
+    return ccount;
+}
+
+void EspClass::restart(void)
+{
+    system_restart();
+}
+
+uint32_t EspClass::getFreeHeap(void)
+{
+    return system_get_free_heap_size();
+}
+
+const char * EspClass::getSdkVersion(void)
+{
+    return system_get_sdk_version();
+}
+
+uint32_t EspClass::getFlashChipSize(void)
+{
+    uint32_t data;
+    uint8_t * bytes = (uint8_t *) &data;
+    // read first 4 byte (magic byte + flash config)
+    if(SPIRead(0x0000, &data, 4) == SPI_FLASH_RESULT_OK) {
+        return magicFlashChipSize((bytes[3] & 0xf0) >> 4);
+    }
+    return 0;
+}
+
+uint32_t EspClass::getFlashChipSpeed(void)
+{
+    uint32_t data;
+    uint8_t * bytes = (uint8_t *) &data;
+    // read first 4 byte (magic byte + flash config)
+    if(SPIRead(0x0000, &data, 4) == SPI_FLASH_RESULT_OK) {
+        return magicFlashChipSpeed(bytes[3] & 0x0F);
+    }
+    return 0;
+}
+
+FlashMode_t EspClass::getFlashChipMode(void)
+{
+    FlashMode_t mode = FM_UNKNOWN;
+    uint32_t data;
+    uint8_t * bytes = (uint8_t *) &data;
+    // read first 4 byte (magic byte + flash config)
+    if(SPIRead(0x0000, &data, 4) == SPI_FLASH_RESULT_OK) {
+        mode = magicFlashChipMode(bytes[2]);
+    }
+    return mode;
+}
+
+uint32_t EspClass::magicFlashChipSize(uint8_t byte)
+{
+    switch(byte & 0x0F) {
+    case 0x0: // 4 Mbit (512KB)
+        return (512_kB);
+    case 0x1: // 2 MBit (256KB)
+        return (256_kB);
+    case 0x2: // 8 MBit (1MB)
+        return (1_MB);
+    case 0x3: // 16 MBit (2MB)
+        return (2_MB);
+    case 0x4: // 32 MBit (4MB)
+        return (4_MB);
+    case 0x5: // 64 MBit (8MB)
+        return (8_MB);
+    case 0x6: // 128 MBit (16MB)
+        return (16_MB);
+    case 0x7: // 256 MBit (32MB)
+        return (32_MB);
+    default: // fail?
+        return 0;
+    }
+}
+
+uint32_t EspClass::magicFlashChipSpeed(uint8_t byte)
+{
+    switch(byte & 0x0F) {
+    case 0x0: // 40 MHz
+        return (40_MHz);
+    case 0x1: // 26 MHz
+        return (26_MHz);
+    case 0x2: // 20 MHz
+        return (20_MHz);
+    case 0xf: // 80 MHz
+        return (80_MHz);
+    default: // fail?
+        return 0;
+    }
+}
+
+FlashMode_t EspClass::magicFlashChipMode(uint8_t byte)
+{
+    FlashMode_t mode = (FlashMode_t) byte;
+    if(mode > FM_DOUT) {
+        mode = FM_UNKNOWN;
+    }
+    return mode;
+}
+
+bool EspClass::eraseConfig(void)
+{
+    bool ret = true;
+    size_t cfgAddr = (getFlashChipSize() - 0x4000);
+    size_t cfgSize = (8*1024);
+
+    while(cfgSize) {
+
+        if(SPIEraseSector((cfgAddr / 4096)) != SPI_FLASH_RESULT_OK) {
+            ret = false;
+        }
+
+        cfgSize -= 4096;
+        cfgAddr += 4096;
+    }
+
+    return ret;
+}
+
+bool EspClass::flashEraseSector(uint32_t sector)
+{
+    int rc = SPIEraseSector(sector);
+    return rc == 0;
+}
+
+bool EspClass::flashWrite(uint32_t offset, uint32_t *data, size_t size)
+{
+    int rc = SPIWrite(offset, (uint32_t*) data, size);
+    return rc == 0;
+}
+
+bool EspClass::flashRead(uint32_t offset, uint32_t *data, size_t size)
+{
+    int rc = SPIRead(offset, (uint32_t*) data, size);
+    return rc == 0;
+}

cores/esp32/Esp.h

@@ -0,0 +1,85 @@
+/*
+ Esp.h - ESP31B-specific APIs
+ Copyright (c) 2015 Ivan Grokhotkov. All rights reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef ESP_H
+#define ESP_H
+
+#include <Arduino.h>
+
+/**
+ * AVR macros for WDT managment
+ */
+typedef enum {
+    WDTO_0MS    = 0,   //!< WDTO_0MS
+    WDTO_15MS   = 15,  //!< WDTO_15MS
+    WDTO_30MS   = 30,  //!< WDTO_30MS
+    WDTO_60MS   = 60,  //!< WDTO_60MS
+    WDTO_120MS  = 120, //!< WDTO_120MS
+    WDTO_250MS  = 250, //!< WDTO_250MS
+    WDTO_500MS  = 500, //!< WDTO_500MS
+    WDTO_1S     = 1000,//!< WDTO_1S
+    WDTO_2S     = 2000,//!< WDTO_2S
+    WDTO_4S     = 4000,//!< WDTO_4S
+    WDTO_8S     = 8000 //!< WDTO_8S
+} WDTO_t;
+
+
+typedef enum {
+    FM_QIO = 0x00,
+    FM_QOUT = 0x01,
+    FM_DIO = 0x02,
+    FM_DOUT = 0x03,
+    FM_UNKNOWN = 0xff
+} FlashMode_t;
+
+class EspClass
+{
+public:
+    EspClass() {}
+    ~EspClass() {}
+    void restart();
+    uint32_t getFreeHeap();
+
+    uint32_t getChipId();
+
+    const char * getSdkVersion();
+
+
+    uint8_t getCpuFreqMHz();
+
+    uint32_t getFlashChipSize();
+    uint32_t getFlashChipSpeed();
+    FlashMode_t getFlashChipMode();
+
+    uint32_t magicFlashChipSize(uint8_t byte);
+    uint32_t magicFlashChipSpeed(uint8_t byte);
+    FlashMode_t magicFlashChipMode(uint8_t byte);
+
+    bool flashEraseSector(uint32_t sector);
+    bool flashWrite(uint32_t offset, uint32_t *data, size_t size);
+    bool flashRead(uint32_t offset, uint32_t *data, size_t size);
+
+    bool eraseConfig();
+
+    uint32_t getCycleCount();
+};
+
+extern EspClass ESP;
+
+#endif //ESP_H

cores/esp32/HardwareSerial.cpp

@@ -0,0 +1,117 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <inttypes.h>
+
+#include "HardwareSerial.h"
+
+HardwareSerial Serial(0);
+
+HardwareSerial::HardwareSerial(int uart_nr) : _uart_nr(uart_nr), _uart(NULL) {}
+
+void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, int8_t txPin)
+{
+    if(_uart_nr == 0 && rxPin < 0 && txPin < 0) {
+        rxPin = 3;
+        txPin = 1;
+    }
+    _uart = uartBegin(_uart_nr, baud, config, rxPin, txPin, 256, false);
+}
+
+void HardwareSerial::end()
+{
+    if(uartGetDebug() == _uart_nr) {
+        uartSetDebug(0);
+    }
+    uartEnd(_uart);
+    _uart = 0;
+}
+
+void HardwareSerial::setDebugOutput(bool en)
+{
+    if(_uart == 0) {
+        return;
+    }
+    if(en) {
+        if(_uart->txEnabled) {
+            uartSetDebug(_uart);
+        } else {
+            uartSetDebug(0);
+        }
+    } else {
+        if(uartGetDebug() == _uart_nr) {
+            uartSetDebug(0);
+        }
+    }
+}
+
+bool HardwareSerial::isTxEnabled(void)
+{
+    if(_uart == 0) {
+        return false;
+    }
+    return _uart->txEnabled;
+}
+
+bool HardwareSerial::isRxEnabled(void)
+{
+    if(_uart == 0) {
+        return false;
+    }
+    return _uart->rxEnabled;
+}
+
+int HardwareSerial::available(void)
+{
+    if (_uart && _uart->rxEnabled) {
+        return uartAvailable(_uart);
+    }
+    return 0;
+}
+
+int HardwareSerial::peek(void)
+{
+    if (_uart && _uart->rxEnabled) {
+        return uartPeek(_uart);
+    }
+    return -1;
+}
+
+int HardwareSerial::read(void)
+{
+    if(_uart && _uart->rxEnabled) {
+        return uartRead(_uart);
+    }
+    return -1;
+}
+
+void HardwareSerial::flush()
+{
+    if(_uart == 0 || !_uart->txEnabled) {
+        return;
+    }
+    uartFlush(_uart);
+}
+
+size_t HardwareSerial::write(uint8_t c)
+{
+    if(_uart == 0 || !_uart->txEnabled) {
+        return 0;
+    }
+    uartWrite(_uart, c);
+    return 1;
+}
+
+size_t HardwareSerial::write(const uint8_t *buffer, size_t size)
+{
+    if(_uart == 0 || !_uart->txEnabled) {
+        return 0;
+    }
+    uartWriteBuf(_uart, buffer, size);
+    return size;
+}
+
+HardwareSerial::operator bool() const
+{
+    return _uart != 0;
+}

cores/esp32/HardwareSerial.h

@@ -0,0 +1,78 @@
+/*
+ HardwareSerial.h - Hardware serial library for Wiring
+ Copyright (c) 2006 Nicholas Zambetti.  All right reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+ Modified 28 September 2010 by Mark Sproul
+ Modified 14 August 2012 by Alarus
+ Modified 3 December 2013 by Matthijs Kooijman
+ Modified 18 December 2014 by Ivan Grokhotkov (esp8266 platform support)
+ Modified 31 March 2015 by Markus Sattler (rewrite the code for UART0 + UART1 support in ESP8266)
+ Modified 25 April 2015 by Thomas Flayols (add configuration different from 8N1 in ESP8266)
+ */
+
+#ifndef HardwareSerial_h
+#define HardwareSerial_h
+
+#include <inttypes.h>
+
+#include "Stream.h"
+#include "esp32-hal.h"
+
+class HardwareSerial: public Stream
+{
+public:
+    HardwareSerial(int uart_nr);
+
+    void begin(unsigned long baud, uint32_t config=SERIAL_8N1, int8_t rxPin=-1, int8_t txPin=-1);
+    void end();
+    int available(void);
+    int peek(void);
+    int read(void);
+    void flush(void);
+    size_t write(uint8_t);
+    size_t write(const uint8_t *buffer, size_t size);
+
+    inline size_t write(unsigned long n)
+    {
+        return write((uint8_t) n);
+    }
+    inline size_t write(long n)
+    {
+        return write((uint8_t) n);
+    }
+    inline size_t write(unsigned int n)
+    {
+        return write((uint8_t) n);
+    }
+    inline size_t write(int n)
+    {
+        return write((uint8_t) n);
+    }
+    operator bool() const;
+
+    void setDebugOutput(bool);
+    bool isTxEnabled(void);
+    bool isRxEnabled(void);
+
+protected:
+    int _uart_nr;
+    uart_t* _uart;
+};
+
+extern HardwareSerial Serial;
+
+#endif

cores/esp32/IPAddress.cpp

@@ -0,0 +1,81 @@
+/*
+ IPAddress.cpp - Base class that provides IPAddress
+ Copyright (c) 2011 Adrian McEwen.  All right reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <Wiring.h>
+#include <IPAddress.h>
+#include <Print.h>
+
+IPAddress::IPAddress()
+{
+    _address.dword = 0;
+}
+
+IPAddress::IPAddress(uint8_t first_octet, uint8_t second_octet, uint8_t third_octet, uint8_t fourth_octet)
+{
+    _address.bytes[0] = first_octet;
+    _address.bytes[1] = second_octet;
+    _address.bytes[2] = third_octet;
+    _address.bytes[3] = fourth_octet;
+}
+
+IPAddress::IPAddress(uint32_t address)
+{
+    _address.dword = address;
+}
+
+IPAddress::IPAddress(const uint8_t *address)
+{
+    memcpy(_address.bytes, address, sizeof(_address.bytes));
+}
+
+IPAddress& IPAddress::operator=(const uint8_t *address)
+{
+    memcpy(_address.bytes, address, sizeof(_address.bytes));
+    return *this;
+}
+
+IPAddress& IPAddress::operator=(uint32_t address)
+{
+    _address.dword = address;
+    return *this;
+}
+
+bool IPAddress::operator==(const uint8_t* addr) const
+{
+    return memcmp(addr, _address.bytes, sizeof(_address.bytes)) == 0;
+}
+
+size_t IPAddress::printTo(Print& p) const
+{
+    size_t n = 0;
+    for(int i = 0; i < 3; i++) {
+        n += p.print(_address.bytes[i], DEC);
+        n += p.print('.');
+    }
+    n += p.print(_address.bytes[3], DEC);
+    return n;
+}
+
+String IPAddress::toString()
+{
+    char szRet[16];
+    sprintf(szRet,"%u.%u.%u.%u", _address.bytes[0], _address.bytes[1], _address.bytes[2], _address.bytes[3]);
+    return String(szRet);
+}
+

cores/esp32/IPAddress.h

@@ -0,0 +1,93 @@
+/*
+ IPAddress.h - Base class that provides IPAddress
+ Copyright (c) 2011 Adrian McEwen.  All right reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef IPAddress_h
+#define IPAddress_h
+
+#include <stdint.h>
+#include <WString.h>
+#include <Printable.h>
+
+// A class to make it easier to handle and pass around IP addresses
+
+class IPAddress: public Printable
+{
+private:
+    union {
+        uint8_t bytes[4];  // IPv4 address
+        uint32_t dword;
+    } _address;
+
+    // Access the raw byte array containing the address.  Because this returns a pointer
+    // to the internal structure rather than a copy of the address this function should only
+    // be used when you know that the usage of the returned uint8_t* will be transient and not
+    // stored.
+    uint8_t* raw_address()
+    {
+        return _address.bytes;
+    }
+
+public:
+    // Constructors
+    IPAddress();
+    IPAddress(uint8_t first_octet, uint8_t second_octet, uint8_t third_octet, uint8_t fourth_octet);
+    IPAddress(uint32_t address);
+    IPAddress(const uint8_t *address);
+    virtual ~IPAddress() {}
+
+    // Overloaded cast operator to allow IPAddress objects to be used where a pointer
+    // to a four-byte uint8_t array is expected
+    operator uint32_t() const
+    {
+        return _address.dword;
+    }
+    bool operator==(const IPAddress& addr) const
+    {
+        return _address.dword == addr._address.dword;
+    }
+    bool operator==(const uint8_t* addr) const;
+
+    // Overloaded index operator to allow getting and setting individual octets of the address
+    uint8_t operator[](int index) const
+    {
+        return _address.bytes[index];
+    }
+    uint8_t& operator[](int index)
+    {
+        return _address.bytes[index];
+    }
+
+    // Overloaded copy operators to allow initialisation of IPAddress objects from other types
+    IPAddress& operator=(const uint8_t *address);
+    IPAddress& operator=(uint32_t address);
+
+    virtual size_t printTo(Print& p) const;
+    String toString();
+
+    friend class EthernetClass;
+    friend class UDP;
+    friend class Client;
+    friend class Server;
+    friend class DhcpClass;
+    friend class DNSClient;
+};
+
+const IPAddress INADDR_NONE(0, 0, 0, 0);
+
+#endif

cores/esp32/MD5Builder.cpp

@@ -0,0 +1,117 @@
+/* 
+  Copyright (c) 2015 Hristo Gochkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+ 
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library 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
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+#include <Arduino.h>
+#include <MD5Builder.h>
+
+uint8_t hex_char_to_byte(uint8_t c)
+{
+    return  (c >= 'a' && c <= 'f') ? (c - ((uint8_t)'a' - 0xa)) :
+            (c >= 'A' && c <= 'F') ? (c - ((uint8_t)'A' - 0xA)) :
+            (c >= '0' &&  c<= '9') ? (c - (uint8_t)'0') : 0;
+}
+
+void MD5Builder::begin(void)
+{
+    memset(_buf, 0x00, 16);
+    MD5Init(&_ctx);
+}
+
+void MD5Builder::add(uint8_t * data, uint16_t len)
+{
+    MD5Update(&_ctx, data, len);
+}
+
+void MD5Builder::addHexString(const char * data)
+{
+    uint16_t i, len = strlen(data);
+    uint8_t * tmp = (uint8_t*)malloc(len/2);
+    if(tmp == NULL) {
+        return;
+    }
+    for(i=0; i<len; i+=2) {
+        uint8_t high = hex_char_to_byte(data[i]);
+        uint8_t low = hex_char_to_byte(data[i+1]);
+        tmp[i/2] = (high & 0x0F) << 4 | (low & 0x0F);
+    }
+    add(tmp, len/2);
+    free(tmp);
+}
+
+bool MD5Builder::addStream(Stream & stream, const size_t maxLen)
+{
+    const int buf_size = 512;
+    int maxLengthLeft = maxLen;
+    uint8_t * buf = (uint8_t*) malloc(buf_size);
+
+    if(!buf) {
+        return false;
+    }
+
+    int bytesAvailable = stream.available();
+    while((bytesAvailable > 0) && (maxLengthLeft > 0)) {
+
+        // determine number of bytes to read
+        int readBytes = bytesAvailable;
+        if(readBytes > maxLengthLeft) {
+            readBytes = maxLengthLeft ;    // read only until max_len
+        }
+        if(readBytes > buf_size) {
+            readBytes = buf_size;    // not read more the buffer can handle
+        }
+
+        // read data and check if we got something
+        int numBytesRead = stream.readBytes(buf, readBytes);
+        if(numBytesRead< 1) {
+            return false;
+        }
+
+        // Update MD5 with buffer payload
+        MD5Update(&_ctx, buf, numBytesRead);
+
+        // update available number of bytes
+        maxLengthLeft -= numBytesRead;
+        bytesAvailable = stream.available();
+    }
+    free(buf);
+    return true;
+}
+
+void MD5Builder::calculate(void)
+{
+    MD5Final(_buf, &_ctx);
+}
+
+void MD5Builder::getBytes(uint8_t * output)
+{
+    memcpy(output, _buf, 16);
+}
+
+void MD5Builder::getChars(char * output)
+{
+    for(uint8_t i = 0; i < 16; i++) {
+        sprintf(output + (i * 2), "%02x", _buf[i]);
+    }
+}
+
+String MD5Builder::toString(void)
+{
+    char out[33];
+    getChars(out);
+    return String(out);
+}

cores/esp32/MD5Builder.h

@@ -0,0 +1,63 @@
+/* 
+  Copyright (c) 2015 Hristo Gochkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+ 
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library 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
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+#ifndef __ESP8266_MD5_BUILDER__
+#define __ESP8266_MD5_BUILDER__
+
+#include <WString.h>
+#include <Stream.h>
+#include "rom/md5_hash.h"
+
+class MD5Builder
+{
+private:
+    struct MD5Context _ctx;
+    uint8_t _buf[16];
+public:
+    void begin(void);
+    void add(uint8_t * data, uint16_t len);
+    void add(const char * data)
+    {
+        add((uint8_t*)data, strlen(data));
+    }
+    void add(char * data)
+    {
+        add((const char*)data);
+    }
+    void add(String data)
+    {
+        add(data.c_str());
+    }
+    void addHexString(const char * data);
+    void addHexString(char * data)
+    {
+        addHexString((const char*)data);
+    }
+    void addHexString(String data)
+    {
+        addHexString(data.c_str());
+    }
+    bool addStream(Stream & stream, const size_t maxLen);
+    void calculate(void);
+    void getBytes(uint8_t * output);
+    void getChars(char * output);
+    String toString(void);
+};
+
+
+#endif

cores/esp32/Print.cpp

@@ -0,0 +1,293 @@
+/*
+ Print.cpp - Base class that provides print() and println()
+ Copyright (c) 2008 David A. Mellis.  All right reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+ Modified 23 November 2006 by David A. Mellis
+ Modified December 2014 by Ivan Grokhotkov
+ Modified May 2015 by Michael C. Miller - ESP31B progmem support
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include "Wiring.h"
+
+#include "Print.h"
+extern "C" {
+//#include "esp_common.h"
+}
+
+// Public Methods //////////////////////////////////////////////////////////////
+
+/* default implementation: may be overridden */
+size_t Print::write(const uint8_t *buffer, size_t size)
+{
+    size_t n = 0;
+    while(size--) {
+        n += write(*buffer++);
+    }
+    return n;
+}
+
+size_t Print::printf(const char *format, ...)
+{
+    va_list arg;
+    va_start(arg, format);
+    size_t len = vsnprintf(NULL, 0, format, arg);
+    char temp[len+1];
+    uint8_t * stemp = (uint8_t*)temp;
+    len = vsnprintf(temp, len+1, format, arg);
+    write(stemp, len);
+    va_end(arg);
+    return len;
+}
+/*
+size_t Print::print(const __FlashStringHelper *ifsh) {
+    PGM_P p = reinterpret_cast<PGM_P>(ifsh);
+
+    size_t n = 0;
+    while (1) {
+        uint8_t c = pgm_read_byte(p++);
+        if (c == 0) break;
+        n += write(c);
+    }
+    return n;
+}
+*/
+size_t Print::print(const String &s)
+{
+    return write(s.c_str(), s.length());
+}
+
+size_t Print::print(const char str[])
+{
+    return write(str);
+}
+
+size_t Print::print(char c)
+{
+    return write(c);
+}
+
+size_t Print::print(unsigned char b, int base)
+{
+    return print((unsigned long) b, base);
+}
+
+size_t Print::print(int n, int base)
+{
+    return print((long) n, base);
+}
+
+size_t Print::print(unsigned int n, int base)
+{
+    return print((unsigned long) n, 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);
+    }
+}
+
+size_t Print::print(unsigned long n, int base)
+{
+    if(base == 0) {
+        return write(n);
+    } else {
+        return printNumber(n, base);
+    }
+}
+
+size_t Print::print(double n, int digits)
+{
+    return printFloat(n, digits);
+}
+
+size_t Print::println(const __FlashStringHelper *ifsh)
+{
+    size_t n = print(ifsh);
+    n += println();
+    return n;
+}
+
+size_t Print::print(const Printable& x)
+{
+    return x.printTo(*this);
+}
+
+size_t Print::println(void)
+{
+    return print("\r\n");
+}
+
+size_t Print::println(const String &s)
+{
+    size_t n = print(s);
+    n += println();
+    return n;
+}
+
+size_t Print::println(const char c[])
+{
+    size_t n = print(c);
+    n += println();
+    return n;
+}
+
+size_t Print::println(char c)
+{
+    size_t n = print(c);
+    n += println();
+    return n;
+}
+
+size_t Print::println(unsigned char b, int base)
+{
+    size_t n = print(b, base);
+    n += println();
+    return n;
+}
+
+size_t Print::println(int num, int base)
+{
+    size_t n = print(num, base);
+    n += println();
+    return n;
+}
+
+size_t Print::println(unsigned int num, int base)
+{
+    size_t n = print(num, base);
+    n += println();
+    return n;
+}
+
+size_t Print::println(long num, int base)
+{
+    size_t n = print(num, base);
+    n += println();
+    return n;
+}
+
+size_t Print::println(unsigned long num, int base)
+{
+    size_t n = print(num, base);
+    n += println();
+    return n;
+}
+
+size_t Print::println(double num, int digits)
+{
+    size_t n = print(num, digits);
+    n += println();
+    return n;
+}
+
+size_t Print::println(const Printable& x)
+{
+    size_t n = print(x);
+    n += println();
+    return n;
+}
+
+// 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];
+
+    *str = '\0';
+
+    // prevent crash if called with base == 1
+    if(base < 2) {
+        base = 10;
+    }
+
+    do {
+        unsigned long m = n;
+        n /= base;
+        char c = m - base * n;
+        *--str = c < 10 ? c + '0' : c + 'A' - 10;
+    } while(n);
+
+    return write(str);
+}
+
+size_t Print::printFloat(double number, uint8_t digits)
+{
+    size_t n = 0;
+
+    if(isnan(number)) {
+        return print("nan");
+    }
+    if(isinf(number)) {
+        return print("inf");
+    }
+    if(number > 4294967040.0) {
+        return print("ovf");    // constant determined empirically
+    }
+    if(number < -4294967040.0) {
+        return print("ovf");    // constant determined empirically
+    }
+
+    // Handle negative numbers
+    if(number < 0.0) {
+        n += print('-');
+        number = -number;
+    }
+
+    // Round correctly so that print(1.999, 2) prints as "2.00"
+    double rounding = 0.5;
+    for(uint8_t i = 0; i < digits; ++i) {
+        rounding /= 10.0;
+    }
+
+    number += rounding;
+
+    // Extract the integer part of the number and print it
+    unsigned long int_part = (unsigned long) number;
+    double remainder = number - (double) int_part;
+    n += print(int_part);
+
+    // Print the decimal point, but only if there are digits beyond
+    if(digits > 0) {
+        n += print(".");
+    }
+
+    // Extract digits from the remainder one at a time
+    while(digits-- > 0) {
+        remainder *= 10.0;
+        int toPrint = int(remainder);
+        n += print(toPrint);
+        remainder -= toPrint;
+    }
+
+    return n;
+}

cores/esp32/Print.h

@@ -0,0 +1,101 @@
+/*
+ Print.h - Base class that provides print() and println()
+ Copyright (c) 2008 David A. Mellis.  All right reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef Print_h
+#define Print_h
+
+#include <stdint.h>
+#include <stddef.h>
+
+#include "WString.h"
+#include "Printable.h"
+
+#define DEC 10
+#define HEX 16
+#define OCT 8
+#define BIN 2
+
+class Print
+{
+private:
+    int write_error;
+    size_t printNumber(unsigned long, uint8_t);
+    size_t printFloat(double, uint8_t);
+protected:
+    void setWriteError(int err = 1)
+    {
+        write_error = err;
+    }
+public:
+    Print() :
+        write_error(0)
+    {
+    }
+    virtual ~Print() {}
+    int getWriteError()
+    {
+        return write_error;
+    }
+    void clearWriteError()
+    {
+        setWriteError(0);
+    }
+
+    virtual size_t write(uint8_t) = 0;
+    size_t write(const char *str)
+    {
+        if(str == NULL) {
+            return 0;
+        }
+        return write((const uint8_t *) str, strlen(str));
+    }
+    virtual size_t write(const uint8_t *buffer, size_t size);
+    size_t write(const char *buffer, size_t size)
+    {
+        return write((const uint8_t *) buffer, size);
+    }
+
+    size_t printf(const char * format, ...)  __attribute__ ((format (printf, 2, 3)));
+    size_t print(const __FlashStringHelper *);
+    size_t print(const String &);
+    size_t print(const char[]);
+    size_t print(char);
+    size_t print(unsigned char, int = DEC);
+    size_t print(int, int = DEC);
+    size_t print(unsigned int, int = DEC);
+    size_t print(long, int = DEC);
+    size_t print(unsigned long, int = DEC);
+    size_t print(double, int = 2);
+    size_t print(const Printable&);
+
+    size_t println(const __FlashStringHelper *);
+    size_t println(const String &s);
+    size_t println(const char[]);
+    size_t println(char);
+    size_t println(unsigned char, int = DEC);
+    size_t println(int, int = DEC);
+    size_t println(unsigned int, int = DEC);
+    size_t println(long, int = DEC);
+    size_t println(unsigned long, int = DEC);
+    size_t println(double, int = 2);
+    size_t println(const Printable&);
+    size_t println(void);
+};
+
+#endif

cores/esp32/Printable.h

@@ -0,0 +1,41 @@
+/*
+ Printable.h - Interface class that allows printing of complex types
+ Copyright (c) 2011 Adrian McEwen.  All right reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef Printable_h
+#define Printable_h
+
+#include <stdlib.h>
+
+class Print;
+
+/** The Printable class provides a way for new classes to allow themselves to be printed.
+ By deriving from Printable and implementing the printTo method, it will then be possible
+ for users to print out instances of this class by passing them into the usual
+ Print::print and Print::println methods.
+ */
+
+class Printable
+{
+public:
+    virtual ~Printable() {}
+    virtual size_t printTo(Print& p) const = 0;
+};
+
+#endif
+

cores/esp32/Server.h

@@ -0,0 +1,31 @@
+/*
+ Server.h - Base class that provides Server
+ Copyright (c) 2011 Adrian McEwen.  All right reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef server_h
+#define server_h
+
+#include "Print.h"
+
+class Server: public Print
+{
+public:
+    virtual void begin() =0;
+};
+
+#endif

cores/esp32/Stream.cpp

@@ -0,0 +1,291 @@
+/*
+ Stream.cpp - adds parsing methods to Stream class
+ Copyright (c) 2008 David A. Mellis.  All right reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+ Created July 2011
+ parsing functions based on TextFinder library by Michael Margolis
+ */
+
+#include "Wiring.h"
+#include "Stream.h"
+#include "esp32-hal.h"
+
+#define PARSE_TIMEOUT 1000  // default number of milli-seconds to wait
+#define NO_SKIP_CHAR  1  // a magic char not found in a valid ASCII numeric field
+
+// private method to read stream with timeout
+int Stream::timedRead()
+{
+    int c;
+    _startMillis = millis();
+    do {
+        c = read();
+        if(c >= 0) {
+            return c;
+        }
+    } while(millis() - _startMillis < _timeout);
+    return -1;     // -1 indicates timeout
+}
+
+// private method to peek stream with timeout
+int Stream::timedPeek()
+{
+    int c;
+    _startMillis = millis();
+    do {
+        c = peek();
+        if(c >= 0) {
+            return c;
+        }
+    } while(millis() - _startMillis < _timeout);
+    return -1;     // -1 indicates timeout
+}
+
+// returns peek of the next digit in the stream or -1 if timeout
+// discards non-numeric characters
+int Stream::peekNextDigit()
+{
+    int c;
+    while(1) {
+        c = timedPeek();
+        if(c < 0) {
+            return c;    // timeout
+        }
+        if(c == '-') {
+            return c;
+        }
+        if(c >= '0' && c <= '9') {
+            return c;
+        }
+        read();  // discard non-numeric
+    }
+}
+
+// Public Methods
+//////////////////////////////////////////////////////////////
+
+void Stream::setTimeout(unsigned long timeout)  // sets the maximum number of milliseconds to wait
+{
+    _timeout = timeout;
+}
+
+// find returns true if the target string is found
+bool Stream::find(const char *target)
+{
+    return findUntil(target, (char*) "");
+}
+
+// reads data from the stream until the target string of given length is found
+// returns true if target string is found, false if timed out
+bool Stream::find(const char *target, size_t length)
+{
+    return findUntil(target, length, NULL, 0);
+}
+
+// as find but search ends if the terminator string is found
+bool Stream::findUntil(const char *target, const char *terminator)
+{
+    return findUntil(target, strlen(target), terminator, strlen(terminator));
+}
+
+// reads data from the stream until the target string of the given length is found
+// search terminated if the terminator string is found
+// returns true if target string is found, false if terminated or timed out
+bool Stream::findUntil(const char *target, size_t targetLen, const char *terminator, size_t termLen)
+{
+    size_t index = 0;  // maximum target string length is 64k bytes!
+    size_t termIndex = 0;
+    int c;
+
+    if(*target == 0) {
+        return true;    // return true if target is a null string
+    }
+    while((c = timedRead()) > 0) {
+
+        if(c != target[index]) {
+            index = 0;    // reset index if any char does not match
+        }
+
+        if(c == target[index]) {
+            //////Serial.print("found "); Serial.write(c); Serial.print("index now"); Serial.println(index+1);
+            if(++index >= targetLen) { // return true if all chars in the target match
+                return true;
+            }
+        }
+
+        if(termLen > 0 && c == terminator[termIndex]) {
+            if(++termIndex >= termLen) {
+                return false;    // return false if terminate string found before target string
+            }
+        } else {
+            termIndex = 0;
+        }
+    }
+    return false;
+}
+
+// returns the first valid (long) integer value from the current position.
+// initial characters that are not digits (or the minus sign) are skipped
+// function is terminated by the first character that is not a digit.
+long Stream::parseInt()
+{
+    return parseInt(NO_SKIP_CHAR); // terminate on first non-digit character (or timeout)
+}
+
+// as above but a given skipChar is ignored
+// this allows format characters (typically commas) in values to be ignored
+long Stream::parseInt(char skipChar)
+{
+    boolean isNegative = false;
+    long value = 0;
+    int c;
+
+    c = peekNextDigit();
+    // ignore non numeric leading characters
+    if(c < 0) {
+        return 0;    // zero returned if timeout
+    }
+
+    do {
+        if(c == skipChar) {
+        } // ignore this charactor
+        else if(c == '-') {
+            isNegative = true;
+        } else if(c >= '0' && c <= '9') {    // is c a digit?
+            value = value * 10 + c - '0';
+        }
+        read();  // consume the character we got with peek
+        c = timedPeek();
+    } while((c >= '0' && c <= '9') || c == skipChar);
+
+    if(isNegative) {
+        value = -value;
+    }
+    return value;
+}
+
+// as parseInt but returns a floating point value
+float Stream::parseFloat()
+{
+    return parseFloat(NO_SKIP_CHAR);
+}
+
+// as above but the given skipChar is ignored
+// this allows format characters (typically commas) in values to be ignored
+float Stream::parseFloat(char skipChar)
+{
+    boolean isNegative = false;
+    boolean isFraction = false;
+    long value = 0;
+    int c;
+    float fraction = 1.0;
+
+    c = peekNextDigit();
+    // ignore non numeric leading characters
+    if(c < 0) {
+        return 0;    // zero returned if timeout
+    }
+
+    do {
+        if(c == skipChar) {
+        } // ignore
+        else if(c == '-') {
+            isNegative = true;
+        } else if(c == '.') {
+            isFraction = true;
+        } else if(c >= '0' && c <= '9') {    // is c a digit?
+            value = value * 10 + c - '0';
+            if(isFraction) {
+                fraction *= 0.1;
+            }
+        }
+        read();  // consume the character we got with peek
+        c = timedPeek();
+    } while((c >= '0' && c <= '9') || c == '.' || c == skipChar);
+
+    if(isNegative) {
+        value = -value;
+    }
+    if(isFraction) {
+        return value * fraction;
+    } else {
+        return value;
+    }
+}
+
+// read characters from stream into buffer
+// terminates if length characters have been read, or timeout (see setTimeout)
+// returns the number of characters placed in the buffer
+// the buffer is NOT null terminated.
+//
+size_t Stream::readBytes(char *buffer, size_t length)
+{
+    size_t count = 0;
+    while(count < length) {
+        int c = timedRead();
+        if(c < 0) {
+            break;
+        }
+        *buffer++ = (char) c;
+        count++;
+    }
+    return count;
+}
+
+// as readBytes with terminator character
+// terminates if length characters have been read, timeout, or if the terminator character  detected
+// returns the number of characters placed in the buffer (0 means no valid data found)
+
+size_t Stream::readBytesUntil(char terminator, char *buffer, size_t length)
+{
+    if(length < 1) {
+        return 0;
+    }
+    size_t index = 0;
+    while(index < length) {
+        int c = timedRead();
+        if(c < 0 || c == terminator) {
+            break;
+        }
+        *buffer++ = (char) c;
+        index++;
+    }
+    return index; // return number of characters, not including null terminator
+}
+
+String Stream::readString()
+{
+    String ret;
+    int c = timedRead();
+    while(c >= 0) {
+        ret += (char) c;
+        c = timedRead();
+    }
+    return ret;
+}
+
+String Stream::readStringUntil(char terminator)
+{
+    String ret;
+    int c = timedRead();
+    while(c >= 0 && c != terminator) {
+        ret += (char) c;
+        c = timedRead();
+    }
+    return ret;
+}
+

cores/esp32/Stream.h

@@ -0,0 +1,128 @@
+/*
+ Stream.h - base class for character-based streams.
+ Copyright (c) 2010 David A. Mellis.  All right reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+ parsing functions based on TextFinder library by Michael Margolis
+ */
+
+#ifndef Stream_h
+#define Stream_h
+
+#include <inttypes.h>
+#include "Print.h"
+
+// compatability macros for testing
+/*
+ #define   getInt()            parseInt()
+ #define   getInt(skipChar)    parseInt(skipchar)
+ #define   getFloat()          parseFloat()
+ #define   getFloat(skipChar)  parseFloat(skipChar)
+ #define   getString( pre_string, post_string, buffer, length)
+ readBytesBetween( pre_string, terminator, buffer, length)
+ */
+
+class Stream: public Print
+{
+protected:
+    unsigned long _timeout;      // number of milliseconds to wait for the next char before aborting timed read
+    unsigned long _startMillis;  // used for timeout measurement
+    int timedRead();    // private method to read stream with timeout
+    int timedPeek();    // private method to peek stream with timeout
+    int peekNextDigit(); // returns the next numeric digit in the stream or -1 if timeout
+
+public:
+    virtual int available() = 0;
+    virtual int read() = 0;
+    virtual int peek() = 0;
+    virtual void flush() = 0;
+
+    Stream():_startMillis(0)
+    {
+        _timeout = 1000;
+    }
+    virtual ~Stream() {}
+
+// parsing methods
+
+    void setTimeout(unsigned long timeout);  // sets maximum milliseconds to wait for stream data, default is 1 second
+
+    bool find(const char *target);   // reads data from the stream until the target string is found
+    bool find(uint8_t *target)
+    {
+        return find((char *) target);
+    }
+    // returns true if target string is found, false if timed out (see setTimeout)
+
+    bool find(const char *target, size_t length);   // reads data from the stream until the target string of given length is found
+    bool find(const uint8_t *target, size_t length)
+    {
+        return find((char *) target, length);
+    }
+    // returns true if target string is found, false if timed out
+
+    bool find(char target)
+    {
+        return find (&target, 1);
+    }
+
+    bool findUntil(const char *target, const char *terminator);   // as find but search ends if the terminator string is found
+    bool findUntil(const uint8_t *target, const char *terminator)
+    {
+        return findUntil((char *) target, terminator);
+    }
+
+    bool findUntil(const char *target, size_t targetLen, const char *terminate, size_t termLen);   // as above but search ends if the terminate string is found
+    bool findUntil(const uint8_t *target, size_t targetLen, const char *terminate, size_t termLen)
+    {
+        return findUntil((char *) target, targetLen, terminate, termLen);
+    }
+
+    long parseInt(); // returns the first valid (long) integer value from the current position.
+    // initial characters that are not digits (or the minus sign) are skipped
+    // integer is terminated by the first character that is not a digit.
+
+    float parseFloat();               // float version of parseInt
+
+    size_t readBytes(char *buffer, size_t length); // read chars from stream into buffer
+    size_t readBytes(uint8_t *buffer, size_t length)
+    {
+        return readBytes((char *) buffer, length);
+    }
+    // terminates if length characters have been read or timeout (see setTimeout)
+    // returns the number of characters placed in the buffer (0 means no valid data found)
+
+    size_t readBytesUntil(char terminator, char *buffer, size_t length); // as readBytes with terminator character
+    size_t readBytesUntil(char terminator, uint8_t *buffer, size_t length)
+    {
+        return readBytesUntil(terminator, (char *) buffer, length);
+    }
+    // terminates if length characters have been read, timeout, or if the terminator character  detected
+    // returns the number of characters placed in the buffer (0 means no valid data found)
+
+    // Arduino String functions to be added here
+    String readString();
+    String readStringUntil(char terminator);
+
+protected:
+    long parseInt(char skipChar); // as above but the given skipChar is ignored
+    // as above but the given skipChar is ignored
+    // this allows format characters (typically commas) in values to be ignored
+
+    float parseFloat(char skipChar);  // as above but the given skipChar is ignored
+};
+
+#endif

cores/esp32/StreamString.cpp

@@ -0,0 +1,71 @@
+/**
+ StreamString.cpp
+
+ Copyright (c) 2015 Markus Sattler. All rights reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+ */
+
+#include <Arduino.h>
+#include "StreamString.h"
+
+size_t StreamString::write(const uint8_t *data, size_t size)
+{
+    if(size && data) {
+        if(reserve(length() + size + 1)) {
+            memcpy((void *) (buffer + len), (const void *) data, size);
+            len += size;
+            *(buffer + len) = 0x00; // add null for string end
+            return size;
+        }
+    }
+    return 0;
+}
+
+size_t StreamString::write(uint8_t data)
+{
+    return concat((char) data);
+}
+
+int StreamString::available()
+{
+    return length();
+}
+
+int StreamString::read()
+{
+    if(length()) {
+        char c = charAt(0);
+        remove(0, 1);
+        return c;
+
+    }
+    return -1;
+}
+
+int StreamString::peek()
+{
+    if(length()) {
+        char c = charAt(0);
+        return c;
+    }
+    return -1;
+}
+
+void StreamString::flush()
+{
+}
+

cores/esp32/StreamString.h

@@ -0,0 +1,39 @@
+/**
+ StreamString.h
+
+ Copyright (c) 2015 Markus Sattler. All rights reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+*/
+
+#ifndef STREAMSTRING_H_
+#define STREAMSTRING_H_
+
+
+class StreamString: public Stream, public String
+{
+public:
+    size_t write(const uint8_t *buffer, size_t size) override;
+    size_t write(uint8_t data) override;
+
+    int available() override;
+    int read() override;
+    int peek() override;
+    void flush() override;
+};
+
+
+#endif /* STREAMSTRING_H_ */

cores/esp32/Udp.h

@@ -0,0 +1,92 @@
+/*
+ *  Udp.cpp: Library to send/receive UDP packets.
+ *
+ * NOTE: UDP is fast, but has some important limitations (thanks to Warren Gray for mentioning these)
+ * 1) UDP does not guarantee the order in which assembled UDP packets are received. This
+ * might not happen often in practice, but in larger network topologies, a UDP
+ * packet can be received out of sequence.
+ * 2) UDP does not guard against lost packets - so packets *can* disappear without the sender being
+ * aware of it. Again, this may not be a concern in practice on small local networks.
+ * For more information, see http://www.cafeaulait.org/course/week12/35.html
+ *
+ * MIT License:
+ * Copyright (c) 2008 Bjoern Hartmann
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * bjoern@cs.stanford.edu 12/30/2008
+ */
+
+#ifndef udp_h
+#define udp_h
+
+#include <Stream.h>
+#include <IPAddress.h>
+
+class UDP: public Stream
+{
+
+public:
+    virtual uint8_t begin(uint16_t) =0;	// initialize, start listening on specified port. Returns 1 if successful, 0 if there are no sockets available to use
+    virtual void stop() =0;  // Finish with the UDP socket
+
+    // Sending UDP packets
+
+    // Start building up a packet to send to the remote host specific in ip and port
+    // Returns 1 if successful, 0 if there was a problem with the supplied IP address or port
+    virtual int beginPacket(IPAddress ip, uint16_t port) =0;
+    // Start building up a packet to send to the remote host specific in host and port
+    // Returns 1 if successful, 0 if there was a problem resolving the hostname or port
+    virtual int beginPacket(const char *host, uint16_t port) =0;
+    // Finish off this packet and send it
+    // Returns 1 if the packet was sent successfully, 0 if there was an error
+    virtual int endPacket() =0;
+    // Write a single byte into the packet
+    virtual size_t write(uint8_t) =0;
+    // Write size bytes from buffer into the packet
+    virtual size_t write(const uint8_t *buffer, size_t size) =0;
+
+    // Start processing the next available incoming packet
+    // Returns the size of the packet in bytes, or 0 if no packets are available
+    virtual int parsePacket() =0;
+    // Number of bytes remaining in the current packet
+    virtual int available() =0;
+    // Read a single byte from the current packet
+    virtual int read() =0;
+    // Read up to len bytes from the current packet and place them into buffer
+    // Returns the number of bytes read, or 0 if none are available
+    virtual int read(unsigned char* buffer, size_t len) =0;
+    // Read up to len characters from the current packet and place them into buffer
+    // Returns the number of characters read, or 0 if none are available
+    virtual int read(char* buffer, size_t len) =0;
+    // Return the next byte from the current packet without moving on to the next byte
+    virtual int peek() =0;
+    virtual void flush() =0;	// Finish reading the current packet
+
+    // Return the IP address of the host who sent the current incoming packet
+    virtual IPAddress remoteIP() =0;
+    // Return the port of the host who sent the current incoming packet
+    virtual uint16_t remotePort() =0;
+protected:
+    uint8_t* rawIPAddress(IPAddress& addr)
+    {
+        return addr.raw_address();
+    }
+};
+
+#endif

cores/esp32/WCharacter.h

@@ -0,0 +1,155 @@
+/*
+ WCharacter.h - Character utility functions for Wiring & Arduino
+ Copyright (c) 2010 Hernando Barragan.  All right reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef Character_h
+#define Character_h
+
+#include <ctype.h>
+#include "WTypes.h"
+#define isascii(__c) ((unsigned)(__c)<=0177)
+#define toascii(__c)  ((__c)&0177)
+
+// WCharacter.h prototypes
+inline boolean isAlphaNumeric(int c) __attribute__((always_inline));
+inline boolean isAlpha(int c) __attribute__((always_inline));
+inline boolean isAscii(int c) __attribute__((always_inline));
+inline boolean isWhitespace(int c) __attribute__((always_inline));
+inline boolean isControl(int c) __attribute__((always_inline));
+inline boolean isDigit(int c) __attribute__((always_inline));
+inline boolean isGraph(int c) __attribute__((always_inline));
+inline boolean isLowerCase(int c) __attribute__((always_inline));
+inline boolean isPrintable(int c) __attribute__((always_inline));
+inline boolean isPunct(int c) __attribute__((always_inline));
+inline boolean isSpace(int c) __attribute__((always_inline));
+inline boolean isUpperCase(int c) __attribute__((always_inline));
+inline boolean isHexadecimalDigit(int c) __attribute__((always_inline));
+inline int toAscii(int c) __attribute__((always_inline));
+inline int toLowerCase(int c) __attribute__((always_inline));
+inline int toUpperCase(int c) __attribute__((always_inline));
+
+// Checks for an alphanumeric character.
+// It is equivalent to (isalpha(c) || isdigit(c)).
+inline boolean isAlphaNumeric(int c)
+{
+    return (isalnum(c) == 0 ? false : true);
+}
+
+// Checks for an alphabetic character.
+// It is equivalent to (isupper(c) || islower(c)).
+inline boolean isAlpha(int c)
+{
+    return (isalpha(c) == 0 ? false : true);
+}
+
+// Checks whether c is a 7-bit unsigned char value
+// that fits into the ASCII character set.
+inline boolean isAscii(int c)
+{
+    return ( isascii (c) == 0 ? false : true);
+}
+
+// Checks for a blank character, that is, a space or a tab.
+inline boolean isWhitespace(int c)
+{
+    return (isblank(c) == 0 ? false : true);
+}
+
+// Checks for a control character.
+inline boolean isControl(int c)
+{
+    return (iscntrl(c) == 0 ? false : true);
+}
+
+// Checks for a digit (0 through 9).
+inline boolean isDigit(int c)
+{
+    return (isdigit(c) == 0 ? false : true);
+}
+
+// Checks for any printable character except space.
+inline boolean isGraph(int c)
+{
+    return (isgraph(c) == 0 ? false : true);
+}
+
+// Checks for a lower-case character.
+inline boolean isLowerCase(int c)
+{
+    return (islower(c) == 0 ? false : true);
+}
+
+// Checks for any printable character including space.
+inline boolean isPrintable(int c)
+{
+    return (isprint(c) == 0 ? false : true);
+}
+
+// Checks for any printable character which is not a space
+// or an alphanumeric character.
+inline boolean isPunct(int c)
+{
+    return (ispunct(c) == 0 ? false : true);
+}
+
+// Checks for white-space characters. For the avr-libc library,
+// these are: space, formfeed ('\f'), newline ('\n'), carriage
+// return ('\r'), horizontal tab ('\t'), and vertical tab ('\v').
+inline boolean isSpace(int c)
+{
+    return (isspace(c) == 0 ? false : true);
+}
+
+// Checks for an uppercase letter.
+inline boolean isUpperCase(int c)
+{
+    return (isupper(c) == 0 ? false : true);
+}
+
+// Checks for a hexadecimal digits, i.e. one of 0 1 2 3 4 5 6 7
+// 8 9 a b c d e f A B C D E F.
+inline boolean isHexadecimalDigit(int c)
+{
+    return (isxdigit(c) == 0 ? false : true);
+}
+
+// Converts c to a 7-bit unsigned char value that fits into the
+// ASCII character set, by clearing the high-order bits.
+inline int toAscii(int c)
+{
+    return toascii(c);
+}
+
+// Warning:
+// Many people will be unhappy if you use this function.
+// This function will convert accented letters into random
+// characters.
+
+// Converts the letter c to lower case, if possible.
+inline int toLowerCase(int c)
+{
+    return tolower(c);
+}
+
+// Converts the letter c to upper case, if possible.
+inline int toUpperCase(int c)
+{
+    return toupper(c);
+}
+
+#endif

cores/esp32/WMath.cpp

@@ -0,0 +1,67 @@
+/* -*- mode: jde; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+ Part of the Wiring project - http://wiring.org.co
+ Copyright (c) 2004-06 Hernando Barragan
+ Modified 13 August 2006, David A. Mellis for Arduino - http://www.arduino.cc/
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General
+ Public License along with this library; if not, write to the
+ Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ Boston, MA  02111-1307  USA
+
+ $Id$
+ */
+
+extern "C" {
+#include <stdlib.h>
+}
+
+void randomSeed(unsigned long seed)
+{
+    if(seed != 0) {
+        srand(seed);
+    }
+}
+
+long random(long howbig)
+{
+    if(howbig == 0) {
+        return 0;
+    }
+    return rand() % howbig;
+}
+
+long random(long howsmall, long howbig)
+{
+    if(howsmall >= howbig) {
+        return howsmall;
+    }
+    long diff = howbig - howsmall;
+    return random(diff) + howsmall;
+}
+
+long map(long x, long in_min, long in_max, long out_min, long out_max)
+{
+    return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
+}
+
+unsigned int makeWord(unsigned int w)
+{
+    return w;
+}
+
+unsigned int makeWord(unsigned char h, unsigned char l)
+{
+    return (h << 8) | l;
+}

cores/esp32/WString.cpp

@@ -0,0 +1,894 @@
+/*
+ WString.cpp - String library for Wiring & Arduino
+ ...mostly rewritten by Paul Stoffregen...
+ Copyright (c) 2009-10 Hernando Barragan.  All rights reserved.
+ Copyright 2011, Paul Stoffregen, paul@pjrc.com
+ Modified by Ivan Grokhotkov, 2014 - ESP31B support
+ Modified by Michael C. Miller, 2015 - ESP31B progmem support
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "WString.h"
+#include "stdlib_noniso.h"
+//extern "C" {
+//#include "esp_common.h"
+//}
+
+/*********************************************/
+/*  Constructors                             */
+/*********************************************/
+
+String::String(const char *cstr)
+{
+    init();
+    if(cstr) {
+        copy(cstr, strlen(cstr));
+    }
+}
+
+String::String(const String &value)
+{
+    init();
+    *this = value;
+}
+/*
+String::String(const __FlashStringHelper *pstr) {
+    init();
+    *this = pstr; // see operator =
+}
+*/
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+String::String(String &&rval)
+{
+    init();
+    move(rval);
+}
+
+String::String(StringSumHelper &&rval)
+{
+    init();
+    move(rval);
+}
+#endif
+
+String::String(char c)
+{
+    init();
+    char buf[2];
+    buf[0] = c;
+    buf[1] = 0;
+    *this = buf;
+}
+
+String::String(unsigned char value, unsigned char base)
+{
+    init();
+    char buf[1 + 8 * sizeof(unsigned char)];
+    utoa(value, buf, base);
+    *this = buf;
+}
+
+String::String(int value, unsigned char base)
+{
+    init();
+    char buf[2 + 8 * sizeof(int)];
+    itoa(value, buf, base);
+    *this = buf;
+}
+
+String::String(unsigned int value, unsigned char base)
+{
+    init();
+    char buf[1 + 8 * sizeof(unsigned int)];
+    utoa(value, buf, base);
+    *this = buf;
+}
+
+String::String(long value, unsigned char base)
+{
+    init();
+    char buf[2 + 8 * sizeof(long)];
+    ltoa(value, buf, base);
+    *this = buf;
+}
+
+String::String(unsigned long value, unsigned char base)
+{
+    init();
+    char buf[1 + 8 * sizeof(unsigned long)];
+    ultoa(value, buf, base);
+    *this = buf;
+}
+
+String::String(float value, unsigned char decimalPlaces)
+{
+    init();
+    char buf[33];
+    *this = dtostrf(value, (decimalPlaces + 2), decimalPlaces, buf);
+}
+
+String::String(double value, unsigned char decimalPlaces)
+{
+    init();
+    char buf[33];
+    *this = dtostrf(value, (decimalPlaces + 2), decimalPlaces, buf);
+}
+
+String::~String()
+{
+    if(buffer) {
+        free(buffer);
+    }
+    init();
+}
+
+// /*********************************************/
+// /*  Memory Management                        */
+// /*********************************************/
+
+inline void String::init(void)
+{
+    buffer = NULL;
+    capacity = 0;
+    len = 0;
+}
+
+void String::invalidate(void)
+{
+    if(buffer) {
+        free(buffer);
+    }
+    init();
+}
+
+unsigned char String::reserve(unsigned int size)
+{
+    if(buffer && capacity >= size) {
+        return 1;
+    }
+    if(changeBuffer(size)) {
+        if(len == 0) {
+            buffer[0] = 0;
+        }
+        return 1;
+    }
+    return 0;
+}
+
+unsigned char String::changeBuffer(unsigned int maxStrLen)
+{
+    size_t newSize = (maxStrLen + 16) & (~0xf);
+    char *newbuffer = (char *) malloc(newSize);
+    if(newbuffer) {
+        memset(newbuffer, 0, newSize);
+        memcpy(newbuffer, buffer, len);
+        if (buffer) {
+            free(buffer);
+        }
+        capacity = newSize - 1;
+        buffer = newbuffer;
+        return 1;
+    }
+    buffer = newbuffer;
+    return 0;
+}
+
+// /*********************************************/
+// /*  Copy and Move                            */
+// /*********************************************/
+
+String & String::copy(const char *cstr, unsigned int length)
+{
+    if(!reserve(length)) {
+        invalidate();
+        return *this;
+    }
+    len = length;
+    strcpy(buffer, cstr);
+    return *this;
+}
+/*
+String & String::copy(const __FlashStringHelper *pstr, unsigned int length) {
+    if (!reserve(length)) {
+        invalidate();
+        return *this;
+    }
+    len = length;
+    strcpy_P(buffer, (PGM_P)pstr);
+    return *this;
+}
+*/
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+void String::move(String &rhs)
+{
+    if(buffer) {
+        if(capacity >= rhs.len) {
+            strcpy(buffer, rhs.buffer);
+            len = rhs.len;
+            rhs.len = 0;
+            return;
+        } else {
+            free(buffer);
+        }
+    }
+    buffer = rhs.buffer;
+    capacity = rhs.capacity;
+    len = rhs.len;
+    rhs.buffer = NULL;
+    rhs.capacity = 0;
+    rhs.len = 0;
+}
+#endif
+
+String & String::operator =(const String &rhs)
+{
+    if(this == &rhs) {
+        return *this;
+    }
+
+    if(rhs.buffer) {
+        copy(rhs.buffer, rhs.len);
+    } else {
+        invalidate();
+    }
+
+    return *this;
+}
+
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+String & String::operator =(String &&rval)
+{
+    if(this != &rval) {
+        move(rval);
+    }
+    return *this;
+}
+
+String & String::operator =(StringSumHelper &&rval)
+{
+    if(this != &rval) {
+        move(rval);
+    }
+    return *this;
+}
+#endif
+
+String & String::operator =(const char *cstr)
+{
+    if(cstr) {
+        copy(cstr, strlen(cstr));
+    } else {
+        invalidate();
+    }
+
+    return *this;
+}
+/*
+String & String::operator = (const __FlashStringHelper *pstr)
+{
+    if (pstr) copy(pstr, strlen_P((PGM_P)pstr));
+    else invalidate();
+
+    return *this;
+}
+*/
+// /*********************************************/
+// /*  concat                                   */
+// /*********************************************/
+
+unsigned char String::concat(const String &s)
+{
+    return concat(s.buffer, s.len);
+}
+
+unsigned char String::concat(const char *cstr, unsigned int length)
+{
+    unsigned int newlen = len + length;
+    if(!cstr) {
+        return 0;
+    }
+    if(length == 0) {
+        return 1;
+    }
+    if(!reserve(newlen)) {
+        return 0;
+    }
+    strcpy(buffer + len, cstr);
+    len = newlen;
+    return 1;
+}
+
+unsigned char String::concat(const char *cstr)
+{
+    if(!cstr) {
+        return 0;
+    }
+    return concat(cstr, strlen(cstr));
+}
+
+unsigned char String::concat(char c)
+{
+    char buf[2];
+    buf[0] = c;
+    buf[1] = 0;
+    return concat(buf, 1);
+}
+
+unsigned char String::concat(unsigned char num)
+{
+    char buf[1 + 3 * sizeof(unsigned char)];
+    itoa(num, buf, 10);
+    return concat(buf, strlen(buf));
+}
+
+unsigned char String::concat(int num)
+{
+    char buf[2 + 3 * sizeof(int)];
+    itoa(num, buf, 10);
+    return concat(buf, strlen(buf));
+}
+
+unsigned char String::concat(unsigned int num)
+{
+    char buf[1 + 3 * sizeof(unsigned int)];
+    utoa(num, buf, 10);
+    return concat(buf, strlen(buf));
+}
+
+unsigned char String::concat(long num)
+{
+    char buf[2 + 3 * sizeof(long)];
+    ltoa(num, buf, 10);
+    return concat(buf, strlen(buf));
+}
+
+unsigned char String::concat(unsigned long num)
+{
+    char buf[1 + 3 * sizeof(unsigned long)];
+    ultoa(num, buf, 10);
+    return concat(buf, strlen(buf));
+}
+
+unsigned char String::concat(float num)
+{
+    char buf[20];
+    char* string = dtostrf(num, 4, 2, buf);
+    return concat(string, strlen(string));
+}
+
+unsigned char String::concat(double num)
+{
+    char buf[20];
+    char* string = dtostrf(num, 4, 2, buf);
+    return concat(string, strlen(string));
+}
+/*
+unsigned char String::concat(const __FlashStringHelper * str) {
+    if (!str) return 0;
+    int length = strlen_P((PGM_P)str);
+    if (length == 0) return 1;
+    unsigned int newlen = len + length;
+    if (!reserve(newlen)) return 0;
+    strcpy_P(buffer + len, (PGM_P)str);
+    len = newlen;
+    return 1;
+}
+*/
+/*********************************************/
+/*  Concatenate                              */
+/*********************************************/
+
+StringSumHelper & operator +(const StringSumHelper &lhs, const String &rhs)
+{
+    StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+    if(!a.concat(rhs.buffer, rhs.len)) {
+        a.invalidate();
+    }
+    return a;
+}
+
+StringSumHelper & operator +(const StringSumHelper &lhs, const char *cstr)
+{
+    StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+    if(!cstr || !a.concat(cstr, strlen(cstr))) {
+        a.invalidate();
+    }
+    return a;
+}
+
+StringSumHelper & operator +(const StringSumHelper &lhs, char c)
+{
+    StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+    if(!a.concat(c)) {
+        a.invalidate();
+    }
+    return a;
+}
+
+StringSumHelper & operator +(const StringSumHelper &lhs, unsigned char num)
+{
+    StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+    if(!a.concat(num)) {
+        a.invalidate();
+    }
+    return a;
+}
+
+StringSumHelper & operator +(const StringSumHelper &lhs, int num)
+{
+    StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+    if(!a.concat(num)) {
+        a.invalidate();
+    }
+    return a;
+}
+
+StringSumHelper & operator +(const StringSumHelper &lhs, unsigned int num)
+{
+    StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+    if(!a.concat(num)) {
+        a.invalidate();
+    }
+    return a;
+}
+
+StringSumHelper & operator +(const StringSumHelper &lhs, long num)
+{
+    StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+    if(!a.concat(num)) {
+        a.invalidate();
+    }
+    return a;
+}
+
+StringSumHelper & operator +(const StringSumHelper &lhs, unsigned long num)
+{
+    StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+    if(!a.concat(num)) {
+        a.invalidate();
+    }
+    return a;
+}
+
+StringSumHelper & operator +(const StringSumHelper &lhs, float num)
+{
+    StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+    if(!a.concat(num)) {
+        a.invalidate();
+    }
+    return a;
+}
+
+StringSumHelper & operator +(const StringSumHelper &lhs, double num)
+{
+    StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+    if(!a.concat(num)) {
+        a.invalidate();
+    }
+    return a;
+}
+/*
+StringSumHelper & operator + (const StringSumHelper &lhs, const __FlashStringHelper *rhs)
+{
+    StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+    if (!a.concat(rhs))	a.invalidate();
+    return a;
+}
+*/
+// /*********************************************/
+// /*  Comparison                               */
+// /*********************************************/
+
+int String::compareTo(const String &s) const
+{
+    if(!buffer || !s.buffer) {
+        if(s.buffer && s.len > 0) {
+            return 0 - *(unsigned char *) s.buffer;
+        }
+        if(buffer && len > 0) {
+            return *(unsigned char *) buffer;
+        }
+        return 0;
+    }
+    return strcmp(buffer, s.buffer);
+}
+
+unsigned char String::equals(const String &s2) const
+{
+    return (len == s2.len && compareTo(s2) == 0);
+}
+
+unsigned char String::equals(const char *cstr) const
+{
+    if(len == 0) {
+        return (cstr == NULL || *cstr == 0);
+    }
+    if(cstr == NULL) {
+        return buffer[0] == 0;
+    }
+    return strcmp(buffer, cstr) == 0;
+}
+
+unsigned char String::operator<(const String &rhs) const
+{
+    return compareTo(rhs) < 0;
+}
+
+unsigned char String::operator>(const String &rhs) const
+{
+    return compareTo(rhs) > 0;
+}
+
+unsigned char String::operator<=(const String &rhs) const
+{
+    return compareTo(rhs) <= 0;
+}
+
+unsigned char String::operator>=(const String &rhs) const
+{
+    return compareTo(rhs) >= 0;
+}
+
+unsigned char String::equalsIgnoreCase(const String &s2) const
+{
+    if(this == &s2) {
+        return 1;
+    }
+    if(len != s2.len) {
+        return 0;
+    }
+    if(len == 0) {
+        return 1;
+    }
+    const char *p1 = buffer;
+    const char *p2 = s2.buffer;
+    while(*p1) {
+        if(tolower(*p1++) != tolower(*p2++)) {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+unsigned char String::startsWith(const String &s2) const
+{
+    if(len < s2.len) {
+        return 0;
+    }
+    return startsWith(s2, 0);
+}
+
+unsigned char String::startsWith(const String &s2, unsigned int offset) const
+{
+    if(offset > len - s2.len || !buffer || !s2.buffer) {
+        return 0;
+    }
+    return strncmp(&buffer[offset], s2.buffer, s2.len) == 0;
+}
+
+unsigned char String::endsWith(const String &s2) const
+{
+    if(len < s2.len || !buffer || !s2.buffer) {
+        return 0;
+    }
+    return strcmp(&buffer[len - s2.len], s2.buffer) == 0;
+}
+
+// /*********************************************/
+// /*  Character Access                         */
+// /*********************************************/
+
+char String::charAt(unsigned int loc) const
+{
+    return operator[](loc);
+}
+
+void String::setCharAt(unsigned int loc, char c)
+{
+    if(loc < len) {
+        buffer[loc] = c;
+    }
+}
+
+char & String::operator[](unsigned int index)
+{
+    static char dummy_writable_char;
+    if(index >= len || !buffer) {
+        dummy_writable_char = 0;
+        return dummy_writable_char;
+    }
+    return buffer[index];
+}
+
+char String::operator[](unsigned int index) const
+{
+    if(index >= len || !buffer) {
+        return 0;
+    }
+    return buffer[index];
+}
+
+void String::getBytes(unsigned char *buf, unsigned int bufsize, unsigned int index) const
+{
+    if(!bufsize || !buf) {
+        return;
+    }
+    if(index >= len) {
+        buf[0] = 0;
+        return;
+    }
+    unsigned int n = bufsize - 1;
+    if(n > len - index) {
+        n = len - index;
+    }
+    strncpy((char *) buf, buffer + index, n);
+    buf[n] = 0;
+}
+
+// /*********************************************/
+// /*  Search                                   */
+// /*********************************************/
+
+int String::indexOf(char c) const
+{
+    return indexOf(c, 0);
+}
+
+int String::indexOf(char ch, unsigned int fromIndex) const
+{
+    if(fromIndex >= len) {
+        return -1;
+    }
+    const char* temp = strchr(buffer + fromIndex, ch);
+    if(temp == NULL) {
+        return -1;
+    }
+    return temp - buffer;
+}
+
+int String::indexOf(const String &s2) const
+{
+    return indexOf(s2, 0);
+}
+
+int String::indexOf(const String &s2, unsigned int fromIndex) const
+{
+    if(fromIndex >= len) {
+        return -1;
+    }
+    const char *found = strstr(buffer + fromIndex, s2.buffer);
+    if(found == NULL) {
+        return -1;
+    }
+    return found - buffer;
+}
+
+int String::lastIndexOf(char theChar) const
+{
+    return lastIndexOf(theChar, len - 1);
+}
+
+int String::lastIndexOf(char ch, unsigned int fromIndex) const
+{
+    if(fromIndex >= len) {
+        return -1;
+    }
+    char tempchar = buffer[fromIndex + 1];
+    buffer[fromIndex + 1] = '\0';
+    char* temp = strrchr(buffer, ch);
+    buffer[fromIndex + 1] = tempchar;
+    if(temp == NULL) {
+        return -1;
+    }
+    return temp - buffer;
+}
+
+int String::lastIndexOf(const String &s2) const
+{
+    return lastIndexOf(s2, len - s2.len);
+}
+
+int String::lastIndexOf(const String &s2, unsigned int fromIndex) const
+{
+    if(s2.len == 0 || len == 0 || s2.len > len) {
+        return -1;
+    }
+    if(fromIndex >= len) {
+        fromIndex = len - 1;
+    }
+    int found = -1;
+    for(char *p = buffer; p <= buffer + fromIndex; p++) {
+        p = strstr(p, s2.buffer);
+        if(!p) {
+            break;
+        }
+        if((unsigned int) (p - buffer) <= fromIndex) {
+            found = p - buffer;
+        }
+    }
+    return found;
+}
+
+String String::substring(unsigned int left, unsigned int right) const
+{
+    if(left > right) {
+        unsigned int temp = right;
+        right = left;
+        left = temp;
+    }
+    String out;
+    if(left >= len) {
+        return out;
+    }
+    if(right > len) {
+        right = len;
+    }
+    char temp = buffer[right];  // save the replaced character
+    buffer[right] = '\0';
+    out = buffer + left;  // pointer arithmetic
+    buffer[right] = temp;  //restore character
+    return out;
+}
+
+// /*********************************************/
+// /*  Modification                             */
+// /*********************************************/
+
+void String::replace(char find, char replace)
+{
+    if(!buffer) {
+        return;
+    }
+    for(char *p = buffer; *p; p++) {
+        if(*p == find) {
+            *p = replace;
+        }
+    }
+}
+
+void String::replace(const String& find, const String& replace)
+{
+    if(len == 0 || find.len == 0) {
+        return;
+    }
+    int diff = replace.len - find.len;
+    char *readFrom = buffer;
+    char *foundAt;
+    if(diff == 0) {
+        while((foundAt = strstr(readFrom, find.buffer)) != NULL) {
+            memcpy(foundAt, replace.buffer, replace.len);
+            readFrom = foundAt + replace.len;
+        }
+    } else if(diff < 0) {
+        char *writeTo = buffer;
+        while((foundAt = strstr(readFrom, find.buffer)) != NULL) {
+            unsigned int n = foundAt - readFrom;
+            memcpy(writeTo, readFrom, n);
+            writeTo += n;
+            memcpy(writeTo, replace.buffer, replace.len);
+            writeTo += replace.len;
+            readFrom = foundAt + find.len;
+            len += diff;
+        }
+        strcpy(writeTo, readFrom);
+    } else {
+        unsigned int size = len; // compute size needed for result
+        while((foundAt = strstr(readFrom, find.buffer)) != NULL) {
+            readFrom = foundAt + find.len;
+            size += diff;
+        }
+        if(size == len) {
+            return;
+        }
+        if(size > capacity && !changeBuffer(size)) {
+            return;    // XXX: tell user!
+        }
+        int index = len - 1;
+        while(index >= 0 && (index = lastIndexOf(find, index)) >= 0) {
+            readFrom = buffer + index + find.len;
+            memmove(readFrom + diff, readFrom, len - (readFrom - buffer));
+            len += diff;
+            buffer[len] = 0;
+            memcpy(buffer + index, replace.buffer, replace.len);
+            index--;
+        }
+    }
+}
+
+void String::remove(unsigned int index)
+{
+    // Pass the biggest integer as the count. The remove method
+    // below will take care of truncating it at the end of the
+    // string.
+    remove(index, (unsigned int) -1);
+}
+
+void String::remove(unsigned int index, unsigned int count)
+{
+    if(index >= len) {
+        return;
+    }
+    if(count <= 0) {
+        return;
+    }
+    if(count > len - index) {
+        count = len - index;
+    }
+    char *writeTo = buffer + index;
+    len = len - count;
+    strncpy(writeTo, buffer + index + count, len - index);
+    buffer[len] = 0;
+}
+
+void String::toLowerCase(void)
+{
+    if(!buffer) {
+        return;
+    }
+    for(char *p = buffer; *p; p++) {
+        *p = tolower(*p);
+    }
+}
+
+void String::toUpperCase(void)
+{
+    if(!buffer) {
+        return;
+    }
+    for(char *p = buffer; *p; p++) {
+        *p = toupper(*p);
+    }
+}
+
+void String::trim(void)
+{
+    if(!buffer || len == 0) {
+        return;
+    }
+    char *begin = buffer;
+    while(isspace(*begin)) {
+        begin++;
+    }
+    char *end = buffer + len - 1;
+    while(isspace(*end) && end >= begin) {
+        end--;
+    }
+    len = end + 1 - begin;
+    if(begin > buffer) {
+        memcpy(buffer, begin, len);
+    }
+    buffer[len] = 0;
+}
+
+// /*********************************************/
+// /*  Parsing / Conversion                     */
+// /*********************************************/
+
+long String::toInt(void) const
+{
+    if(buffer) {
+        return atol(buffer);
+    }
+    return 0;
+}
+
+float String::toFloat(void) const
+{
+    if(buffer) {
+        return atof(buffer);
+    }
+    return 0;
+}

cores/esp32/WString.h

@@ -0,0 +1,327 @@
+/*
+ WString.h - String library for Wiring & Arduino
+ ...mostly rewritten by Paul Stoffregen...
+ Copyright (c) 2009-10 Hernando Barragan.  All right reserved.
+ Copyright 2011, Paul Stoffregen, paul@pjrc.com
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef String_class_h
+#define String_class_h
+#ifdef __cplusplus
+
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+//#include <pgmspace.h>
+
+// An inherited class for holding the result of a concatenation.  These
+// result objects are assumed to be writable by subsequent concatenations.
+class StringSumHelper;
+
+// an abstract class used as a means to proide a unique pointer type
+// but really has no body
+class __FlashStringHelper;
+#define FPSTR(pstr_pointer) (reinterpret_cast<const __FlashStringHelper *>(pstr_pointer))
+#define F(string_literal) (FPSTR(PSTR(string_literal)))
+
+// The string class
+class String
+{
+    // use a function pointer to allow for "if (s)" without the
+    // complications of an operator bool(). for more information, see:
+    // http://www.artima.com/cppsource/safebool.html
+    typedef void (String::*StringIfHelperType)() const;
+    void StringIfHelper() const
+    {
+    }
+
+public:
+    // constructors
+    // creates a copy of the initial value.
+    // if the initial value is null or invalid, or if memory allocation
+    // fails, the string will be marked as invalid (i.e. "if (s)" will
+    // be false).
+    String(const char *cstr = "");
+    String(const String &str);
+    //String(const __FlashStringHelper *str);
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+    String(String &&rval);
+    String(StringSumHelper &&rval);
+#endif
+    explicit String(char c);
+    explicit String(unsigned char, unsigned char base = 10);
+    explicit String(int, unsigned char base = 10);
+    explicit String(unsigned int, unsigned char base = 10);
+    explicit String(long, unsigned char base = 10);
+    explicit String(unsigned long, unsigned char base = 10);
+    explicit String(float, unsigned char decimalPlaces = 2);
+    explicit String(double, unsigned char decimalPlaces = 2);
+    ~String(void);
+
+    // memory management
+    // return true on success, false on failure (in which case, the string
+    // is left unchanged).  reserve(0), if successful, will validate an
+    // invalid string (i.e., "if (s)" will be true afterwards)
+    unsigned char reserve(unsigned int size);
+    inline unsigned int length(void) const
+    {
+        if(buffer) {
+            return len;
+        } else {
+            return 0;
+        }
+    }
+
+    // creates a copy of the assigned value.  if the value is null or
+    // invalid, or if the memory allocation fails, the string will be
+    // marked as invalid ("if (s)" will be false).
+    String & operator =(const String &rhs);
+    String & operator =(const char *cstr);
+    //String & operator = (const __FlashStringHelper *str);
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+    String & operator =(String &&rval);
+    String & operator =(StringSumHelper &&rval);
+#endif
+
+    // concatenate (works w/ built-in types)
+
+    // returns true on success, false on failure (in which case, the string
+    // is left unchanged).  if the argument is null or invalid, the
+    // concatenation is considered unsucessful.
+    unsigned char concat(const String &str);
+    unsigned char concat(const char *cstr);
+    unsigned char concat(char c);
+    unsigned char concat(unsigned char c);
+    unsigned char concat(int num);
+    unsigned char concat(unsigned int num);
+    unsigned char concat(long num);
+    unsigned char concat(unsigned long num);
+    unsigned char concat(float num);
+    unsigned char concat(double num);
+    //unsigned char concat(const __FlashStringHelper * str);
+
+    // if there's not enough memory for the concatenated value, the string
+    // will be left unchanged (but this isn't signalled in any way)
+    String & operator +=(const String &rhs)
+    {
+        concat(rhs);
+        return (*this);
+    }
+    String & operator +=(const char *cstr)
+    {
+        concat(cstr);
+        return (*this);
+    }
+    String & operator +=(char c)
+    {
+        concat(c);
+        return (*this);
+    }
+    String & operator +=(unsigned char num)
+    {
+        concat(num);
+        return (*this);
+    }
+    String & operator +=(int num)
+    {
+        concat(num);
+        return (*this);
+    }
+    String & operator +=(unsigned int num)
+    {
+        concat(num);
+        return (*this);
+    }
+    String & operator +=(long num)
+    {
+        concat(num);
+        return (*this);
+    }
+    String & operator +=(unsigned long num)
+    {
+        concat(num);
+        return (*this);
+    }
+    String & operator +=(float num)
+    {
+        concat(num);
+        return (*this);
+    }
+    String & operator +=(double num)
+    {
+        concat(num);
+        return (*this);
+    }
+    //String & operator += (const __FlashStringHelper *str){
+    //    concat(str);
+    //    return (*this);
+    //}
+
+    friend StringSumHelper & operator +(const StringSumHelper &lhs, const String &rhs);
+    friend StringSumHelper & operator +(const StringSumHelper &lhs, const char *cstr);
+    friend StringSumHelper & operator +(const StringSumHelper &lhs, char c);
+    friend StringSumHelper & operator +(const StringSumHelper &lhs, unsigned char num);
+    friend StringSumHelper & operator +(const StringSumHelper &lhs, int num);
+    friend StringSumHelper & operator +(const StringSumHelper &lhs, unsigned int num);
+    friend StringSumHelper & operator +(const StringSumHelper &lhs, long num);
+    friend StringSumHelper & operator +(const StringSumHelper &lhs, unsigned long num);
+    friend StringSumHelper & operator +(const StringSumHelper &lhs, float num);
+    friend StringSumHelper & operator +(const StringSumHelper &lhs, double num);
+    //friend StringSumHelper & operator +(const StringSumHelper &lhs, const __FlashStringHelper *rhs);
+
+    // comparison (only works w/ Strings and "strings")
+    operator StringIfHelperType() const
+    {
+        return buffer ? &String::StringIfHelper : 0;
+    }
+    int compareTo(const String &s) const;
+    unsigned char equals(const String &s) const;
+    unsigned char equals(const char *cstr) const;
+    unsigned char operator ==(const String &rhs) const
+    {
+        return equals(rhs);
+    }
+    unsigned char operator ==(const char *cstr) const
+    {
+        return equals(cstr);
+    }
+    unsigned char operator !=(const String &rhs) const
+    {
+        return !equals(rhs);
+    }
+    unsigned char operator !=(const char *cstr) const
+    {
+        return !equals(cstr);
+    }
+    unsigned char operator <(const String &rhs) const;
+    unsigned char operator >(const String &rhs) const;
+    unsigned char operator <=(const String &rhs) const;
+    unsigned char operator >=(const String &rhs) const;
+    unsigned char equalsIgnoreCase(const String &s) const;
+    unsigned char startsWith(const String &prefix) const;
+    unsigned char startsWith(const String &prefix, unsigned int offset) const;
+    unsigned char endsWith(const String &suffix) const;
+
+    // character acccess
+    char charAt(unsigned int index) const;
+    void setCharAt(unsigned int index, char c);
+    char operator [](unsigned int index) const;
+    char& operator [](unsigned int index);
+    void getBytes(unsigned char *buf, unsigned int bufsize, unsigned int index = 0) const;
+    void toCharArray(char *buf, unsigned int bufsize, unsigned int index = 0) const
+    {
+        getBytes((unsigned char *) buf, bufsize, index);
+    }
+    const char * c_str() const
+    {
+        return buffer;
+    }
+
+    // search
+    int indexOf(char ch) const;
+    int indexOf(char ch, unsigned int fromIndex) const;
+    int indexOf(const String &str) const;
+    int indexOf(const String &str, unsigned int fromIndex) const;
+    int lastIndexOf(char ch) const;
+    int lastIndexOf(char ch, unsigned int fromIndex) const;
+    int lastIndexOf(const String &str) const;
+    int lastIndexOf(const String &str, unsigned int fromIndex) const;
+    String substring(unsigned int beginIndex) const
+    {
+        return substring(beginIndex, len);
+    }
+    ;
+    String substring(unsigned int beginIndex, unsigned int endIndex) const;
+
+    // modification
+    void replace(char find, char replace);
+    void replace(const String& find, const String& replace);
+    void remove(unsigned int index);
+    void remove(unsigned int index, unsigned int count);
+    void toLowerCase(void);
+    void toUpperCase(void);
+    void trim(void);
+
+    // parsing/conversion
+    long toInt(void) const;
+    float toFloat(void) const;
+
+protected:
+    char *buffer;	        // the actual char array
+    unsigned int capacity;  // the array length minus one (for the '\0')
+    unsigned int len;       // the String length (not counting the '\0')
+protected:
+    void init(void);
+    void invalidate(void);
+    unsigned char changeBuffer(unsigned int maxStrLen);
+    unsigned char concat(const char *cstr, unsigned int length);
+
+    // copy and move
+    String & copy(const char *cstr, unsigned int length);
+    //String & copy(const __FlashStringHelper *pstr, unsigned int length);
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+    void move(String &rhs);
+#endif
+};
+
+class StringSumHelper: public String
+{
+public:
+    StringSumHelper(const String &s) :
+        String(s)
+    {
+    }
+    StringSumHelper(const char *p) :
+        String(p)
+    {
+    }
+    StringSumHelper(char c) :
+        String(c)
+    {
+    }
+    StringSumHelper(unsigned char num) :
+        String(num)
+    {
+    }
+    StringSumHelper(int num) :
+        String(num)
+    {
+    }
+    StringSumHelper(unsigned int num) :
+        String(num)
+    {
+    }
+    StringSumHelper(long num) :
+        String(num)
+    {
+    }
+    StringSumHelper(unsigned long num) :
+        String(num)
+    {
+    }
+    StringSumHelper(float num) :
+        String(num)
+    {
+    }
+    StringSumHelper(double num) :
+        String(num)
+    {
+    }
+};
+
+#endif  // __cplusplus
+#endif  // String_class_h

cores/esp32/base64.cpp

@@ -0,0 +1,65 @@
+/**
+ * base64.cpp
+ *
+ * Created on: 09.12.2015
+ *
+ * Copyright (c) 2015 Markus Sattler. All rights reserved.
+ * This file is part of the ESP31B core for Arduino.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#include "Arduino.h"
+extern "C" {
+#include "libb64/cdecode.h"
+#include "libb64/cencode.h"
+}
+#include "base64.h"
+
+/**
+ * convert input data to base64
+ * @param data uint8_t *
+ * @param length size_t
+ * @return String
+ */
+String base64::encode(uint8_t * data, size_t length)
+{
+    // base64 needs more size then the source data
+    size_t size = ((length * 1.6f) + 1);
+    char * buffer = (char *) malloc(size);
+    if(buffer) {
+        base64_encodestate _state;
+        base64_init_encodestate(&_state);
+        int len = base64_encode_block((const char *) &data[0], length, &buffer[0], &_state);
+        len = base64_encode_blockend((buffer + len), &_state);
+
+        String base64 = String(buffer);
+        free(buffer);
+        return base64;
+    }
+    return String("-FAIL-");
+}
+
+/**
+ * convert input data to base64
+ * @param text String
+ * @return String
+ */
+String base64::encode(String text)
+{
+    return base64::encode((uint8_t *) text.c_str(), text.length());
+}
+

cores/esp32/base64.h

@@ -0,0 +1,13 @@
+#ifndef CORE_BASE64_H_
+#define CORE_BASE64_H_
+
+class base64
+{
+public:
+    static String encode(uint8_t * data, size_t length);
+    static String encode(String text);
+private:
+};
+
+
+#endif /* CORE_BASE64_H_ */

cores/esp32/binary.h

@@ -0,0 +1,534 @@
+/*
+ binary.h - Definitions for binary constants
+ Copyright (c) 2006 David A. Mellis.  All right reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef Binary_h
+#define Binary_h
+
+#define B0 0
+#define B00 0
+#define B000 0
+#define B0000 0
+#define B00000 0
+#define B000000 0
+#define B0000000 0
+#define B00000000 0
+#define B1 1
+#define B01 1
+#define B001 1
+#define B0001 1
+#define B00001 1
+#define B000001 1
+#define B0000001 1
+#define B00000001 1
+#define B10 2
+#define B010 2
+#define B0010 2
+#define B00010 2
+#define B000010 2
+#define B0000010 2
+#define B00000010 2
+#define B11 3
+#define B011 3
+#define B0011 3
+#define B00011 3
+#define B000011 3
+#define B0000011 3
+#define B00000011 3
+#define B100 4
+#define B0100 4
+#define B00100 4
+#define B000100 4
+#define B0000100 4
+#define B00000100 4
+#define B101 5
+#define B0101 5
+#define B00101 5
+#define B000101 5
+#define B0000101 5
+#define B00000101 5
+#define B110 6
+#define B0110 6
+#define B00110 6
+#define B000110 6
+#define B0000110 6
+#define B00000110 6
+#define B111 7
+#define B0111 7
+#define B00111 7
+#define B000111 7
+#define B0000111 7
+#define B00000111 7
+#define B1000 8
+#define B01000 8
+#define B001000 8
+#define B0001000 8
+#define B00001000 8
+#define B1001 9
+#define B01001 9
+#define B001001 9
+#define B0001001 9
+#define B00001001 9
+#define B1010 10
+#define B01010 10
+#define B001010 10
+#define B0001010 10
+#define B00001010 10
+#define B1011 11
+#define B01011 11
+#define B001011 11
+#define B0001011 11
+#define B00001011 11
+#define B1100 12
+#define B01100 12
+#define B001100 12
+#define B0001100 12
+#define B00001100 12
+#define B1101 13
+#define B01101 13
+#define B001101 13
+#define B0001101 13
+#define B00001101 13
+#define B1110 14
+#define B01110 14
+#define B001110 14
+#define B0001110 14
+#define B00001110 14
+#define B1111 15
+#define B01111 15
+#define B001111 15
+#define B0001111 15
+#define B00001111 15
+#define B10000 16
+#define B010000 16
+#define B0010000 16
+#define B00010000 16
+#define B10001 17
+#define B010001 17
+#define B0010001 17
+#define B00010001 17
+#define B10010 18
+#define B010010 18
+#define B0010010 18
+#define B00010010 18
+#define B10011 19
+#define B010011 19
+#define B0010011 19
+#define B00010011 19
+#define B10100 20
+#define B010100 20
+#define B0010100 20
+#define B00010100 20
+#define B10101 21
+#define B010101 21
+#define B0010101 21
+#define B00010101 21
+#define B10110 22
+#define B010110 22
+#define B0010110 22
+#define B00010110 22
+#define B10111 23
+#define B010111 23
+#define B0010111 23
+#define B00010111 23
+#define B11000 24
+#define B011000 24
+#define B0011000 24
+#define B00011000 24
+#define B11001 25
+#define B011001 25
+#define B0011001 25
+#define B00011001 25
+#define B11010 26
+#define B011010 26
+#define B0011010 26
+#define B00011010 26
+#define B11011 27
+#define B011011 27
+#define B0011011 27
+#define B00011011 27
+#define B11100 28
+#define B011100 28
+#define B0011100 28
+#define B00011100 28
+#define B11101 29
+#define B011101 29
+#define B0011101 29
+#define B00011101 29
+#define B11110 30
+#define B011110 30
+#define B0011110 30
+#define B00011110 30
+#define B11111 31
+#define B011111 31
+#define B0011111 31
+#define B00011111 31
+#define B100000 32
+#define B0100000 32
+#define B00100000 32
+#define B100001 33
+#define B0100001 33
+#define B00100001 33
+#define B100010 34
+#define B0100010 34
+#define B00100010 34
+#define B100011 35
+#define B0100011 35
+#define B00100011 35
+#define B100100 36
+#define B0100100 36
+#define B00100100 36
+#define B100101 37
+#define B0100101 37
+#define B00100101 37
+#define B100110 38
+#define B0100110 38
+#define B00100110 38
+#define B100111 39
+#define B0100111 39
+#define B00100111 39
+#define B101000 40
+#define B0101000 40
+#define B00101000 40
+#define B101001 41
+#define B0101001 41
+#define B00101001 41
+#define B101010 42
+#define B0101010 42
+#define B00101010 42
+#define B101011 43
+#define B0101011 43
+#define B00101011 43
+#define B101100 44
+#define B0101100 44
+#define B00101100 44
+#define B101101 45
+#define B0101101 45
+#define B00101101 45
+#define B101110 46
+#define B0101110 46
+#define B00101110 46
+#define B101111 47
+#define B0101111 47
+#define B00101111 47
+#define B110000 48
+#define B0110000 48
+#define B00110000 48
+#define B110001 49
+#define B0110001 49
+#define B00110001 49
+#define B110010 50
+#define B0110010 50
+#define B00110010 50
+#define B110011 51
+#define B0110011 51
+#define B00110011 51
+#define B110100 52
+#define B0110100 52
+#define B00110100 52
+#define B110101 53
+#define B0110101 53
+#define B00110101 53
+#define B110110 54
+#define B0110110 54
+#define B00110110 54
+#define B110111 55
+#define B0110111 55
+#define B00110111 55
+#define B111000 56
+#define B0111000 56
+#define B00111000 56
+#define B111001 57
+#define B0111001 57
+#define B00111001 57
+#define B111010 58
+#define B0111010 58
+#define B00111010 58
+#define B111011 59
+#define B0111011 59
+#define B00111011 59
+#define B111100 60
+#define B0111100 60
+#define B00111100 60
+#define B111101 61
+#define B0111101 61
+#define B00111101 61
+#define B111110 62
+#define B0111110 62
+#define B00111110 62
+#define B111111 63
+#define B0111111 63
+#define B00111111 63
+#define B1000000 64
+#define B01000000 64
+#define B1000001 65
+#define B01000001 65
+#define B1000010 66
+#define B01000010 66
+#define B1000011 67
+#define B01000011 67
+#define B1000100 68
+#define B01000100 68
+#define B1000101 69
+#define B01000101 69
+#define B1000110 70
+#define B01000110 70
+#define B1000111 71
+#define B01000111 71
+#define B1001000 72
+#define B01001000 72
+#define B1001001 73
+#define B01001001 73
+#define B1001010 74
+#define B01001010 74
+#define B1001011 75
+#define B01001011 75
+#define B1001100 76
+#define B01001100 76
+#define B1001101 77
+#define B01001101 77
+#define B1001110 78
+#define B01001110 78
+#define B1001111 79
+#define B01001111 79
+#define B1010000 80
+#define B01010000 80
+#define B1010001 81
+#define B01010001 81
+#define B1010010 82
+#define B01010010 82
+#define B1010011 83
+#define B01010011 83
+#define B1010100 84
+#define B01010100 84
+#define B1010101 85
+#define B01010101 85
+#define B1010110 86
+#define B01010110 86
+#define B1010111 87
+#define B01010111 87
+#define B1011000 88
+#define B01011000 88
+#define B1011001 89
+#define B01011001 89
+#define B1011010 90
+#define B01011010 90
+#define B1011011 91
+#define B01011011 91
+#define B1011100 92
+#define B01011100 92
+#define B1011101 93
+#define B01011101 93
+#define B1011110 94
+#define B01011110 94
+#define B1011111 95
+#define B01011111 95
+#define B1100000 96
+#define B01100000 96
+#define B1100001 97
+#define B01100001 97
+#define B1100010 98
+#define B01100010 98
+#define B1100011 99
+#define B01100011 99
+#define B1100100 100
+#define B01100100 100
+#define B1100101 101
+#define B01100101 101
+#define B1100110 102
+#define B01100110 102
+#define B1100111 103
+#define B01100111 103
+#define B1101000 104
+#define B01101000 104
+#define B1101001 105
+#define B01101001 105
+#define B1101010 106
+#define B01101010 106
+#define B1101011 107
+#define B01101011 107
+#define B1101100 108
+#define B01101100 108
+#define B1101101 109
+#define B01101101 109
+#define B1101110 110
+#define B01101110 110
+#define B1101111 111
+#define B01101111 111
+#define B1110000 112
+#define B01110000 112
+#define B1110001 113
+#define B01110001 113
+#define B1110010 114
+#define B01110010 114
+#define B1110011 115
+#define B01110011 115
+#define B1110100 116
+#define B01110100 116
+#define B1110101 117
+#define B01110101 117
+#define B1110110 118
+#define B01110110 118
+#define B1110111 119
+#define B01110111 119
+#define B1111000 120
+#define B01111000 120
+#define B1111001 121
+#define B01111001 121
+#define B1111010 122
+#define B01111010 122
+#define B1111011 123
+#define B01111011 123
+#define B1111100 124
+#define B01111100 124
+#define B1111101 125
+#define B01111101 125
+#define B1111110 126
+#define B01111110 126
+#define B1111111 127
+#define B01111111 127
+#define B10000000 128
+#define B10000001 129
+#define B10000010 130
+#define B10000011 131
+#define B10000100 132
+#define B10000101 133
+#define B10000110 134
+#define B10000111 135
+#define B10001000 136
+#define B10001001 137
+#define B10001010 138
+#define B10001011 139
+#define B10001100 140
+#define B10001101 141
+#define B10001110 142
+#define B10001111 143
+#define B10010000 144
+#define B10010001 145
+#define B10010010 146
+#define B10010011 147
+#define B10010100 148
+#define B10010101 149
+#define B10010110 150
+#define B10010111 151
+#define B10011000 152
+#define B10011001 153
+#define B10011010 154
+#define B10011011 155
+#define B10011100 156
+#define B10011101 157
+#define B10011110 158
+#define B10011111 159
+#define B10100000 160
+#define B10100001 161
+#define B10100010 162
+#define B10100011 163
+#define B10100100 164
+#define B10100101 165
+#define B10100110 166
+#define B10100111 167
+#define B10101000 168
+#define B10101001 169
+#define B10101010 170
+#define B10101011 171
+#define B10101100 172
+#define B10101101 173
+#define B10101110 174
+#define B10101111 175
+#define B10110000 176
+#define B10110001 177
+#define B10110010 178
+#define B10110011 179
+#define B10110100 180
+#define B10110101 181
+#define B10110110 182
+#define B10110111 183
+#define B10111000 184
+#define B10111001 185
+#define B10111010 186
+#define B10111011 187
+#define B10111100 188
+#define B10111101 189
+#define B10111110 190
+#define B10111111 191
+#define B11000000 192
+#define B11000001 193
+#define B11000010 194
+#define B11000011 195
+#define B11000100 196
+#define B11000101 197
+#define B11000110 198
+#define B11000111 199
+#define B11001000 200
+#define B11001001 201
+#define B11001010 202
+#define B11001011 203
+#define B11001100 204
+#define B11001101 205
+#define B11001110 206
+#define B11001111 207
+#define B11010000 208
+#define B11010001 209
+#define B11010010 210
+#define B11010011 211
+#define B11010100 212
+#define B11010101 213
+#define B11010110 214
+#define B11010111 215
+#define B11011000 216
+#define B11011001 217
+#define B11011010 218
+#define B11011011 219
+#define B11011100 220
+#define B11011101 221
+#define B11011110 222
+#define B11011111 223
+#define B11100000 224
+#define B11100001 225
+#define B11100010 226
+#define B11100011 227
+#define B11100100 228
+#define B11100101 229
+#define B11100110 230
+#define B11100111 231
+#define B11101000 232
+#define B11101001 233
+#define B11101010 234
+#define B11101011 235
+#define B11101100 236
+#define B11101101 237
+#define B11101110 238
+#define B11101111 239
+#define B11110000 240
+#define B11110001 241
+#define B11110010 242
+#define B11110011 243
+#define B11110100 244
+#define B11110101 245
+#define B11110110 246
+#define B11110111 247
+#define B11111000 248
+#define B11111001 249
+#define B11111010 250
+#define B11111011 251
+#define B11111100 252
+#define B11111101 253
+#define B11111110 254
+#define B11111111 255
+
+#endif

cores/esp32/cbuf.cpp

@@ -0,0 +1,196 @@
+/*
+ cbuf.cpp - Circular buffer implementation
+ Copyright (c) 2014 Ivan Grokhotkov. All rights reserved.
+ This file is part of the esp8266 core for Arduino environment.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "cbuf.h"
+
+cbuf::cbuf(size_t size) :
+    next(NULL), _size(size), _buf(new char[size]), _bufend(_buf + size), _begin(_buf), _end(_begin)
+{
+}
+
+cbuf::~cbuf()
+{
+    delete[] _buf;
+}
+
+size_t cbuf::resizeAdd(size_t addSize)
+{
+    return resize(_size + addSize);
+}
+
+size_t cbuf::resize(size_t newSize)
+{
+
+    size_t bytes_available = available();
+
+    // not lose any data
+    // if data can be lost use remove or flush before resize
+    if((newSize < bytes_available) || (newSize == _size)) {
+        return _size;
+    }
+
+    char *newbuf = new char[newSize];
+    char *oldbuf = _buf;
+
+    if(!newbuf) {
+        return _size;
+    }
+
+    if(_buf) {
+        read(newbuf, bytes_available);
+        memset((newbuf + bytes_available), 0x00, (newSize - bytes_available));
+    }
+
+    _begin = newbuf;
+    _end = newbuf + bytes_available;
+    _bufend = newbuf + newSize;
+    _size = newSize;
+
+    _buf = newbuf;
+    delete[] oldbuf;
+
+    return _size;
+}
+
+size_t cbuf::available() const
+{
+    if(_end >= _begin) {
+        return _end - _begin;
+    }
+    return _size - (_begin - _end);
+}
+
+size_t cbuf::size()
+{
+    return _size;
+}
+
+size_t cbuf::room() const
+{
+    if(_end >= _begin) {
+        return _size - (_end - _begin) - 1;
+    }
+    return _begin - _end - 1;
+}
+
+int cbuf::peek()
+{
+    if(empty()) {
+        return -1;
+    }
+
+    return static_cast<int>(*_begin);
+}
+
+size_t cbuf::peek(char *dst, size_t size)
+{
+    size_t bytes_available = available();
+    size_t size_to_read = (size < bytes_available) ? size : bytes_available;
+    size_t size_read = size_to_read;
+    char * begin = _begin;
+    if(_end < _begin && size_to_read > (size_t) (_bufend - _begin)) {
+        size_t top_size = _bufend - _begin;
+        memcpy(dst, _begin, top_size);
+        begin = _buf;
+        size_to_read -= top_size;
+        dst += top_size;
+    }
+    memcpy(dst, begin, size_to_read);
+    return size_read;
+}
+
+int cbuf::read()
+{
+    if(empty()) {
+        return -1;
+    }
+
+    char result = *_begin;
+    _begin = wrap_if_bufend(_begin + 1);
+    return static_cast<int>(result);
+}
+
+size_t cbuf::read(char* dst, size_t size)
+{
+    size_t bytes_available = available();
+    size_t size_to_read = (size < bytes_available) ? size : bytes_available;
+    size_t size_read = size_to_read;
+    if(_end < _begin && size_to_read > (size_t) (_bufend - _begin)) {
+        size_t top_size = _bufend - _begin;
+        memcpy(dst, _begin, top_size);
+        _begin = _buf;
+        size_to_read -= top_size;
+        dst += top_size;
+    }
+    memcpy(dst, _begin, size_to_read);
+    _begin = wrap_if_bufend(_begin + size_to_read);
+    return size_read;
+}
+
+size_t cbuf::write(char c)
+{
+    if(full()) {
+        return 0;
+    }
+
+    *_end = c;
+    _end = wrap_if_bufend(_end + 1);
+    return 1;
+}
+
+size_t cbuf::write(const char* src, size_t size)
+{
+    size_t bytes_available = room();
+    size_t size_to_write = (size < bytes_available) ? size : bytes_available;
+    size_t size_written = size_to_write;
+    if(_end >= _begin && size_to_write > (size_t) (_bufend - _end)) {
+        size_t top_size = _bufend - _end;
+        memcpy(_end, src, top_size);
+        _end = _buf;
+        size_to_write -= top_size;
+        src += top_size;
+    }
+    memcpy(_end, src, size_to_write);
+    _end = wrap_if_bufend(_end + size_to_write);
+    return size_written;
+}
+
+void cbuf::flush()
+{
+    _begin = _buf;
+    _end = _buf;
+}
+
+size_t cbuf::remove(size_t size)
+{
+    size_t bytes_available = available();
+    if(size >= bytes_available) {
+        flush();
+        return 0;
+    }
+    size_t size_to_remove = (size < bytes_available) ? size : bytes_available;
+    if(_end < _begin && size_to_remove > (size_t) (_bufend - _begin)) {
+        size_t top_size = _bufend - _begin;
+        _begin = _buf;
+        size_to_remove -= top_size;
+    }
+    _begin = wrap_if_bufend(_begin + size_to_remove);
+    return available();
+}

cores/esp32/cbuf.h

@@ -0,0 +1,79 @@
+/*
+ cbuf.h - Circular buffer implementation
+ Copyright (c) 2014 Ivan Grokhotkov. All rights reserved.
+ This file is part of the esp8266 core for Arduino environment.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef __cbuf_h
+#define __cbuf_h
+
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+class cbuf
+{
+public:
+    cbuf(size_t size);
+    ~cbuf();
+
+    size_t resizeAdd(size_t addSize);
+    size_t resize(size_t newSize);
+    size_t available() const;
+    size_t size();
+
+    size_t room() const;
+
+    inline bool empty() const
+    {
+        return _begin == _end;
+    }
+
+    inline bool full() const
+    {
+        return wrap_if_bufend(_end + 1) == _begin;
+    }
+
+    int peek();
+    size_t peek(char *dst, size_t size);
+
+    int read();
+    size_t read(char* dst, size_t size);
+
+    size_t write(char c);
+    size_t write(const char* src, size_t size);
+
+    void flush();
+    size_t remove(size_t size);
+
+    cbuf *next;
+
+private:
+    inline char* wrap_if_bufend(char* ptr) const
+    {
+        return (ptr == _bufend) ? _buf : ptr;
+    }
+
+    size_t _size;
+    char* _buf;
+    const char* _bufend;
+    char* _begin;
+    char* _end;
+
+};
+
+#endif//__cbuf_h

cores/esp32/esp32-hal-gpio.c

@@ -0,0 +1,217 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "esp32-hal-gpio.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "rom/ets_sys.h"
+#include "esp_attr.h"
+#include "esp_intr.h"
+#include "rom/gpio.h"
+#include "soc/gpio_reg.h"
+#include "soc/io_mux_reg.h"
+#include "soc/gpio_struct.h"
+
+#define ETS_GPIO_INUM       4
+
+const uint8_t esp32_gpioToFn[40] = {
+    0x44,//0
+    0x88,//1
+    0x40,//2
+    0x84,//3
+    0x48,//4
+    0x6c,//5
+    0x60,//6
+    0x64,//7
+    0x68,//8
+    0x54,//9
+    0x58,//10
+    0x5c,//11
+    0x34,//12
+    0x38,//13
+    0x30,//14
+    0x3c,//15
+    0x4c,//16
+    0x50,//17
+    0x70,//18
+    0x74,//19
+    0x78,//20
+    0x7c,//21
+    0x80,//22
+    0x8c,//23
+    0xFF,//N/A
+    0x24,//25
+    0x28,//26
+    0x2c,//27
+    0xFF,//N/A
+    0xFF,//N/A
+    0xFF,//N/A
+    0xFF,//N/A
+    0x1c,//32
+    0x20,//33
+    0x14,//34
+    0x18,//35
+    0x04,//36
+    0x08,//37
+    0x0c,//38
+    0x10 //39
+};
+
+typedef void (*voidFuncPtr)(void);
+static voidFuncPtr __pinInterruptHandlers[GPIO_PIN_COUNT] = {0,};
+
+extern void IRAM_ATTR __pinMode(uint8_t pin, uint8_t mode)
+{
+    uint32_t pinFunction = 0, pinControl = 0;
+
+    if(pin > 39 || esp32_gpioToFn[pin] == 0xFF) {
+        return;
+    }
+
+    if(mode & INPUT) {
+        if(pin < 32) {
+            GPIO.enable_w1tc = ((uint32_t)1 << pin);
+        } else {
+            GPIO.enable1_w1tc.val = ((uint32_t)1 << (pin - 32));
+        }
+
+        if(mode & PULLUP) {
+            pinFunction |= FUN_PU;
+        } else if(mode & PULLDOWN) {
+            pinFunction |= FUN_PD;
+        }
+
+    } else if(mode & OUTPUT) {
+        if(pin < 32) {
+            GPIO.enable_w1ts = ((uint32_t)1 << pin);
+        } else {
+            GPIO.enable1_w1ts.val = ((uint32_t)1 << (pin - 32));
+        }
+    }
+
+    pinFunction |= ((uint32_t)2 << FUN_DRV_S);//what are the drivers?
+    pinFunction |= FUN_IE;//input enable but required for output as well?
+
+    if(mode & (INPUT | OUTPUT)) {
+        pinFunction |= ((uint32_t)2 << MCU_SEL_S);
+    } else if(mode == SPECIAL) {
+        pinFunction |= ((uint32_t)(((pin)==1||(pin)==3)?0:1) << MCU_SEL_S);
+    } else {
+        pinFunction |= ((uint32_t)(mode >> 5) << MCU_SEL_S);
+    }
+
+    if(mode & OPEN_DRAIN) {
+        pinControl = (1 << GPIO_PIN0_PAD_DRIVER_S);
+    }
+
+    ESP_REG(DR_REG_IO_MUX_BASE + esp32_gpioToFn[pin]) = pinFunction;
+    GPIO.pin[pin].val = pinControl;
+}
+
+extern void IRAM_ATTR __digitalWrite(uint8_t pin, uint8_t val)
+{
+    if(pin > 39) {
+        return;
+    }
+    if(val) {
+        if(pin < 32) {
+            GPIO.out_w1ts = ((uint32_t)1 << pin);
+        } else {
+            GPIO.out1_w1ts.val = ((uint32_t)1 << (pin - 32));
+        }
+    } else {
+        if(pin < 32) {
+            GPIO.out_w1tc = ((uint32_t)1 << pin);
+        } else {
+            GPIO.out1_w1tc.val = ((uint32_t)1 << (pin - 32));
+        }
+    }
+}
+
+extern int IRAM_ATTR __digitalRead(uint8_t pin)
+{
+    if(pin > 39) {
+        return 0;
+    }
+    if(pin < 32) {
+        return (GPIO.in >> pin) & 0x1;
+    } else {
+        return (GPIO.in1.val >> (pin - 32)) & 0x1;
+    }
+}
+
+
+static void IRAM_ATTR __onPinInterrupt(void *arg)
+{
+    uint32_t gpio_intr_status_l=0;
+    uint32_t gpio_intr_status_h=0;
+
+    gpio_intr_status_l = GPIO.status;
+    gpio_intr_status_h = GPIO.status1.val;
+    GPIO.status_w1tc = gpio_intr_status_l;//Clear intr for gpio0-gpio31
+    GPIO.status1_w1tc.val = gpio_intr_status_h;//Clear intr for gpio32-39
+
+    uint8_t pin=0;
+    if(gpio_intr_status_l) {
+        do {
+            if(gpio_intr_status_l & ((uint32_t)1 << pin)) {
+                if(__pinInterruptHandlers[pin]) {
+                    __pinInterruptHandlers[pin]();
+                }
+            }
+        } while(++pin<32);
+    }
+    if(gpio_intr_status_h) {
+        pin=32;
+        do {
+            if(gpio_intr_status_h & ((uint32_t)1 << (pin - 32))) {
+                if(__pinInterruptHandlers[pin]) {
+                    __pinInterruptHandlers[pin]();
+                }
+            }
+        } while(++pin<GPIO_PIN_COUNT);
+    }
+}
+
+extern void __attachInterrupt(uint8_t pin, voidFuncPtr userFunc, int intr_type)
+{
+    static bool interrupt_initialized = false;
+    if(!interrupt_initialized) {
+        interrupt_initialized = true;
+        ESP_INTR_DISABLE(ETS_GPIO_INUM);
+        intr_matrix_set(PRO_CPU_NUM, ETS_GPIO_INTR_SOURCE, ETS_GPIO_INUM);
+        xt_set_interrupt_handler(ETS_GPIO_INUM, &__onPinInterrupt, NULL);
+        ESP_INTR_ENABLE(ETS_GPIO_INUM);
+    }
+    __pinInterruptHandlers[pin] = userFunc;
+    ESP_INTR_DISABLE(ETS_GPIO_INUM);
+    GPIO.pin[pin].val = (GPIO.pin[pin].val & ~((GPIO_PIN0_INT_ENA << GPIO_PIN0_INT_ENA_S) | (GPIO_PIN0_INT_TYPE << GPIO_PIN0_INT_TYPE_S))) | (((uint32_t)0x4 << GPIO_PIN0_INT_ENA_S) | ((uint32_t)intr_type << GPIO_PIN0_INT_TYPE_S));
+    ESP_INTR_ENABLE(ETS_GPIO_INUM);
+}
+
+extern void __detachInterrupt(uint8_t pin)
+{
+    __pinInterruptHandlers[pin] = NULL;
+    ESP_INTR_DISABLE(ETS_GPIO_INUM);
+    GPIO.pin[pin].val = (GPIO.pin[pin].val & ~((GPIO_PIN0_INT_ENA << GPIO_PIN0_INT_ENA_S) | (GPIO_PIN0_INT_TYPE << GPIO_PIN0_INT_TYPE_S)));
+    ESP_INTR_ENABLE(ETS_GPIO_INUM);
+}
+
+
+extern void pinMode(uint8_t pin, uint8_t mode) __attribute__ ((weak, alias("__pinMode")));
+extern void digitalWrite(uint8_t pin, uint8_t val) __attribute__ ((weak, alias("__digitalWrite")));
+extern int digitalRead(uint8_t pin) __attribute__ ((weak, alias("__digitalRead")));
+extern void attachInterrupt(uint8_t pin, voidFuncPtr handler, int mode) __attribute__ ((weak, alias("__attachInterrupt")));
+extern void detachInterrupt(uint8_t pin) __attribute__ ((weak, alias("__detachInterrupt")));
+

cores/esp32/esp32-hal-gpio.h

@@ -0,0 +1,69 @@
+/*
+ Arduino.h - Main include file for the Arduino SDK
+ Copyright (c) 2005-2013 Arduino Team.  All right reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef MAIN_ESP32_HAL_GPIO_H_
+#define MAIN_ESP32_HAL_GPIO_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "esp32-hal.h"
+
+#define LOW               0x0
+#define HIGH              0x1
+
+//GPIO FUNCTIONS
+#define INPUT             0x01
+#define OUTPUT            0x02
+#define PULLUP            0x04
+#define INPUT_PULLUP      0x05
+#define PULLDOWN          0x08
+#define INPUT_PULLDOWN    0x09
+#define OPEN_DRAIN        0x10
+#define OUTPUT_OPEN_DRAIN 0x12
+#define SPECIAL           0xF0
+#define FUNCTION_0        0x00
+#define FUNCTION_1        0x20
+#define FUNCTION_2        0x40
+#define FUNCTION_3        0x70
+#define FUNCTION_4        0x80
+
+//Interrupt Modes
+#define DISABLED  0x00
+#define RISING    0x01
+#define FALLING   0x02
+#define CHANGE    0x03
+#define ONLOW     0x04
+#define ONHIGH    0x05
+#define ONLOW_WE  0x0C
+#define ONHIGH_WE 0x0D
+
+void pinMode(uint8_t pin, uint8_t mode);
+void digitalWrite(uint8_t pin, uint8_t val);
+int digitalRead(uint8_t pin);
+
+void attachInterrupt(uint8_t pin, void (*)(void), int mode);
+void detachInterrupt(uint8_t pin);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MAIN_ESP32_HAL_GPIO_H_ */

cores/esp32/esp32-hal-i2c.c

@@ -0,0 +1,247 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "esp32-hal-i2c.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "rom/ets_sys.h"
+#include "soc/i2c_reg.h"
+#include "soc/dport_reg.h"
+
+#define I2C_DEV(i)   (volatile i2c_dev_t *)((i)?DR_REG_I2C1_EXT_BASE:DR_REG_I2C_EXT_BASE)
+//#define I2C_DEV(i)   ((i2c_dev_t *)(REG_I2C_BASE(i)))
+#define I2C_SCL_IDX(p)  ((p==0)?I2CEXT0_SCL_OUT_IDX:((p==1)?I2CEXT1_SCL_OUT_IDX:0))
+#define I2C_SDA_IDX(p) ((p==0)?I2CEXT0_SDA_OUT_IDX:((p==1)?I2CEXT1_SDA_OUT_IDX:0))
+
+void i2cAttachSCL(i2c_t * i2c, int8_t scl)
+{
+    pinMode(scl, INPUT);
+    pinMatrixOutAttach(scl, I2C_SCL_IDX(i2c->num), false, false);
+    pinMatrixInAttach(scl, I2C_SCL_IDX(i2c->num), false);
+}
+
+void i2cDetachSCL(i2c_t * i2c, int8_t scl)
+{
+    pinMatrixOutDetach(scl, false, false);
+    pinMatrixInDetach(I2C_SCL_IDX(i2c->num), false, false);
+    pinMode(scl, INPUT);
+}
+
+void i2cAttachSDA(i2c_t * i2c, int8_t sda)
+{
+    pinMode(sda, INPUT);
+    pinMatrixOutAttach(sda, I2C_SDA_IDX(i2c->num), false, false);
+    pinMatrixInAttach(sda, I2C_SDA_IDX(i2c->num), false);
+}
+
+void i2cDetachSDA(i2c_t * i2c, int8_t sda)
+{
+    pinMatrixOutDetach(sda, false, false);
+    pinMatrixInDetach(I2C_SDA_IDX(i2c->num), false, false);
+    pinMode(sda, INPUT);
+}
+
+enum {
+    I2C_CMD_RSTART,
+    I2C_CMD_WRITE,
+    I2C_CMD_READ,
+    I2C_CMD_STOP,
+    I2C_CMD_END
+};
+
+/*
+ * index     - command index (0 to 15)
+ * op_code   - is the command
+ * ack_val   - Each data byte is terminated by an ACK bit used to set the bit level.
+ * ack_exp   - This bit is to set an expected ACK value for the transmitter.
+ * ack_check - This bit is to decide whether the transmitter checks ACK bit. 1 means yes and 0 means no.
+ * byte_num  - This register is to store the amounts of data that is read and written. byte_num in RSTART, STOP, END is null.
+ * */
+void i2cSetCmd(i2c_t * i2c, uint8_t index, uint8_t op_code, uint8_t byte_num, bool ack_val, bool ack_exp, bool ack_check)
+{
+    i2c->dev->command[index].val = 0;
+    i2c->dev->command[index].ack_en = ack_check;
+    i2c->dev->command[index].ack_exp = ack_exp;
+    i2c->dev->command[index].ack_val = ack_val;
+    i2c->dev->command[index].byte_num = byte_num;
+    i2c->dev->command[index].op_code = op_code;
+}
+
+int i2cWrite(i2c_t * i2c, uint16_t address, bool addr_10bit, uint8_t * data, uint8_t len, bool sendStop)
+{
+    uint8_t index = 0;
+    uint8_t dataLen = len + (addr_10bit?2:1);
+    address = (address << 1);
+
+    while(dataLen) {
+        uint8_t willSend = (dataLen > 32)?32:dataLen;
+        uint8_t dataSend = willSend;
+        i2cSetCmd(i2c, 0, I2C_CMD_RSTART, 0, false, false, false);//START
+        i2cSetCmd(i2c, 1, I2C_CMD_WRITE, willSend, false, false, true);
+        if(!index) {
+            i2c->dev->fifo_data.data = address & 0xFF;
+            dataSend--;
+            if(addr_10bit) {
+                i2c->dev->fifo_data.data = (address >> 8) & 0xFF;
+                dataSend--;
+            }
+        }
+        int i = 0;
+        while(i<dataSend) {
+            i++;
+            i2c->dev->fifo_data.data = data[index++];
+        }
+        dataLen -= willSend;
+        if(dataLen) {
+            i2cSetCmd(i2c, 2, I2C_CMD_END, 0, false, false, false);
+        } else if(sendStop) {
+            i2cSetCmd(i2c, 2, I2C_CMD_STOP, 0, false, false, true);
+        }
+        i2c->dev->ctr.trans_start = 1;
+        while(i2c->dev->ctr.trans_start || i2c->dev->status_reg.bus_busy || (!i2c->dev->int_raw.ack_err && !i2c->dev->command[2].done));
+        if(!i2c->dev->command[2].done) {
+            log_e("Ack Error");
+            return -1;
+        }
+        if(i2c->dev->status_reg.arb_lost || i2c->dev->status_reg.time_out) {
+            log_e("Bus Fail");
+            return -1;
+        }
+    }
+    return 0;
+}
+
+int i2cRead(i2c_t * i2c, uint16_t address, bool addr_10bit, uint8_t * data, uint8_t len, bool sendStop)
+{
+    address = (address << 1) | 1;
+    uint8_t addrLen = (addr_10bit?2:1);
+    uint8_t index = 0;
+    uint8_t cmdIdx;
+    uint8_t willRead;
+
+    i2cSetCmd(i2c, 0, I2C_CMD_RSTART, 0, false, false, false);//START
+    i2cSetCmd(i2c, 1, I2C_CMD_WRITE, addrLen, false, false, true);
+    i2c->dev->fifo_data.data = address & 0xFF;
+    if(addr_10bit) {
+        i2c->dev->fifo_data.data = (address >> 8) & 0xFF;
+    }
+    while(len) {
+        cmdIdx = (index)?0:2;
+        willRead = (len > 32)?32:(len-1);
+        i2cSetCmd(i2c, cmdIdx++, I2C_CMD_READ, willRead, false, false, false);
+        if((len - willRead) > 1) {
+            i2cSetCmd(i2c, cmdIdx++, I2C_CMD_END, 0, false, false, false);
+        } else {
+            willRead++;
+            i2cSetCmd(i2c, cmdIdx++, I2C_CMD_READ, 1, true, false, false);
+            if(sendStop) {
+                i2cSetCmd(i2c, cmdIdx++, I2C_CMD_STOP, 0, false, false, false);
+            }
+        }
+
+        i2c->dev->ctr.trans_start = 1;
+        while(i2c->dev->ctr.trans_start || i2c->dev->status_reg.bus_busy || (!i2c->dev->int_raw.ack_err && !i2c->dev->command[cmdIdx-1].done));
+        if(!i2c->dev->command[cmdIdx-1].done) {
+            log_e("Ack Error");
+            return -1;
+        }
+        if(i2c->dev->status_reg.arb_lost || i2c->dev->status_reg.time_out) {
+            log_e("Bus Fail");
+            return -1;
+        }
+        int i = 0;
+        while(i<willRead) {
+            i++;
+            data[index++] = i2c->dev->fifo_data.data;
+        }
+        len -= willRead;
+    }
+    return 0;
+}
+
+void i2cResetFiFo(i2c_t * i2c)
+{
+    //TX FIFO
+    i2c->dev->fifo_conf.tx_fifo_rst = 1;
+    i2c->dev->fifo_conf.tx_fifo_rst = 0;
+    //RX FIFO
+    i2c->dev->fifo_conf.rx_fifo_rst = 1;
+    i2c->dev->fifo_conf.rx_fifo_rst = 0;
+}
+
+void i2cSetFrequency(i2c_t * i2c, uint32_t clk_speed)
+{
+    uint32_t period = (APB_CLK_FREQ/clk_speed) / 2;
+    i2c->dev->scl_low_period.scl_low_period = period;
+    i2c->dev->scl_high_period.period = period;
+
+    i2c->dev->scl_start_hold.time = 50;
+    i2c->dev->scl_rstart_setup.time = 50;
+
+    i2c->dev->scl_stop_hold.time   = 50;
+    i2c->dev->scl_stop_setup.time = 50;
+
+    i2c->dev->sda_hold.time     = 40;
+    i2c->dev->sda_sample.time = 40;
+}
+
+uint32_t i2cGetFrequency(i2c_t * i2c)
+{
+    return APB_CLK_FREQ/(i2c->dev->scl_low_period.scl_low_period+i2c->dev->scl_high_period.period);
+}
+
+/*
+ * mode          - 0 = Slave, 1 = Master
+ * slave_addr    - I2C Address
+ * addr_10bit_en - enable slave 10bit address mode.
+ * clk_speed     - SCL Frequency
+ * */
+
+i2c_t * i2cInit(uint8_t i2c_num, uint16_t slave_addr, bool addr_10bit_en)
+{
+    i2c_t* i2c = (i2c_t*) malloc(sizeof(i2c_t));
+    if(i2c == 0) {
+        return NULL;
+    }
+
+    i2c->num = i2c_num;
+    i2c->dev = I2C_DEV(i2c_num);
+
+    if(i2c->num == 0) {
+        SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG,DPORT_I2C_EXT0_CLK_EN);
+        CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG,DPORT_I2C_EXT0_RST);
+    } else if(i2c->num == 1) {
+        SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG,DPORT_I2C_EXT1_CLK_EN);
+        CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG,DPORT_I2C_EXT1_RST);
+    }
+
+    i2c->dev->ctr.rx_lsb_first = 0 ;
+    i2c->dev->ctr.tx_lsb_first = 0 ;
+    i2c->dev->ctr.ms_mode = (slave_addr == 0);
+    i2c->dev->ctr.sda_force_out = 1 ;
+    i2c->dev->ctr.scl_force_out = 1 ;
+    i2c->dev->ctr.sample_scl_level = 0 ;
+
+    i2c->dev->timeout.tout = 2000;
+    i2c->dev->fifo_conf.nonfifo_en = 0;
+
+    if (slave_addr) {
+        i2c->dev->slave_addr.addr = slave_addr;
+        i2c->dev->slave_addr.en_10bit = addr_10bit_en;
+    }
+
+    return i2c;
+}
+
+

cores/esp32/esp32-hal-i2c.h

@@ -0,0 +1,50 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef _ESP32_HAL_I2C_H_
+#define _ESP32_HAL_I2C_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "esp32-hal.h"
+#include "soc/i2c_struct.h"
+
+typedef struct {
+    i2c_dev_t * dev;
+    uint8_t num;
+} i2c_t;
+
+i2c_t * i2cInit(uint8_t i2c_num, uint16_t slave_addr, bool addr_10bit_en);
+
+void i2cSetFrequency(i2c_t * i2c, uint32_t clk_speed);
+uint32_t i2cGetFrequency(i2c_t * i2c);
+
+void i2cResetFiFo(i2c_t * i2c);
+
+void i2cAttachSCL(i2c_t * i2c, int8_t scl);
+void i2cDetachSCL(i2c_t * i2c, int8_t scl);
+void i2cAttachSDA(i2c_t * i2c, int8_t sda);
+void i2cDetachSDA(i2c_t * i2c, int8_t sda);
+
+int i2cWrite(i2c_t * i2c, uint16_t address, bool addr_10bit, uint8_t * data, uint8_t len, bool sendStop);
+int i2cRead(i2c_t * i2c, uint16_t address, bool addr_10bit, uint8_t * data, uint8_t len, bool sendStop);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _ESP32_HAL_I2C_H_ */

cores/esp32/esp32-hal-log.h

@@ -0,0 +1,105 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#ifndef __ARDUHAL_LOG_H__
+#define __ARDUHAL_LOG_H__
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include "sdkconfig.h"
+
+#define ARDUHAL_LOG_LEVEL_NONE       (0)
+#define ARDUHAL_LOG_LEVEL_ERROR      (1)
+#define ARDUHAL_LOG_LEVEL_WARN       (2)
+#define ARDUHAL_LOG_LEVEL_INFO       (3)
+#define ARDUHAL_LOG_LEVEL_DEBUG      (4)
+#define ARDUHAL_LOG_LEVEL_VERBOSE    (5)
+
+#ifndef CONFIG_ARDUHAL_LOG_DEFAULT_LEVEL
+#define CONFIG_ARDUHAL_LOG_DEFAULT_LEVEL ARDUHAL_LOG_LEVEL_NONE
+#endif
+
+#ifndef CONFIG_ARDUHAL_LOG_COLORS
+#define CONFIG_ARDUHAL_LOG_COLORS 0
+#endif
+
+#if CONFIG_ARDUHAL_LOG_COLORS
+#define ARDUHAL_LOG_COLOR_BLACK   "30"
+#define ARDUHAL_LOG_COLOR_RED     "31" //ERROR
+#define ARDUHAL_LOG_COLOR_GREEN   "32" //INFO
+#define ARDUHAL_LOG_COLOR_YELLOW  "33" //WARNING
+#define ARDUHAL_LOG_COLOR_BLUE    "34"
+#define ARDUHAL_LOG_COLOR_MAGENTA "35"
+#define ARDUHAL_LOG_COLOR_CYAN    "36" //DEBUG
+#define ARDUHAL_LOG_COLOR_GRAY    "37" //VERBOSE
+#define ARDUHAL_LOG_COLOR_WHITE   "38"
+
+#define ARDUHAL_LOG_COLOR(COLOR)  "\033[0;" COLOR "m"
+#define ARDUHAL_LOG_BOLD(COLOR)   "\033[1;" COLOR "m"
+#define ARDUHAL_LOG_RESET_COLOR   "\033[0m"
+
+#define ARDUHAL_LOG_COLOR_E       ARDUHAL_LOG_COLOR(ARDUHAL_LOG_COLOR_RED)
+#define ARDUHAL_LOG_COLOR_W       ARDUHAL_LOG_COLOR(ARDUHAL_LOG_COLOR_YELLOW)
+#define ARDUHAL_LOG_COLOR_I       ARDUHAL_LOG_COLOR(ARDUHAL_LOG_COLOR_GREEN)
+#define ARDUHAL_LOG_COLOR_D       ARDUHAL_LOG_COLOR(ARDUHAL_LOG_COLOR_CYAN)
+#define ARDUHAL_LOG_COLOR_V       ARDUHAL_LOG_COLOR(ARDUHAL_LOG_COLOR_GRAY)
+#else
+#define ARDUHAL_LOG_COLOR_E
+#define ARDUHAL_LOG_COLOR_W
+#define ARDUHAL_LOG_COLOR_I
+#define ARDUHAL_LOG_COLOR_D
+#define ARDUHAL_LOG_COLOR_V
+#define ARDUHAL_LOG_RESET_COLOR
+#endif
+
+#define ARDUHAL_SHORT_LOG_FORMAT(letter, format)  ARDUHAL_LOG_COLOR_ ## letter format ARDUHAL_LOG_RESET_COLOR "\r\n"
+#define ARDUHAL_LOG_FORMAT(letter, format)  ARDUHAL_LOG_COLOR_ ## letter "[" #letter "][%s():%d] " format ARDUHAL_LOG_RESET_COLOR "\r\n", __FUNCTION__, __LINE__
+
+#if CONFIG_ARDUHAL_LOG_DEFAULT_LEVEL >= ARDUHAL_LOG_LEVEL_VERBOSE
+#define log_v(format, ...) ets_printf(ARDUHAL_SHORT_LOG_FORMAT(V, format), ##__VA_ARGS__)
+#else
+#define log_v(format, ...)
+#endif
+
+#if CONFIG_ARDUHAL_LOG_DEFAULT_LEVEL >= ARDUHAL_LOG_LEVEL_DEBUG
+#define log_d(format, ...) ets_printf(ARDUHAL_SHORT_LOG_FORMAT(D, format), ##__VA_ARGS__)
+#else
+#define log_d(format, ...)
+#endif
+
+#if CONFIG_ARDUHAL_LOG_DEFAULT_LEVEL >= ARDUHAL_LOG_LEVEL_INFO
+#define log_i(format, ...) ets_printf(ARDUHAL_SHORT_LOG_FORMAT(I, format), ##__VA_ARGS__)
+#else
+#define log_i(format, ...)
+#endif
+
+#if CONFIG_ARDUHAL_LOG_DEFAULT_LEVEL >= ARDUHAL_LOG_LEVEL_WARN
+#define log_w(format, ...) ets_printf(ARDUHAL_LOG_FORMAT(W, format), ##__VA_ARGS__)
+#else
+#define log_w(format, ...)
+#endif
+
+#if CONFIG_ARDUHAL_LOG_DEFAULT_LEVEL >= ARDUHAL_LOG_LEVEL_ERROR
+#define log_e(format, ...) ets_printf(ARDUHAL_LOG_FORMAT(E, format), ##__VA_ARGS__)
+#else
+#define log_e(format, ...)
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __ESP_LOGGING_H__ */

cores/esp32/esp32-hal-matrix.c

@@ -0,0 +1,47 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "esp32-hal-matrix.h"
+#include "esp_attr.h"
+#include "rom/gpio.h"
+
+#define MATRIX_DETACH_OUT_SIG 0x100
+#define MATRIX_DETACH_IN_LOW_PIN 0x30
+#define MATRIX_DETACH_IN_LOW_HIGH 0x38
+
+void IRAM_ATTR pinMatrixOutAttach(uint8_t pin, uint8_t function, bool invertOut, bool invertEnable)
+{
+    gpio_matrix_out(pin, function, invertOut, invertEnable);
+}
+
+void IRAM_ATTR pinMatrixOutDetach(uint8_t pin, bool invertOut, bool invertEnable)
+{
+    gpio_matrix_out(pin, MATRIX_DETACH_OUT_SIG, invertOut, invertEnable);
+}
+
+void IRAM_ATTR pinMatrixInAttach(uint8_t pin, uint8_t signal, bool inverted)
+{
+    gpio_matrix_in(pin, signal, inverted);
+}
+
+void IRAM_ATTR pinMatrixInDetach(uint8_t signal, bool high, bool inverted)
+{
+    gpio_matrix_in(high?MATRIX_DETACH_IN_LOW_HIGH:MATRIX_DETACH_IN_LOW_PIN, signal, inverted);
+}
+/*
+void IRAM_ATTR intrMatrixAttach(uint32_t source, uint32_t inum){
+  intr_matrix_set(PRO_CPU_NUM, source, inum);
+}
+*/
+

cores/esp32/esp32-hal-matrix.h

@@ -0,0 +1,35 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef _ESP32_HAL_MATRIX_H_
+#define _ESP32_HAL_MATRIX_H_
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "esp32-hal.h"
+#include "soc/gpio_sig_map.h"
+
+void pinMatrixOutAttach(uint8_t pin, uint8_t function, bool invertOut, bool invertEnable);
+void pinMatrixOutDetach(uint8_t pin, bool invertOut, bool invertEnable);
+void pinMatrixInAttach(uint8_t pin, uint8_t signal, bool inverted);
+void pinMatrixInDetach(uint8_t signal, bool high, bool inverted);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* COMPONENTS_ARDUHAL_INCLUDE_ESP32_HAL_MATRIX_H_ */

cores/esp32/esp32-hal-misc.c

@@ -0,0 +1,50 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "esp32-hal.h"
+#include "sdkconfig.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_attr.h"
+
+uint32_t IRAM_ATTR micros()
+{
+    uint32_t ccount;
+    __asm__ __volatile__ ( "rsr     %0, ccount" : "=a" (ccount) );
+    return ccount / CONFIG_ESP32_DEFAULT_CPU_FREQ_MHZ;
+    //return system_get_time();
+}
+
+uint32_t IRAM_ATTR millis()
+{
+    return xTaskGetTickCount() * portTICK_PERIOD_MS;
+}
+
+void delay(uint32_t ms)
+{
+    vTaskDelay(ms / portTICK_PERIOD_MS);
+}
+
+void delayMicroseconds(uint32_t us)
+{
+    if(us) {
+        unsigned long endat = micros();
+        endat += us;
+        while(micros() < endat) {
+            NOP();
+        }
+    }
+}
+
+

cores/esp32/esp32-hal-spi.c

@@ -0,0 +1,700 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "esp32-hal-spi.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "rom/ets_sys.h"
+#include "esp_attr.h"
+#include "esp_intr.h"
+#include "rom/gpio.h"
+#include "soc/spi_reg.h"
+#include "soc/io_mux_reg.h"
+#include "soc/gpio_sig_map.h"
+#include "soc/dport_reg.h"
+
+#define SPI_REG_BASE(p) ((p==0)?DR_REG_SPI0_BASE:((p==1)?DR_REG_SPI1_BASE:((p==2)?DR_REG_SPI2_BASE:((p==3)?DR_REG_SPI3_BASE:0))))
+#define SPI_DEV(i)   ((spi_dev_t *)(SPI_REG_BASE(i)))
+
+#define SPI_CLK_IDX(p)  ((p==0)?SPICLK_OUT_IDX:((p==1)?SPICLK_OUT_IDX:((p==2)?HSPICLK_OUT_IDX:((p==3)?VSPICLK_OUT_MUX_IDX:0))))
+#define SPI_MISO_IDX(p) ((p==0)?SPIQ_OUT_IDX:((p==1)?SPIQ_OUT_IDX:((p==2)?HSPIQ_OUT_IDX:((p==3)?VSPIQ_OUT_IDX:0))))
+#define SPI_MOSI_IDX(p) ((p==0)?SPID_IN_IDX:((p==1)?SPID_IN_IDX:((p==2)?HSPID_IN_IDX:((p==3)?VSPID_IN_IDX:0))))
+
+#define SPI_SPI_SS_IDX(n)   ((n==0)?SPICS0_OUT_IDX:((n==1)?SPICS1_OUT_IDX:((n==2)?SPICS2_OUT_IDX:SPICS0_OUT_IDX)))
+#define SPI_HSPI_SS_IDX(n)   ((n==0)?HSPICS0_OUT_IDX:((n==1)?HSPICS1_OUT_IDX:((n==2)?HSPICS2_OUT_IDX:HSPICS0_OUT_IDX)))
+#define SPI_VSPI_SS_IDX(n)   ((n==0)?VSPICS0_OUT_IDX:((n==1)?VSPICS1_OUT_IDX:((n==2)?VSPICS2_OUT_IDX:VSPICS0_OUT_IDX)))
+#define SPI_SS_IDX(p, n)   ((p==0)?SPI_SPI_SS_IDX(n):((p==1)?SPI_SPI_SS_IDX(n):((p==2)?SPI_HSPI_SS_IDX(n):((p==3)?SPI_VSPI_SS_IDX(n):0))))
+
+#define SPI_INUM(u)        (2)
+#define SPI_INTR_SOURCE(u) ((u==0)?ETS_SPI0_INTR_SOURCE:((u==1)?ETS_SPI1_INTR_SOURCE:((u==2)?ETS_SPI2_INTR_SOURCE:((p==3)?ETS_SPI3_INTR_SOURCE:0))))
+
+void spiAttachSCK(spi_t * spi, int8_t sck)
+{
+    if(!spi) {
+        return;
+    }
+    if(sck < 0) {
+        if(spi->num == HSPI) {
+            sck = 14;
+        } else if(spi->num == VSPI) {
+            sck = 18;
+        } else {
+            sck = 6;
+        }
+    }
+    pinMode(sck, OUTPUT);
+    pinMatrixOutAttach(sck, SPI_CLK_IDX(spi->num), false, false);
+}
+
+void spiAttachMISO(spi_t * spi, int8_t miso)
+{
+    if(!spi) {
+        return;
+    }
+    if(miso < 0) {
+        if(spi->num == HSPI) {
+            miso = 12;
+        } else if(spi->num == VSPI) {
+            miso = 19;
+        } else {
+            miso = 7;
+        }
+    }
+    pinMode(miso, INPUT);
+    pinMatrixInAttach(miso, SPI_MISO_IDX(spi->num), false);
+}
+
+void spiAttachMOSI(spi_t * spi, int8_t mosi)
+{
+    if(!spi) {
+        return;
+    }
+    if(mosi < 0) {
+        if(spi->num == HSPI) {
+            mosi = 13;
+        } else if(spi->num == VSPI) {
+            mosi = 23;
+        } else {
+            mosi = 8;
+        }
+    }
+    pinMode(mosi, OUTPUT);
+    pinMatrixOutAttach(mosi, SPI_MOSI_IDX(spi->num), false, false);
+}
+
+void spiDetachSCK(spi_t * spi, int8_t sck)
+{
+    if(!spi) {
+        return;
+    }
+    if(sck < 0) {
+        if(spi->num == HSPI) {
+            sck = 14;
+        } else if(spi->num == VSPI) {
+            sck = 18;
+        } else {
+            sck = 6;
+        }
+    }
+    pinMatrixOutDetach(sck, false, false);
+    pinMode(sck, INPUT);
+}
+
+void spiDetachMISO(spi_t * spi, int8_t miso)
+{
+    if(!spi) {
+        return;
+    }
+    if(miso < 0) {
+        if(spi->num == HSPI) {
+            miso = 12;
+        } else if(spi->num == VSPI) {
+            miso = 19;
+        } else {
+            miso = 7;
+        }
+    }
+    pinMatrixInDetach(SPI_MISO_IDX(spi->num), false, false);
+    pinMode(miso, INPUT);
+}
+
+void spiDetachMOSI(spi_t * spi, int8_t mosi)
+{
+    if(!spi) {
+        return;
+    }
+    if(mosi < 0) {
+        if(spi->num == HSPI) {
+            mosi = 13;
+        } else if(spi->num == VSPI) {
+            mosi = 23;
+        } else {
+            mosi = 8;
+        }
+    }
+    pinMatrixOutDetach(mosi, false, false);
+    pinMode(mosi, INPUT);
+}
+
+void spiAttachSS(spi_t * spi, uint8_t cs_num, int8_t ss)
+{
+    if(!spi) {
+        return;
+    }
+    if(cs_num > 2) {
+        return;
+    }
+    if(ss < 0) {
+        cs_num = 0;
+        if(spi->num == HSPI) {
+            ss = 15;
+        } else if(spi->num == VSPI) {
+            ss = 5;
+        } else {
+            ss = 11;
+        }
+    }
+    pinMode(ss, OUTPUT);
+    pinMatrixOutAttach(ss, SPI_SS_IDX(spi->num, cs_num), false, false);
+    spiEnableSSPins(spi, (1 << cs_num));
+}
+
+void spiDetachSS(spi_t * spi, int8_t ss)
+{
+    if(!spi) {
+        return;
+    }
+    if(ss < 0) {
+        if(spi->num == HSPI) {
+            ss = 15;
+        } else if(spi->num == VSPI) {
+            ss = 5;
+        } else {
+            ss = 11;
+        }
+    }
+    pinMatrixOutDetach(ss, false, false);
+    pinMode(ss, INPUT);
+}
+
+void spiEnableSSPins(spi_t * spi, uint8_t cs_mask)
+{
+    if(!spi) {
+        return;
+    }
+    spi->dev->pin.val &= ~(cs_mask & SPI_CS_MASK_ALL);
+}
+
+void spiDisableSSPins(spi_t * spi, uint8_t cs_mask)
+{
+    if(!spi) {
+        return;
+    }
+    spi->dev->pin.val |= (cs_mask & SPI_CS_MASK_ALL);
+}
+
+void spiSSEnable(spi_t * spi)
+{
+    if(!spi) {
+        return;
+    }
+    spi->dev->user.cs_setup = 1;
+    spi->dev->user.cs_hold = 1;
+}
+
+void spiSSDisable(spi_t * spi)
+{
+    if(!spi) {
+        return;
+    }
+    spi->dev->user.cs_setup = 0;
+    spi->dev->user.cs_hold = 0;
+}
+
+void spiSSSet(spi_t * spi)
+{
+    if(!spi) {
+        return;
+    }
+    spi->dev->pin.cs_keep_active = 1;
+}
+
+void spiSSClear(spi_t * spi)
+{
+    if(!spi) {
+        return;
+    }
+    spi->dev->pin.cs_keep_active = 0;
+}
+
+uint32_t spiGetClockDiv(spi_t * spi)
+{
+    if(!spi) {
+        return 0;
+    }
+    return spi->dev->clock.val;
+}
+
+void spiSetClockDiv(spi_t * spi, uint32_t clockDiv)
+{
+    if(!spi) {
+        return;
+    }
+    spi->dev->clock.val = clockDiv;
+}
+
+uint8_t spiGetDataMode(spi_t * spi)
+{
+    if(!spi) {
+        return 0;
+    }
+    bool idleEdge = spi->dev->pin.ck_idle_edge;
+    bool outEdge = spi->dev->user.ck_out_edge;
+    if(idleEdge) {
+        if(outEdge) {
+            return SPI_MODE3;
+        }
+        return SPI_MODE2;
+    }
+    if(outEdge) {
+        return SPI_MODE1;
+    }
+    return SPI_MODE0;
+}
+
+void spiSetDataMode(spi_t * spi, uint8_t dataMode)
+{
+    if(!spi) {
+        return;
+    }
+    switch (dataMode) {
+    case SPI_MODE1:
+        spi->dev->pin.ck_idle_edge = 0;
+        spi->dev->user.ck_out_edge = 1;
+        break;
+    case SPI_MODE2:
+        spi->dev->pin.ck_idle_edge = 1;
+        spi->dev->user.ck_out_edge = 0;
+        break;
+    case SPI_MODE3:
+        spi->dev->pin.ck_idle_edge = 1;
+        spi->dev->user.ck_out_edge = 1;
+        break;
+    case SPI_MODE0:
+    default:
+        spi->dev->pin.ck_idle_edge = 0;
+        spi->dev->user.ck_out_edge = 0;
+        break;
+    }
+}
+
+uint8_t spiGetBitOrder(spi_t * spi)
+{
+    if(!spi) {
+        return 0;
+    }
+    return (spi->dev->ctrl.wr_bit_order | spi->dev->ctrl.rd_bit_order) == 0;
+}
+
+void spiSetBitOrder(spi_t * spi, uint8_t bitOrder)
+{
+    if(!spi) {
+        return;
+    }
+    if (SPI_MSBFIRST == bitOrder) {
+        spi->dev->ctrl.wr_bit_order = 0;
+        spi->dev->ctrl.rd_bit_order = 0;
+    } else if (SPI_LSBFIRST == bitOrder) {
+        spi->dev->ctrl.wr_bit_order = 1;
+        spi->dev->ctrl.rd_bit_order = 1;
+    }
+}
+
+void spiStopBus(spi_t * spi)
+{
+    if(!spi) {
+        return;
+    }
+    spi->dev->slave.trans_done = 0;
+    spi->dev->slave.slave_mode = 0;
+    spi->dev->pin.val = 0;
+    spi->dev->user.val = 0;
+    spi->dev->user1.val = 0;
+    spi->dev->ctrl.val = 0;
+    spi->dev->ctrl1.val = 0;
+    spi->dev->ctrl2.val = 0;
+    spi->dev->clock.val = 0;
+}
+
+spi_t * spiStartBus(uint8_t spi_num, uint32_t clockDiv, uint8_t dataMode, uint8_t bitOrder)
+{
+
+    spi_t* spi = (spi_t*) malloc(sizeof(spi_t));
+    if(spi == 0) {
+        return NULL;
+    }
+
+    spi->num = spi_num;
+    spi->dev = (spi_dev_t *)SPI_DEV(spi_num);
+
+    if(spi_num == HSPI) {
+        SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI_CLK_EN_1);
+        CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI_RST_1);
+    } else if(spi_num == VSPI) {
+        SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI_CLK_EN_2);
+        CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI_RST_2);
+    } else {
+        SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI_CLK_EN);
+        CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI_RST);
+    }
+
+    spiStopBus(spi);
+    spiSetDataMode(spi, dataMode);
+    spiSetBitOrder(spi, bitOrder);
+    spiSetClockDiv(spi, clockDiv);
+
+    spi->dev->user.usr_mosi = 1;
+    spi->dev->user.usr_miso = 1;
+    spi->dev->user.doutdin = 1;
+
+    int i;
+    for(i=0; i<16; i++) {
+        spi->dev->data_buf[i] = 0x00000000;
+    }
+
+    return spi;
+}
+
+void spiWaitReady(spi_t * spi)
+{
+    if(!spi) {
+        return;
+    }
+    while(spi->dev->cmd.usr);
+}
+
+void spiWrite(spi_t * spi, uint32_t *data, uint8_t len)
+{
+    if(!spi) {
+        return;
+    }
+    int i;
+    if(len > 16) {
+        len = 16;
+    }
+    while(spi->dev->cmd.usr);
+    spi->dev->mosi_dlen.usr_mosi_dbitlen = (len * 32) - 1;
+    spi->dev->miso_dlen.usr_miso_dbitlen = (len * 32) - 1;
+    for(i=0; i<len; i++) {
+        spi->dev->data_buf[i] = data[i];
+    }
+    spi->dev->cmd.usr = 1;
+}
+
+void spiRead(spi_t * spi, uint32_t *data, uint8_t len)
+{
+    if(!spi) {
+        return;
+    }
+    int i;
+    if(len > 16) {
+        len = 16;
+    }
+    while(spi->dev->cmd.usr);
+    for(i=0; i<len; i++) {
+        data[i] = spi->dev->data_buf[i];
+    }
+}
+
+void spiWriteByte(spi_t * spi, uint8_t data)
+{
+    if(!spi) {
+        return;
+    }
+    while(spi->dev->cmd.usr);
+    spi->dev->mosi_dlen.usr_mosi_dbitlen = 7;
+    spi->dev->miso_dlen.usr_miso_dbitlen = 7;
+    spi->dev->data_buf[0] = data;
+    spi->dev->cmd.usr = 1;
+}
+
+uint8_t spiReadByte(spi_t * spi)
+{
+    if(!spi) {
+        return 0;
+    }
+    while(spi->dev->cmd.usr);
+    return spi->dev->data_buf[0] & 0xFF;
+}
+
+uint32_t __spiTranslate16(uint16_t data, bool msb)
+{
+    if(msb) {
+        return (data >> 8) | (data << 8);
+    } else {
+        return data;
+    }
+}
+
+uint32_t __spiTranslate24(uint32_t data, bool msb)
+{
+    if(msb) {
+        union {
+            uint32_t l;
+            uint8_t b[4];
+        } out;
+        out.l = data;
+        return out.b[2] | (out.b[1] << 8) | (out.b[0] << 16);
+    } else {
+        return data;
+    }
+}
+
+uint32_t __spiTranslate32(uint32_t data, bool msb)
+{
+    if(msb) {
+        union {
+            uint32_t l;
+            uint8_t b[4];
+        } out;
+        out.l = data;
+        return out.b[3] | (out.b[2] << 8) | (out.b[1] << 16) | (out.b[0] << 24);
+    } else {
+        return data;
+    }
+}
+
+void spiWriteWord(spi_t * spi, uint16_t data)
+{
+    if(!spi) {
+        return;
+    }
+    while(spi->dev->cmd.usr);
+    spi->dev->mosi_dlen.usr_mosi_dbitlen = 15;
+    spi->dev->miso_dlen.usr_miso_dbitlen = 15;
+    spi->dev->data_buf[0] = __spiTranslate16(data, !spi->dev->ctrl.wr_bit_order);
+    spi->dev->cmd.usr = 1;
+}
+
+uint16_t spiReadWord(spi_t * spi)
+{
+    if(!spi) {
+        return 0;
+    }
+    while(spi->dev->cmd.usr);
+    return __spiTranslate16(spi->dev->data_buf[0] & 0xFFFF, !spi->dev->ctrl.rd_bit_order);
+}
+
+void spiWriteLong(spi_t * spi, uint32_t data)
+{
+    if(!spi) {
+        return;
+    }
+    while(spi->dev->cmd.usr);
+    spi->dev->mosi_dlen.usr_mosi_dbitlen = 31;
+    spi->dev->miso_dlen.usr_miso_dbitlen = 31;
+    spi->dev->data_buf[0] = __spiTranslate32(data, !spi->dev->ctrl.wr_bit_order);
+    spi->dev->cmd.usr = 1;
+}
+
+uint32_t spiReadLong(spi_t * spi)
+{
+    if(!spi) {
+        return 0;
+    }
+    while(spi->dev->cmd.usr);
+    return __spiTranslate32(spi->dev->data_buf[0], !spi->dev->ctrl.rd_bit_order);
+}
+
+void spiTransferBits(spi_t * spi, uint32_t data, uint32_t * out, uint8_t bits)
+{
+    if(!spi) {
+        return;
+    }
+
+    if(bits > 32) {
+        bits = 32;
+    }
+    uint32_t bytes = (bits + 7) / 8;//64 max
+    uint32_t mask = (((uint64_t)1 << bits) - 1) & 0xFFFFFFFF;
+
+    while(spi->dev->cmd.usr);
+    spi->dev->mosi_dlen.usr_mosi_dbitlen = (bits - 1);
+    spi->dev->miso_dlen.usr_miso_dbitlen = (bits - 1);
+    if(bytes == 1) {
+        spi->dev->data_buf[0] = data & mask;
+    } else if(bytes == 2) {
+        spi->dev->data_buf[0] = __spiTranslate16(data & mask, !spi->dev->ctrl.wr_bit_order);
+    } else if(bytes == 3) {
+        spi->dev->data_buf[0] = __spiTranslate24(data & mask, !spi->dev->ctrl.wr_bit_order);
+    } else {
+        spi->dev->data_buf[0] = __spiTranslate32(data & mask, !spi->dev->ctrl.wr_bit_order);
+    }
+    spi->dev->cmd.usr = 1;
+
+    if(out) {
+        while(spi->dev->cmd.usr);
+        if(bytes == 1) {
+            *out = spi->dev->data_buf[0] & mask;
+        } else if(bytes == 2) {
+            *out = __spiTranslate16(spi->dev->data_buf[0] & mask, !spi->dev->ctrl.wr_bit_order);
+        } else if(bytes == 3) {
+            *out = __spiTranslate24(spi->dev->data_buf[0] & mask, !spi->dev->ctrl.wr_bit_order);
+        } else {
+            *out = __spiTranslate32(spi->dev->data_buf[0] & mask, !spi->dev->ctrl.wr_bit_order);
+        }
+    }
+}
+
+void __spiTransferBytes(spi_t * spi, uint8_t * data, uint8_t * out, uint32_t bytes)
+{
+    if(!spi) {
+        return;
+    }
+    int i;
+
+    if(bytes > 64) {
+        bytes = 64;
+    }
+
+    uint32_t words = (bytes + 3) / 4;//16 max
+
+    uint32_t wordsBuf[16] = {0,};
+    uint8_t * bytesBuf = (uint8_t *) wordsBuf;
+
+    if(data) {
+        for(i=0; i<bytes; i++) {
+            bytesBuf[i] = data[i];//copy data to buffer
+        }
+    }
+
+    while(spi->dev->cmd.usr);
+    spi->dev->mosi_dlen.usr_mosi_dbitlen = ((bytes * 8) - 1);
+    spi->dev->miso_dlen.usr_miso_dbitlen = ((bytes * 8) - 1);
+
+    for(i=0; i<words; i++) {
+        spi->dev->data_buf[i] = wordsBuf[i];    //copy buffer to spi fifo
+    }
+
+    spi->dev->cmd.usr = 1;
+
+    if(out) {
+        while(spi->dev->cmd.usr);
+        for(i=0; i<words; i++) {
+            wordsBuf[i] = spi->dev->data_buf[i];//copy spi fifo to buffer
+        }
+        for(i=0; i<bytes; i++) {
+            out[i] = bytesBuf[i];//copy buffer to output
+        }
+    }
+}
+
+void spiTransferBytes(spi_t * spi, uint8_t * data, uint8_t * out, uint32_t size)
+{
+    if(!spi) {
+        return;
+    }
+    while(size) {
+        if(size > 64) {
+            __spiTransferBytes(spi, data, out, 64);
+            size -= 64;
+            if(data) {
+                data += 64;
+            }
+            if(out) {
+                out += 64;
+            }
+        } else {
+            __spiTransferBytes(spi, data, out, size);
+            size = 0;
+        }
+    }
+}
+
+
+typedef union {
+    uint32_t regValue;
+    struct {
+        unsigned regL :6;
+        unsigned regH :6;
+        unsigned regN :6;
+        unsigned regPre :13;
+        unsigned regEQU :1;
+    };
+} spiClk_t;
+
+#define ClkRegToFreq(reg) (CPU_CLK_FREQ / (((reg)->regPre + 1) * ((reg)->regN + 1)))
+
+uint32_t spiClockDivToFrequency(uint32_t clockDiv)
+{
+    spiClk_t reg = { clockDiv };
+    return ClkRegToFreq(&reg);
+}
+
+uint32_t spiFrequencyToClockDiv(uint32_t freq)
+{
+
+    if(freq >= CPU_CLK_FREQ) {
+        return SPI_CLK_EQU_SYSCLK;
+    }
+
+    const spiClk_t minFreqReg = { 0x7FFFF000 };
+    uint32_t minFreq = ClkRegToFreq((spiClk_t*) &minFreqReg);
+    if(freq < minFreq) {
+        return minFreqReg.regValue;
+    }
+
+    uint8_t calN = 1;
+    spiClk_t bestReg = { 0 };
+    int32_t bestFreq = 0;
+
+    while(calN <= 0x3F) {
+        spiClk_t reg = { 0 };
+        int32_t calFreq;
+        int32_t calPre;
+        int8_t calPreVari = -2;
+
+        reg.regN = calN;
+
+        while(calPreVari++ <= 1) {
+            calPre = (((CPU_CLK_FREQ / (reg.regN + 1)) / freq) - 1) + calPreVari;
+            if(calPre > 0x1FFF) {
+                reg.regPre = 0x1FFF;
+            } else if(calPre <= 0) {
+                reg.regPre = 0;
+            } else {
+                reg.regPre = calPre;
+            }
+            reg.regL = ((reg.regN + 1) / 2);
+            calFreq = ClkRegToFreq(&reg);
+            if(calFreq == (int32_t) freq) {
+                memcpy(&bestReg, &reg, sizeof(bestReg));
+                break;
+            } else if(calFreq < (int32_t) freq) {
+                if(abs(freq - calFreq) < abs(freq - bestFreq)) {
+                    bestFreq = calFreq;
+                    memcpy(&bestReg, &reg, sizeof(bestReg));
+                }
+            }
+        }
+        if(calFreq == (int32_t) freq) {
+            break;
+        }
+        calN++;
+    }
+    return bestReg.regValue;
+}
+
+
+

cores/esp32/esp32-hal-spi.h

@@ -0,0 +1,118 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef MAIN_ESP32_HAL_SPI_H_
+#define MAIN_ESP32_HAL_SPI_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "esp32-hal.h"
+#include "soc/spi_struct.h"
+
+#define SPI_HAS_TRANSACTION
+
+#define FSPI  1 //SPI bus attached to the flash (can use the same data lines but different SS)
+#define HSPI  2 //SPI bus normally mapped to pins 12 - 15, but can be matrixed to any pins
+#define VSPI  3 //SPI bus normally attached to pins 5, 18, 19 and 23, but can be matrixed to any pins
+
+// This defines are not representing the real Divider of the ESP32
+// the Defines match to an AVR Arduino on 16MHz for better compatibility
+#define SPI_CLOCK_DIV2    0x00101001 //8 MHz
+#define SPI_CLOCK_DIV4    0x00241001 //4 MHz
+#define SPI_CLOCK_DIV8    0x004c1001 //2 MHz
+#define SPI_CLOCK_DIV16   0x009c1001 //1 MHz
+#define SPI_CLOCK_DIV32   0x013c1001 //500 KHz
+#define SPI_CLOCK_DIV64   0x027c1001 //250 KHz
+#define SPI_CLOCK_DIV128  0x04fc1001 //125 KHz
+
+#define SPI_MODE0 0
+#define SPI_MODE1 1
+#define SPI_MODE2 2
+#define SPI_MODE3 3
+
+#define SPI_CS0 0
+#define SPI_CS1 1
+#define SPI_CS2 2
+#define SPI_CS_MASK_ALL 0x7
+
+#define SPI_LSBFIRST 0
+#define SPI_MSBFIRST 1
+
+typedef struct {
+    spi_dev_t * dev;
+    uint8_t num;
+} spi_t;
+
+spi_t * spiStartBus(uint8_t spi_num, uint32_t freq, uint8_t dataMode, uint8_t bitOrder);
+void spiStopBus(spi_t * spi);
+
+//Attach/Detach Signal Pins
+void spiAttachSCK(spi_t * spi, int8_t sck);
+void spiAttachMISO(spi_t * spi, int8_t miso);
+void spiAttachMOSI(spi_t * spi, int8_t mosi);
+void spiDetachSCK(spi_t * spi, int8_t sck);
+void spiDetachMISO(spi_t * spi, int8_t miso);
+void spiDetachMOSI(spi_t * spi, int8_t mosi);
+
+//Attach/Detach SS pin to SPI_CSx signal
+void spiAttachSS(spi_t * spi, uint8_t cs_num, int8_t ss);
+void spiDetachSS(spi_t * spi, int8_t ss);
+
+//Enable/Disable SPI_CSx pins
+void spiEnableSSPins(spi_t * spi, uint8_t cs_mask);
+void spiDisableSSPins(spi_t * spi, uint8_t cs_mask);
+
+//Enable/Disable hardware control of SPI_CSx pins
+void spiSSEnable(spi_t * spi);
+void spiSSDisable(spi_t * spi);
+
+//Activate enabled SPI_CSx pins
+void spiSSSet(spi_t * spi);
+//Deactivate enabled SPI_CSx pins
+void spiSSClear(spi_t * spi);
+
+void spiWaitReady(spi_t * spi);
+
+uint32_t spiGetClockDiv(spi_t * spi);
+void spiSetClockDiv(spi_t * spi, uint32_t clockDiv);
+
+uint8_t spiGetDataMode(spi_t * spi);
+void spiSetDataMode(spi_t * spi, uint8_t dataMode);
+
+uint8_t spiGetBitOrder(spi_t * spi);
+void spiSetBitOrder(spi_t * spi, uint8_t bitOrder);
+
+void spiWrite(spi_t * spi, uint32_t *data, uint8_t len);
+void spiWriteByte(spi_t * spi, uint8_t data);
+void spiWriteWord(spi_t * spi, uint16_t data);
+void spiWriteLong(spi_t * spi, uint32_t data);
+
+void spiRead(spi_t * spi, uint32_t *out, uint8_t len);
+uint8_t spiReadByte(spi_t * spi);
+uint16_t spiReadWord(spi_t * spi);
+uint32_t spiReadLong(spi_t * spi);
+
+void spiTransferBits(spi_t * spi, uint32_t data, uint32_t * out, uint8_t bits);
+void spiTransferBytes(spi_t * spi, uint8_t * data, uint8_t * out, uint32_t size);
+
+uint32_t spiFrequencyToClockDiv(uint32_t freq);
+uint32_t spiClockDivToFrequency(uint32_t freq);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MAIN_ESP32_HAL_SPI_H_ */

cores/esp32/esp32-hal-uart.c

@@ -0,0 +1,270 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "esp32-hal-uart.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/semphr.h"
+#include "rom/ets_sys.h"
+#include "esp_attr.h"
+#include "esp_intr.h"
+#include "rom/uart.h"
+#include "soc/uart_reg.h"
+#include "soc/io_mux_reg.h"
+#include "soc/gpio_sig_map.h"
+
+#define ETS_UART2_INUM  5
+
+#define UART_REG_BASE(u)    ((u==0)?DR_REG_UART_BASE:(      (u==1)?DR_REG_UART1_BASE:(    (u==2)?DR_REG_UART2_BASE:0)))
+#define UART_RXD_IDX(u)     ((u==0)?U0RXD_IN_IDX:(          (u==1)?U1RXD_IN_IDX:(         (u==2)?U2RXD_IN_IDX:0)))
+#define UART_TXD_IDX(u)     ((u==0)?U0TXD_OUT_IDX:(         (u==1)?U1TXD_OUT_IDX:(        (u==2)?U2TXD_OUT_IDX:0)))
+#define UART_INUM(u)        ((u==0)?ETS_UART0_INUM:(        (u==1)?ETS_UART1_INUM:(       (u==2)?ETS_UART2_INUM:0)))
+#define UART_INTR_SOURCE(u) ((u==0)?ETS_UART0_INTR_SOURCE:( (u==1)?ETS_UART1_INTR_SOURCE:((u==2)?ETS_UART2_INTR_SOURCE:0)))
+
+static int s_uart_debug_nr = 0;
+
+static void IRAM_ATTR _uart_isr(void *arg)
+{
+    uint8_t c;
+    BaseType_t xHigherPriorityTaskWoken;
+    uart_t* uart = (uart_t*)arg;
+
+    uart->dev->int_clr.val = UART_RXFIFO_FULL_INT_ENA | UART_FRM_ERR_INT_ENA | UART_RXFIFO_TOUT_INT_ENA; //Acknowledge the interrupt
+    while(uart->dev->status.rxfifo_cnt) {
+        c = uart->dev->fifo.rw_byte;
+        if(!xQueueIsQueueFullFromISR(uart->queue)) {
+            xQueueSendFromISR(uart->queue, &c, &xHigherPriorityTaskWoken);
+        }
+    }
+
+    if (xHigherPriorityTaskWoken) {
+        portYIELD_FROM_ISR();
+    }
+}
+
+uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t queueLen, bool inverted)
+{
+    uint32_t conf1 = 0;
+
+    if(uart_nr > 2) {
+        return NULL;
+    }
+
+    if(rxPin == -1 && txPin == -1) {
+        return NULL;
+    }
+
+    uart_t* uart = (uart_t*) malloc(sizeof(uart_t));
+    if(uart == 0) {
+        return NULL;
+    }
+
+    uart->dev = (uart_dev_t *)UART_REG_BASE(uart_nr);
+    uart->num = uart_nr;
+    uart->inverted = inverted;
+
+    uart->rxPin = rxPin;
+    uart->txPin = txPin;
+    uart->rxEnabled = (uart->rxPin != -1);
+    uart->txEnabled = (uart->txPin != -1);
+
+    uartFlush(uart);
+
+    if(uart->rxEnabled) {
+        uart->queue = xQueueCreate(queueLen, sizeof(uint8_t)); //initialize the queue
+        if(uart->queue == NULL) {
+            free(uart);
+            return NULL;
+        }
+
+        pinMode(uart->rxPin, INPUT);
+        pinMatrixInAttach(uart->rxPin, UART_RXD_IDX(uart->num), uart->inverted);
+        intr_matrix_set(PRO_CPU_NUM, UART_INTR_SOURCE(uart->num), UART_INUM(uart->num));
+        xt_set_interrupt_handler(UART_INUM(uart->num), _uart_isr, uart);
+        ESP_INTR_ENABLE(UART_INUM(uart->num));
+        conf1 = (112 << UART_RXFIFO_FULL_THRHD_S) | (0x02 << UART_RX_TOUT_THRHD_S) | UART_RX_TOUT_EN;
+        uart->dev->int_ena.val = UART_RXFIFO_FULL_INT_ENA | UART_FRM_ERR_INT_ENA | UART_RXFIFO_TOUT_INT_ENA;
+        uart->dev->int_clr.val = 0xffff;
+    }
+    if(uart->txEnabled) {
+        pinMode(uart->txPin, OUTPUT);
+        pinMatrixOutAttach(uart->txPin, UART_TXD_IDX(uart->num), uart->inverted, false);
+    }
+
+    uartSetBaudRate(uart, baudrate);
+    uart->dev->conf0.val = config;
+    uart->dev->conf1.val = conf1;
+    return uart;
+}
+
+void uartEnd(uart_t* uart)
+{
+    if(uart == 0) {
+        return;
+    }
+
+    if(uart->rxEnabled) {
+        pinMode(uart->rxPin, INPUT);
+        if(uart->num || uart->rxPin != 3) {
+            pinMatrixInDetach(UART_RXD_IDX(uart->num), uart->inverted, false);
+        }
+
+        ESP_INTR_DISABLE(UART_INUM(uart->num));
+        xt_set_interrupt_handler(UART_INUM(uart->num), NULL, NULL);
+        vQueueDelete(uart->queue);
+    }
+    if(uart->txEnabled) {
+        pinMode(uart->txPin, INPUT);
+        if(uart->num || uart->txPin != 1) {
+            pinMatrixInDetach(UART_TXD_IDX(uart->num), !uart->inverted, uart->inverted);
+        }
+    }
+
+    uart->dev->conf0.val = 0;
+    uart->dev->conf1.val = 0;
+    uart->dev->int_ena.val = 0;
+    uart->dev->int_clr.val = 0xffff;
+
+    free(uart);
+}
+
+uint32_t uartAvailable(uart_t* uart)
+{
+    return uxQueueMessagesWaiting(uart->queue);
+}
+
+uint8_t uartRead(uart_t* uart)
+{
+    uint8_t c;
+    if(xQueueReceive(uart->queue, &c, 0)) {
+        return c;
+    }
+    return 0;
+}
+
+uint8_t uartPeek(uart_t* uart)
+{
+    uint8_t c;
+    if(xQueuePeek(uart->queue, &c, 0)) {
+        return c;
+    }
+    return 0;
+}
+
+void uartWrite(uart_t* uart, uint8_t c)
+{
+    while(uart->dev->status.rxfifo_cnt == 0x7F);
+    uart->dev->fifo.rw_byte = c;
+}
+
+void uartWriteBuf(uart_t* uart, const uint8_t * data, size_t len)
+{
+    while(len && uart->dev->status.rxfifo_cnt < 0x7F) {
+        uart->dev->fifo.rw_byte = *data++;
+        len--;
+    }
+}
+
+void uartFlush(uart_t* uart)
+{
+    uint32_t tmp = 0x00000000;
+
+    if(uart == 0) {
+        return;
+    }
+
+    if(uart->rxEnabled) {
+        tmp |= UART_RXFIFO_RST;
+    }
+
+    if(uart->txEnabled) {
+        tmp |= UART_TXFIFO_RST;
+        while(uart->dev->status.txfifo_cnt);
+    }
+
+    uart->dev->conf0.val |= (tmp);
+    uart->dev->conf0.val &= ~(tmp);
+}
+
+void uartSetBaudRate(uart_t* uart, uint32_t baud_rate)
+{
+    if(uart == 0) {
+        return;
+    }
+    uart->baud_rate = baud_rate;
+    uint32_t clk_div = ((UART_CLK_FREQ<<4)/baud_rate);
+    uart->dev->clk_div.div_int = clk_div>>4 ;
+    uart->dev->clk_div.div_frag = clk_div & 0xf;
+}
+
+uint32_t uartGetBaudRate(uart_t* uart)
+{
+    if(uart == 0) {
+        return 0;
+    }
+    return uart->baud_rate;
+}
+
+static void IRAM_ATTR uart0_write_char(char c)
+{
+    while(((ESP_REG(0x01C+DR_REG_UART_BASE) >> UART_TXFIFO_CNT_S) & 0x7F) == 0x7F);
+    ESP_REG(DR_REG_UART_BASE) = c;
+}
+
+static void IRAM_ATTR uart1_write_char(char c)
+{
+    while(((ESP_REG(0x01C+DR_REG_UART1_BASE) >> UART_TXFIFO_CNT_S) & 0x7F) == 0x7F);
+    ESP_REG(DR_REG_UART1_BASE) = c;
+}
+
+static void IRAM_ATTR uart2_write_char(char c)
+{
+    while(((ESP_REG(0x01C+DR_REG_UART2_BASE) >> UART_TXFIFO_CNT_S) & 0x7F) == 0x7F);
+    ESP_REG(DR_REG_UART2_BASE) = c;
+}
+
+void uartSetDebug(uart_t* uart)
+{
+    if(uart == NULL || uart->num > 2) {
+        s_uart_debug_nr = -1;
+        ets_install_putc1(NULL);
+        return;
+    }
+    if(s_uart_debug_nr == uart->num) {
+        return;
+    }
+    s_uart_debug_nr = uart->num;
+    switch(s_uart_debug_nr) {
+    case 0:
+        ets_install_putc1((void (*)(char)) &uart0_write_char);
+        break;
+    case 1:
+        ets_install_putc1((void (*)(char)) &uart1_write_char);
+        break;
+    case 2:
+        ets_install_putc1((void (*)(char)) &uart2_write_char);
+        break;
+    default:
+        ets_install_putc1(NULL);
+        break;
+    }
+}
+
+int uartGetDebug()
+{
+    return s_uart_debug_nr;
+}
+
+
+

cores/esp32/esp32-hal-uart.h

@@ -0,0 +1,84 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef MAIN_ESP32_HAL_UART_H_
+#define MAIN_ESP32_HAL_UART_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "esp32-hal.h"
+#include "soc/uart_struct.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/queue.h"
+
+#define SERIAL_5N1 0x8000010
+#define SERIAL_6N1 0x8000014
+#define SERIAL_7N1 0x8000018
+#define SERIAL_8N1 0x800001c
+#define SERIAL_5N2 0x8000030
+#define SERIAL_6N2 0x8000034
+#define SERIAL_7N2 0x8000038
+#define SERIAL_8N2 0x800003c
+#define SERIAL_5E1 0x8000012
+#define SERIAL_6E1 0x8000016
+#define SERIAL_7E1 0x800001a
+#define SERIAL_8E1 0x800001e
+#define SERIAL_5E2 0x8000032
+#define SERIAL_6E2 0x8000036
+#define SERIAL_7E2 0x800003a
+#define SERIAL_8E2 0x800003e
+#define SERIAL_5O1 0x8000013
+#define SERIAL_6O1 0x8000017
+#define SERIAL_7O1 0x800001b
+#define SERIAL_8O1 0x800001f
+#define SERIAL_5O2 0x8000033
+#define SERIAL_6O2 0x8000037
+#define SERIAL_7O2 0x800003b
+#define SERIAL_8O2 0x800003f
+
+typedef struct {
+    uart_dev_t * dev;
+    xQueueHandle queue;
+    uint32_t baud_rate;
+    uint8_t num;
+    int8_t rxPin;
+    int8_t txPin;
+    bool rxEnabled;
+    bool txEnabled;
+    bool inverted;
+} uart_t;
+
+uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t queueLen, bool inverted);
+void uartEnd(uart_t* uart);
+
+uint32_t uartAvailable(uart_t* uart);
+uint8_t uartRead(uart_t* uart);
+uint8_t uartPeek(uart_t* uart);
+void uartWrite(uart_t* uart, uint8_t c);
+void uartWriteBuf(uart_t* uart, const uint8_t * data, size_t len);
+void uartFlush(uart_t* uart);
+
+void uartSetBaudRate(uart_t* uart, uint32_t baud_rate);
+uint32_t uartGetBaudRate(uart_t* uart);
+
+void uartSetDebug(uart_t* uart);
+int uartGetDebug();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MAIN_ESP32_HAL_UART_H_ */

cores/esp32/esp32-hal.h

@@ -0,0 +1,54 @@
+/*
+ Arduino.h - Main include file for the Arduino SDK
+ Copyright (c) 2005-2013 Arduino Team.  All right reserved.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef HAL_ESP32_HAL_H_
+#define HAL_ESP32_HAL_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <inttypes.h>
+#include <string.h>
+
+#define ESP_REG(addr) *((volatile uint32_t *)(addr))
+#define NOP() asm volatile ("nop")
+
+#include "esp32-hal-log.h"
+#include "esp32-hal-matrix.h"
+#include "esp32-hal-uart.h"
+#include "esp32-hal-gpio.h"
+#include "esp32-hal-spi.h"
+#include "esp32-hal-i2c.h"
+#include "esp_system.h"
+
+uint32_t micros();
+uint32_t millis();
+void delay(uint32_t);
+void delayMicroseconds(uint32_t us);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* HAL_ESP32_HAL_H_ */

cores/esp32/libb64/AUTHORS

@@ -0,0 +1,7 @@
+libb64: Base64 Encoding/Decoding Routines
+======================================
+
+Authors:
+-------
+
+Chris Venter	chris.venter@gmail.com	http://rocketpod.blogspot.com

cores/esp32/libb64/LICENSE

@@ -0,0 +1,29 @@
+Copyright-Only Dedication (based on United States law) 
+or Public Domain Certification
+
+The person or persons who have associated work with this document (the
+"Dedicator" or "Certifier") hereby either (a) certifies that, to the best of
+his knowledge, the work of authorship identified is in the public domain of the
+country from which the work is published, or (b) hereby dedicates whatever
+copyright the dedicators holds in the work of authorship identified below (the
+"Work") to the public domain. A certifier, moreover, dedicates any copyright
+interest he may have in the associated work, and for these purposes, is
+described as a "dedicator" below.
+
+A certifier has taken reasonable steps to verify the copyright status of this
+work. Certifier recognizes that his good faith efforts may not shield him from
+liability if in fact the work certified is not in the public domain.
+
+Dedicator makes this dedication for the benefit of the public at large and to
+the detriment of the Dedicator's heirs and successors. Dedicator intends this
+dedication to be an overt act of relinquishment in perpetuity of all present
+and future rights under copyright law, whether vested or contingent, in the
+Work. Dedicator understands that such relinquishment of all rights includes
+the relinquishment of all rights to enforce (by lawsuit or otherwise) those
+copyrights in the Work.
+
+Dedicator recognizes that, once placed in the public domain, the Work may be
+freely reproduced, distributed, transmitted, used, modified, built upon, or
+otherwise exploited by anyone for any purpose, commercial or non-commercial,
+and in any way, including by methods that have not yet been invented or
+conceived.

cores/esp32/libb64/cdecode.c

@@ -0,0 +1,94 @@
+/*
+cdecoder.c - c source to a base64 decoding algorithm implementation
+
+This is part of the libb64 project, and has been placed in the public domain.
+For details, see http://sourceforge.net/projects/libb64
+*/
+
+#include "cdecode.h"
+
+int base64_decode_value(char value_in)
+{
+    static const char decoding[] = {62,-1,-1,-1,63,52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-2,-1,-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,-1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51};
+    static const char decoding_size = sizeof(decoding);
+    value_in -= 43;
+    if (value_in < 0 || value_in > decoding_size) {
+        return -1;
+    }
+    return decoding[(int)value_in];
+}
+
+void base64_init_decodestate(base64_decodestate* state_in)
+{
+    state_in->step = step_a;
+    state_in->plainchar = 0;
+}
+
+int base64_decode_block(const char* code_in, const int length_in, char* plaintext_out, base64_decodestate* state_in)
+{
+    const char* codechar = code_in;
+    char* plainchar = plaintext_out;
+    char fragment;
+
+    *plainchar = state_in->plainchar;
+
+    switch (state_in->step) {
+        while (1) {
+        case step_a:
+            do {
+                if (codechar == code_in+length_in) {
+                    state_in->step = step_a;
+                    state_in->plainchar = *plainchar;
+                    return plainchar - plaintext_out;
+                }
+                fragment = (char)base64_decode_value(*codechar++);
+            } while (fragment < 0);
+            *plainchar    = (fragment & 0x03f) << 2;
+        case step_b:
+            do {
+                if (codechar == code_in+length_in) {
+                    state_in->step = step_b;
+                    state_in->plainchar = *plainchar;
+                    return plainchar - plaintext_out;
+                }
+                fragment = (char)base64_decode_value(*codechar++);
+            } while (fragment < 0);
+            *plainchar++ |= (fragment & 0x030) >> 4;
+            *plainchar    = (fragment & 0x00f) << 4;
+        case step_c:
+            do {
+                if (codechar == code_in+length_in) {
+                    state_in->step = step_c;
+                    state_in->plainchar = *plainchar;
+                    return plainchar - plaintext_out;
+                }
+                fragment = (char)base64_decode_value(*codechar++);
+            } while (fragment < 0);
+            *plainchar++ |= (fragment & 0x03c) >> 2;
+            *plainchar    = (fragment & 0x003) << 6;
+        case step_d:
+            do {
+                if (codechar == code_in+length_in) {
+                    state_in->step = step_d;
+                    state_in->plainchar = *plainchar;
+                    return plainchar - plaintext_out;
+                }
+                fragment = (char)base64_decode_value(*codechar++);
+            } while (fragment < 0);
+            *plainchar++   |= (fragment & 0x03f);
+        }
+    }
+    /* control should not reach here */
+    return plainchar - plaintext_out;
+}
+
+int base64_decode_chars(const char* code_in, const int length_in, char* plaintext_out)
+{
+    base64_decodestate _state;
+    base64_init_decodestate(&_state);
+    int len = base64_decode_block(code_in, length_in, plaintext_out, &_state);
+    if(len > 0) {
+        plaintext_out[len] = 0;
+    }
+    return len;
+}

cores/esp32/libb64/cdecode.h

@@ -0,0 +1,38 @@
+/*
+cdecode.h - c header for a base64 decoding algorithm
+
+This is part of the libb64 project, and has been placed in the public domain.
+For details, see http://sourceforge.net/projects/libb64
+*/
+
+#ifndef BASE64_CDECODE_H
+#define BASE64_CDECODE_H
+
+#define base64_decode_expected_len(n) ((n * 3) / 4)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    step_a, step_b, step_c, step_d
+} base64_decodestep;
+
+typedef struct {
+    base64_decodestep step;
+    char plainchar;
+} base64_decodestate;
+
+void base64_init_decodestate(base64_decodestate* state_in);
+
+int base64_decode_value(char value_in);
+
+int base64_decode_block(const char* code_in, const int length_in, char* plaintext_out, base64_decodestate* state_in);
+
+int base64_decode_chars(const char* code_in, const int length_in, char* plaintext_out);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif /* BASE64_CDECODE_H */

cores/esp32/libb64/cencode.c

@@ -0,0 +1,111 @@
+/*
+cencoder.c - c source to a base64 encoding algorithm implementation
+
+This is part of the libb64 project, and has been placed in the public domain.
+For details, see http://sourceforge.net/projects/libb64
+*/
+
+#include "cencode.h"
+
+const int CHARS_PER_LINE = 72;
+
+void base64_init_encodestate(base64_encodestate* state_in)
+{
+    state_in->step = step_A;
+    state_in->result = 0;
+    state_in->stepcount = 0;
+}
+
+char base64_encode_value(char value_in)
+{
+    static const char* encoding = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    if (value_in > 63) {
+        return '=';
+    }
+    return encoding[(int)value_in];
+}
+
+int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in)
+{
+    const char* plainchar = plaintext_in;
+    const char* const plaintextend = plaintext_in + length_in;
+    char* codechar = code_out;
+    char result;
+    char fragment;
+
+    result = state_in->result;
+
+    switch (state_in->step) {
+        while (1) {
+        case step_A:
+            if (plainchar == plaintextend) {
+                state_in->result = result;
+                state_in->step = step_A;
+                return codechar - code_out;
+            }
+            fragment = *plainchar++;
+            result = (fragment & 0x0fc) >> 2;
+            *codechar++ = base64_encode_value(result);
+            result = (fragment & 0x003) << 4;
+        case step_B:
+            if (plainchar == plaintextend) {
+                state_in->result = result;
+                state_in->step = step_B;
+                return codechar - code_out;
+            }
+            fragment = *plainchar++;
+            result |= (fragment & 0x0f0) >> 4;
+            *codechar++ = base64_encode_value(result);
+            result = (fragment & 0x00f) << 2;
+        case step_C:
+            if (plainchar == plaintextend) {
+                state_in->result = result;
+                state_in->step = step_C;
+                return codechar - code_out;
+            }
+            fragment = *plainchar++;
+            result |= (fragment & 0x0c0) >> 6;
+            *codechar++ = base64_encode_value(result);
+            result  = (fragment & 0x03f) >> 0;
+            *codechar++ = base64_encode_value(result);
+
+            ++(state_in->stepcount);
+            if (state_in->stepcount == CHARS_PER_LINE/4) {
+                *codechar++ = '\n';
+                state_in->stepcount = 0;
+            }
+        }
+    }
+    /* control should not reach here */
+    return codechar - code_out;
+}
+
+int base64_encode_blockend(char* code_out, base64_encodestate* state_in)
+{
+    char* codechar = code_out;
+
+    switch (state_in->step) {
+    case step_B:
+        *codechar++ = base64_encode_value(state_in->result);
+        *codechar++ = '=';
+        *codechar++ = '=';
+        break;
+    case step_C:
+        *codechar++ = base64_encode_value(state_in->result);
+        *codechar++ = '=';
+        break;
+    case step_A:
+        break;
+    }
+    *codechar = 0x00;
+
+    return codechar - code_out;
+}
+
+int base64_encode_chars(const char* plaintext_in, int length_in, char* code_out)
+{
+    base64_encodestate _state;
+    base64_init_encodestate(&_state);
+    int len = base64_encode_block(plaintext_in, length_in, code_out, &_state);
+    return len + base64_encode_blockend((code_out + len), &_state);
+}

cores/esp32/libb64/cencode.h

@@ -0,0 +1,41 @@
+/*
+cencode.h - c header for a base64 encoding algorithm
+
+This is part of the libb64 project, and has been placed in the public domain.
+For details, see http://sourceforge.net/projects/libb64
+*/
+
+#ifndef BASE64_CENCODE_H
+#define BASE64_CENCODE_H
+
+#define base64_encode_expected_len(n) ((((4 * n) / 3) + 3) & ~3)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    step_A, step_B, step_C
+} base64_encodestep;
+
+typedef struct {
+    base64_encodestep step;
+    char result;
+    int stepcount;
+} base64_encodestate;
+
+void base64_init_encodestate(base64_encodestate* state_in);
+
+char base64_encode_value(char value_in);
+
+int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in);
+
+int base64_encode_blockend(char* code_out, base64_encodestate* state_in);
+
+int base64_encode_chars(const char* plaintext_in, int length_in, char* code_out);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif /* BASE64_CENCODE_H */

cores/esp32/main.cpp

@@ -0,0 +1,35 @@
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+
+void initVariant() __attribute__((weak));
+void initVariant() {}
+
+void init() __attribute__((weak));
+void init() {}
+
+void bootWiFi() __attribute__((weak));
+void bootWiFi() {}
+
+extern void loop();
+extern void setup();
+
+void loopTask(void *pvParameters)
+{
+    bool setup_done = false;
+    for(;;) {
+        if(!setup_done) {
+            bootWiFi();
+            setup();
+            setup_done = true;
+        }
+        loop();
+    }
+}
+
+extern "C" void app_main()
+{
+    init();
+    initVariant();
+    xTaskCreatePinnedToCore(loopTask, "loopTask", 4096, NULL, 1, NULL, 0);
+}
+

cores/esp32/pgmspace.h

@@ -0,0 +1,42 @@
+/* 
+  Copyright (c) 2015 Hristo Gochkov. All rights reserved.
+  This file is part of the RaspberryPi core for Arduino environment.
+ 
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library 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
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+#ifndef PGMSPACE_INCLUDE
+#define PGMSPACE_INCLUDE
+
+typedef char __FlashStringHelper;
+#define PROGMEM
+#define PSTR(s) (s)
+#define F(string_literal) (reinterpret_cast<const __FlashStringHelper *>(PSTR(string_literal)))
+
+#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
+#define pgm_read_word(addr) (*(const unsigned short *)(addr))
+#define pgm_read_dword(addr) (*(const unsigned long *)(addr))
+#define pgm_read_float(addr) (*(const float *)(addr))
+
+#define pgm_read_byte_near(addr) pgm_read_byte(addr)
+#define pgm_read_word_near(addr) pgm_read_word(addr)
+#define pgm_read_dword_near(addr) pgm_read_dword(addr)
+#define pgm_read_float_near(addr) pgm_read_float(addr)
+#define pgm_read_byte_far(addr) pgm_read_byte(addr)
+#define pgm_read_word_far(addr) pgm_read_word(addr)
+#define pgm_read_dword_far(addr) pgm_read_dword(addr)
+#define pgm_read_float_far(addr) pgm_read_float(addr)
+
+#define memcpy_P(to,from,len) memcpy(to,from,len)
+#endif

cores/esp32/stdlib_noniso.h

@@ -0,0 +1,49 @@
+/*
+  stdlib_noniso.h - nonstandard (but usefull) conversion functions
+
+  Copyright (c) 2014 Ivan Grokhotkov. All rights reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library 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
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef STDLIB_NONISO_H
+#define STDLIB_NONISO_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int atoi(const char *s);
+
+long atol(const char* s);
+
+double atof(const char* s);
+
+char* itoa (int val, char *s, int radix);
+
+char* ltoa (long val, char *s, int radix);
+
+char* utoa (unsigned int val, char *s, int radix);
+
+char* ultoa (unsigned long val, char *s, int radix);
+
+char* dtostrf (double val, signed char width, unsigned char prec, char *s);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+
+#endif

cores/esp32/wiring_private.h

@@ -0,0 +1,45 @@
+/*
+ wiring_private.h - Internal header file.
+ Part of Arduino - http://www.arduino.cc/
+
+ Copyright (c) 2005-2006 David A. Mellis
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General
+ Public License along with this library; if not, write to the
+ Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ Boston, MA  02111-1307  USA
+
+ $Id: wiring.h 239 2007-01-12 17:58:39Z mellis $
+ */
+
+#ifndef WiringPrivate_h
+#define WiringPrivate_h
+
+#include <stdio.h>
+#include <stdarg.h>
+
+#include "arducore.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void (*voidFuncPtr)(void);
+
+void initPins();
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif