initial import

Author: me-no-dev

.gitignore

@@ -0,0 +1,2 @@
+
+tools/xtensa-esp32-elf

boards.txt

@@ -0,0 +1,42 @@
+menu.UploadSpeed=Upload Speed
+menu.FlashFreq=Flash Frequency
+
+##############################################################
+esp32.name=ESP32 Dev Module
+
+esp32.upload.tool=esptool
+esp32.upload.maximum_size=1044464
+esp32.upload.maximum_data_size=114688
+esp32.upload.wait_for_upload_port=true
+
+esp32.serial.disableDTR=true
+esp32.serial.disableRTS=true
+
+esp32.build.mcu=esp32
+esp32.build.core=esp32
+esp32.build.variant=esp32
+esp32.build.board=ESP32_DEV
+
+esp32.build.f_cpu=160000000L
+esp32.build.flash_mode=dio
+esp32.build.flash_size=4MB
+
+esp32.menu.FlashFreq.80=80MHz
+esp32.menu.FlashFreq.80.build.flash_freq=80m
+esp32.menu.FlashFreq.40=40MHz
+esp32.menu.FlashFreq.40.build.flash_freq=40m
+
+esp32.menu.UploadSpeed.921600=921600
+esp32.menu.UploadSpeed.921600.upload.speed=921600
+esp32.menu.UploadSpeed.115200=115200
+esp32.menu.UploadSpeed.115200.upload.speed=115200
+esp32.menu.UploadSpeed.256000.windows=256000
+esp32.menu.UploadSpeed.256000.upload.speed=256000
+esp32.menu.UploadSpeed.230400.windows.upload.speed=256000
+esp32.menu.UploadSpeed.230400=230400
+esp32.menu.UploadSpeed.230400.upload.speed=230400
+esp32.menu.UploadSpeed.460800.linux=460800
+esp32.menu.UploadSpeed.460800.macosx=460800
+esp32.menu.UploadSpeed.460800.upload.speed=460800
+esp32.menu.UploadSpeed.512000.windows=512000
+esp32.menu.UploadSpeed.512000.upload.speed=512000

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;
+}