From a12c6fcea253a987e2b83aca2d9f717d0d201472 Mon Sep 17 00:00:00 2001 From: Ivan Grokhotkov Date: Sat, 15 Nov 2014 10:45:08 +0300 Subject: [PATCH] Basic support for esp8266 platform This includes empty stubs for most core Arduino functions. Need to actually implement all those digital reads writes whatever. Need to prebuild toolchains (xtensa-elf-lx106) for 3 platforms and put them on some download server. Need to do the same with esptool. Need to fix 0x40000 binary generation and add correct upload commands. Maybe even implement uploads over WiFi. --- build/build.xml | 10 + hardware/arduino/esp8266/boards.txt | 12 + .../arduino/esp8266/cores/esp8266/Arduino.h | 240 ++++++ .../arduino/esp8266/cores/esp8266/Client.h | 45 ++ .../esp8266/cores/esp8266/HardwareSerial.h | 151 ++++ .../cores/esp8266/HardwareSerial_private.h | 123 +++ .../esp8266/cores/esp8266/IPAddress.cpp | 75 ++ .../arduino/esp8266/cores/esp8266/IPAddress.h | 75 ++ .../arduino/esp8266/cores/esp8266/Print.cpp | 248 ++++++ .../arduino/esp8266/cores/esp8266/Print.h | 82 ++ .../arduino/esp8266/cores/esp8266/Printable.h | 40 + .../arduino/esp8266/cores/esp8266/Server.h | 30 + .../arduino/esp8266/cores/esp8266/Stream.cpp | 270 +++++++ .../arduino/esp8266/cores/esp8266/Stream.h | 102 +++ .../arduino/esp8266/cores/esp8266/Tone.cpp | 49 ++ hardware/arduino/esp8266/cores/esp8266/Udp.h | 88 +++ .../esp8266/cores/esp8266/WCharacter.h | 168 +++++ .../esp8266/cores/esp8266/WInterrupts.c | 38 + .../arduino/esp8266/cores/esp8266/WMath.cpp | 60 ++ .../arduino/esp8266/cores/esp8266/WString.cpp | 704 ++++++++++++++++++ .../arduino/esp8266/cores/esp8266/WString.h | 209 ++++++ .../arduino/esp8266/cores/esp8266/abi.cpp | 35 + .../arduino/esp8266/cores/esp8266/binary.h | 534 +++++++++++++ .../arduino/esp8266/cores/esp8266/hooks.c | 31 + .../arduino/esp8266/cores/esp8266/main.cpp | 68 ++ .../arduino/esp8266/cores/esp8266/new.cpp | 36 + hardware/arduino/esp8266/cores/esp8266/new.h | 30 + .../esp8266/cores/esp8266/stdlib_noniso.c | 38 + .../esp8266/cores/esp8266/stdlib_noniso.h | 26 + .../esp8266/cores/esp8266/user_config.h | 1 + .../arduino/esp8266/cores/esp8266/wiring.c | 68 ++ .../esp8266/cores/esp8266/wiring_analog.c | 55 ++ .../esp8266/cores/esp8266/wiring_digital.c | 45 ++ .../esp8266/cores/esp8266/wiring_private.h | 61 ++ .../esp8266/cores/esp8266/wiring_pulse.c | 35 + .../esp8266/cores/esp8266/wiring_shift.c | 55 ++ hardware/arduino/esp8266/platform.txt | 107 +++ hardware/arduino/esp8266/programmers.txt | 6 + .../esp8266/variants/esp01/pins_arduino.h | 86 +++ hardware/tools/esp8266/esptool.py | 383 ++++++++++ hardware/tools/esp8266/sdk/include/c_types.h | 92 +++ .../tools/esp8266/sdk/include/eagle_soc.h | 255 +++++++ hardware/tools/esp8266/sdk/include/espconn.h | 321 ++++++++ hardware/tools/esp8266/sdk/include/ets_sys.h | 83 +++ hardware/tools/esp8266/sdk/include/gpio.h | 100 +++ hardware/tools/esp8266/sdk/include/ip_addr.h | 64 ++ hardware/tools/esp8266/sdk/include/mem.h | 12 + hardware/tools/esp8266/sdk/include/os_type.h | 19 + hardware/tools/esp8266/sdk/include/osapi.h | 48 ++ hardware/tools/esp8266/sdk/include/queue.h | 204 +++++ .../tools/esp8266/sdk/include/spi_flash.h | 30 + .../tools/esp8266/sdk/include/uart_register.h | 128 ++++ .../esp8266/sdk/include/user_interface.h | 201 +++++ hardware/tools/esp8266/sdk/include/version.h | 12 + hardware/tools/esp8266/sdk/ld/eagle.app.v6.ld | 181 +++++ .../tools/esp8266/sdk/ld/eagle.rom.addr.v6.ld | 343 +++++++++ hardware/tools/esp8266/sdk/lib/libhal.a | Bin 0 -> 349408 bytes hardware/tools/esp8266/sdk/lib/liblwip.a | Bin 0 -> 230324 bytes hardware/tools/esp8266/sdk/lib/libmain.a | Bin 0 -> 69124 bytes hardware/tools/esp8266/sdk/lib/libnet80211.a | Bin 0 -> 178578 bytes hardware/tools/esp8266/sdk/lib/libphy.a | Bin 0 -> 290658 bytes hardware/tools/esp8266/sdk/lib/libssl.a | Bin 0 -> 159214 bytes hardware/tools/esp8266/sdk/lib/libwpa.a | Bin 0 -> 124308 bytes hardware/tools/esp8266/sdk/version | 1 + 64 files changed, 6613 insertions(+) create mode 100644 hardware/arduino/esp8266/boards.txt create mode 100644 hardware/arduino/esp8266/cores/esp8266/Arduino.h create mode 100644 hardware/arduino/esp8266/cores/esp8266/Client.h create mode 100644 hardware/arduino/esp8266/cores/esp8266/HardwareSerial.h create mode 100644 hardware/arduino/esp8266/cores/esp8266/HardwareSerial_private.h create mode 100644 hardware/arduino/esp8266/cores/esp8266/IPAddress.cpp create mode 100644 hardware/arduino/esp8266/cores/esp8266/IPAddress.h create mode 100644 hardware/arduino/esp8266/cores/esp8266/Print.cpp create mode 100644 hardware/arduino/esp8266/cores/esp8266/Print.h create mode 100644 hardware/arduino/esp8266/cores/esp8266/Printable.h create mode 100644 hardware/arduino/esp8266/cores/esp8266/Server.h create mode 100644 hardware/arduino/esp8266/cores/esp8266/Stream.cpp create mode 100644 hardware/arduino/esp8266/cores/esp8266/Stream.h create mode 100644 hardware/arduino/esp8266/cores/esp8266/Tone.cpp create mode 100644 hardware/arduino/esp8266/cores/esp8266/Udp.h create mode 100644 hardware/arduino/esp8266/cores/esp8266/WCharacter.h create mode 100644 hardware/arduino/esp8266/cores/esp8266/WInterrupts.c create mode 100644 hardware/arduino/esp8266/cores/esp8266/WMath.cpp create mode 100644 hardware/arduino/esp8266/cores/esp8266/WString.cpp create mode 100644 hardware/arduino/esp8266/cores/esp8266/WString.h create mode 100644 hardware/arduino/esp8266/cores/esp8266/abi.cpp create mode 100644 hardware/arduino/esp8266/cores/esp8266/binary.h create mode 100644 hardware/arduino/esp8266/cores/esp8266/hooks.c create mode 100644 hardware/arduino/esp8266/cores/esp8266/main.cpp create mode 100644 hardware/arduino/esp8266/cores/esp8266/new.cpp create mode 100644 hardware/arduino/esp8266/cores/esp8266/new.h create mode 100644 hardware/arduino/esp8266/cores/esp8266/stdlib_noniso.c create mode 100644 hardware/arduino/esp8266/cores/esp8266/stdlib_noniso.h create mode 100755 hardware/arduino/esp8266/cores/esp8266/user_config.h create mode 100644 hardware/arduino/esp8266/cores/esp8266/wiring.c create mode 100644 hardware/arduino/esp8266/cores/esp8266/wiring_analog.c create mode 100644 hardware/arduino/esp8266/cores/esp8266/wiring_digital.c create mode 100644 hardware/arduino/esp8266/cores/esp8266/wiring_private.h create mode 100644 hardware/arduino/esp8266/cores/esp8266/wiring_pulse.c create mode 100644 hardware/arduino/esp8266/cores/esp8266/wiring_shift.c create mode 100644 hardware/arduino/esp8266/platform.txt create mode 100644 hardware/arduino/esp8266/programmers.txt create mode 100644 hardware/arduino/esp8266/variants/esp01/pins_arduino.h create mode 100755 hardware/tools/esp8266/esptool.py create mode 100755 hardware/tools/esp8266/sdk/include/c_types.h create mode 100755 hardware/tools/esp8266/sdk/include/eagle_soc.h create mode 100755 hardware/tools/esp8266/sdk/include/espconn.h create mode 100755 hardware/tools/esp8266/sdk/include/ets_sys.h create mode 100755 hardware/tools/esp8266/sdk/include/gpio.h create mode 100755 hardware/tools/esp8266/sdk/include/ip_addr.h create mode 100755 hardware/tools/esp8266/sdk/include/mem.h create mode 100755 hardware/tools/esp8266/sdk/include/os_type.h create mode 100755 hardware/tools/esp8266/sdk/include/osapi.h create mode 100755 hardware/tools/esp8266/sdk/include/queue.h create mode 100755 hardware/tools/esp8266/sdk/include/spi_flash.h create mode 100755 hardware/tools/esp8266/sdk/include/uart_register.h create mode 100755 hardware/tools/esp8266/sdk/include/user_interface.h create mode 100755 hardware/tools/esp8266/sdk/include/version.h create mode 100755 hardware/tools/esp8266/sdk/ld/eagle.app.v6.ld create mode 100755 hardware/tools/esp8266/sdk/ld/eagle.rom.addr.v6.ld create mode 100644 hardware/tools/esp8266/sdk/lib/libhal.a create mode 100755 hardware/tools/esp8266/sdk/lib/liblwip.a create mode 100755 hardware/tools/esp8266/sdk/lib/libmain.a create mode 100755 hardware/tools/esp8266/sdk/lib/libnet80211.a create mode 100755 hardware/tools/esp8266/sdk/lib/libphy.a create mode 100755 hardware/tools/esp8266/sdk/lib/libssl.a create mode 100755 hardware/tools/esp8266/sdk/lib/libwpa.a create mode 100644 hardware/tools/esp8266/sdk/version diff --git a/build/build.xml b/build/build.xml index 4427239bb..7a7fa1d32 100644 --- a/build/build.xml +++ b/build/build.xml @@ -127,6 +127,8 @@ + + @@ -274,6 +276,14 @@ + + + + + + + + diff --git a/hardware/arduino/esp8266/boards.txt b/hardware/arduino/esp8266/boards.txt new file mode 100644 index 000000000..3faf8b2ba --- /dev/null +++ b/hardware/arduino/esp8266/boards.txt @@ -0,0 +1,12 @@ +############################################################## +esp01.name=ESP-01 + +esp01.upload.tool=esptool +esp01.upload.speed=57600 +esp01.upload.wait_for_upload_port=true + +esp01.build.mcu=esp8266 +esp01.build.f_cpu=80000000L +esp01.build.board=ESP8266_ESP01 +esp01.build.core=esp8266 +esp01.build.variant=esp01 diff --git a/hardware/arduino/esp8266/cores/esp8266/Arduino.h b/hardware/arduino/esp8266/cores/esp8266/Arduino.h new file mode 100644 index 000000000..92bdc63a6 --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/Arduino.h @@ -0,0 +1,240 @@ +/* + 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 + +#include +#include +#include +#include +#include + +#include "binary.h" + +#ifdef __cplusplus +extern "C"{ +#endif + +void yield(void); + +#define HIGH 0x1 +#define LOW 0x0 + +#define INPUT 0x0 +#define OUTPUT 0x1 +#define INPUT_PULLUP 0x2 + +#define PI 3.1415926535897932384626433832795 +#define HALF_PI 1.5707963267948966192313216916398 +#define TWO_PI 6.283185307179586476925286766559 +#define DEG_TO_RAD 0.017453292519943295769236907684886 +#define RAD_TO_DEG 57.295779513082320876798154814105 +#define EULER 2.718281828459045235360287471352 + +#define SERIAL 0x0 +#define DISPLAY 0x1 + +#define LSBFIRST 0 +#define MSBFIRST 1 + +#define CHANGE 1 +#define FALLING 2 +#define RISING 3 + +#define DEFAULT 1 +#define EXTERNAL 0 + +// undefine stdlib's abs if encountered +#ifdef abs +#undef abs +#endif + +#define min(a,b) ((a)<(b)?(a):(b)) +#define max(a,b) ((a)>(b)?(a):(b)) +#define abs(x) ((x)>0?(x):-(x)) +#define constrain(amt,low,high) ((amt)<(low)?(low):((amt)>(high)?(high):(amt))) +#define round(x) ((x)>=0?(long)((x)+0.5):(long)((x)-0.5)) +#define radians(deg) ((deg)*DEG_TO_RAD) +#define degrees(rad) ((rad)*RAD_TO_DEG) +#define sq(x) ((x)*(x)) + +#define interrupts() sei() +#define noInterrupts() cli() + +#define clockCyclesPerMicrosecond() ( F_CPU / 1000000L ) +#define clockCyclesToMicroseconds(a) ( (a) / clockCyclesPerMicrosecond() ) +#define microsecondsToClockCycles(a) ( (a) * clockCyclesPerMicrosecond() ) + +#define lowByte(w) ((uint8_t) ((w) & 0xff)) +#define highByte(w) ((uint8_t) ((w) >> 8)) + +#define bitRead(value, bit) (((value) >> (bit)) & 0x01) +#define bitSet(value, bit) ((value) |= (1UL << (bit))) +#define bitClear(value, bit) ((value) &= ~(1UL << (bit))) +#define bitWrite(value, bit, bitvalue) (bitvalue ? bitSet(value, bit) : bitClear(value, bit)) + +// avr-libc defines _NOP() since 1.6.2 +#ifndef _NOP +#define _NOP() do { __asm__ volatile ("nop"); } while (0) +#endif + +typedef unsigned int word; + +#define bit(b) (1UL << (b)) + +typedef uint8_t boolean; +typedef uint8_t byte; + +void init(void); +void initVariant(void); + +int atexit(void (*func)()) __attribute__((weak)); + +void pinMode(uint8_t, uint8_t); +void digitalWrite(uint8_t, uint8_t); +int digitalRead(uint8_t); +int analogRead(uint8_t); +void analogReference(uint8_t mode); +void analogWrite(uint8_t, int); + +unsigned long millis(void); +unsigned long micros(void); +void delay(unsigned long); +void delayMicroseconds(unsigned int us); +unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout); + +void shiftOut(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t val); +uint8_t shiftIn(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder); + +void attachInterrupt(uint8_t, void (*)(void), int mode); +void detachInterrupt(uint8_t); + +void setup(void); +void loop(void); + +// Get the bit location within the hardware port of the given virtual pin. +// This comes from the pins_*.c file for the active board configuration. + +#define analogInPinToBit(P) (P) + +// On the ATmega1280, the addresses of some of the port registers are +// greater than 255, so we can't store them in uint8_t's. +#define PROGMEM + +extern const uint16_t PROGMEM port_to_mode_PGM[]; +extern const uint16_t PROGMEM port_to_input_PGM[]; +extern const uint16_t PROGMEM port_to_output_PGM[]; + +extern const uint8_t PROGMEM digital_pin_to_port_PGM[]; +// extern const uint8_t PROGMEM digital_pin_to_bit_PGM[]; +extern const uint8_t PROGMEM digital_pin_to_bit_mask_PGM[]; +extern const uint8_t PROGMEM digital_pin_to_timer_PGM[]; + +// Get the bit location within the hardware port of the given virtual pin. +// This comes from the pins_*.c file for the active board configuration. +// +// These perform slightly better as macros compared to inline functions +// +#define digitalPinToPort(P) ( pgm_read_byte( digital_pin_to_port_PGM + (P) ) ) +#define digitalPinToBitMask(P) ( pgm_read_byte( digital_pin_to_bit_mask_PGM + (P) ) ) +#define digitalPinToTimer(P) ( pgm_read_byte( digital_pin_to_timer_PGM + (P) ) ) +#define analogInPinToBit(P) (P) +#define portOutputRegister(P) ( (volatile uint8_t *)( pgm_read_word( port_to_output_PGM + (P))) ) +#define portInputRegister(P) ( (volatile uint8_t *)( pgm_read_word( port_to_input_PGM + (P))) ) +#define portModeRegister(P) ( (volatile uint8_t *)( pgm_read_word( port_to_mode_PGM + (P))) ) + +#define NOT_A_PIN 0 +#define NOT_A_PORT 0 + +#define NOT_AN_INTERRUPT -1 + +#ifdef ARDUINO_MAIN +#define PA 1 +#define PB 2 +#define PC 3 +#define PD 4 +#define PE 5 +#define PF 6 +#define PG 7 +#define PH 8 +#define PJ 10 +#define PK 11 +#define PL 12 +#endif + +#define NOT_ON_TIMER 0 +#define TIMER0A 1 +#define TIMER0B 2 +#define TIMER1A 3 +#define TIMER1B 4 +#define TIMER1C 5 +#define TIMER2 6 +#define TIMER2A 7 +#define TIMER2B 8 + +#define TIMER3A 9 +#define TIMER3B 10 +#define TIMER3C 11 +#define TIMER4A 12 +#define TIMER4B 13 +#define TIMER4C 14 +#define TIMER4D 15 +#define TIMER5A 16 +#define TIMER5B 17 +#define TIMER5C 18 + +#ifdef __cplusplus +} // extern "C" +#endif + +#ifdef __cplusplus + +#include "WCharacter.h" +#include "WString.h" +/* +#include "HardwareSerial.h" + +#include "USBAPI.h" +#if defined(HAVE_HWSERIAL0) && defined(HAVE_CDCSERIAL) +#error "Targets with both UART0 and CDC serial not supported" +#endif +*/ + +uint16_t makeWord(uint16_t w); +uint16_t makeWord(byte h, byte l); + +#define word(...) makeWord(__VA_ARGS__) + +unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout = 1000000L); + +void tone(uint8_t _pin, unsigned int frequency, unsigned long duration = 0); +void noTone(uint8_t _pin); + +// WMath prototypes +long random(long); +long random(long, long); +void randomSeed(unsigned int); +long map(long, long, long, long, long); + +#endif + +#include "pins_arduino.h" + +#endif diff --git a/hardware/arduino/esp8266/cores/esp8266/Client.h b/hardware/arduino/esp8266/cores/esp8266/Client.h new file mode 100644 index 000000000..b8e5d935f --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/Client.h @@ -0,0 +1,45 @@ +/* + 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 diff --git a/hardware/arduino/esp8266/cores/esp8266/HardwareSerial.h b/hardware/arduino/esp8266/cores/esp8266/HardwareSerial.h new file mode 100644 index 000000000..7dc2aa98c --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/HardwareSerial.h @@ -0,0 +1,151 @@ +/* + 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 +*/ + +#ifndef HardwareSerial_h +#define HardwareSerial_h + +#include + +#include "Stream.h" + +// Define constants and variables for buffering incoming serial data. We're +// using a ring buffer (I think), in which head is the index of the location +// to which to write the next incoming character and tail is the index of the +// location from which to read. +// NOTE: a "power of 2" buffer size is reccomended to dramatically +// optimize all the modulo operations for ring buffers. +#if !(defined(SERIAL_TX_BUFFER_SIZE) && defined(SERIAL_RX_BUFFER_SIZE)) +#if (RAMEND < 1000) +#define SERIAL_TX_BUFFER_SIZE 16 +#define SERIAL_RX_BUFFER_SIZE 16 +#else +#define SERIAL_TX_BUFFER_SIZE 64 +#define SERIAL_RX_BUFFER_SIZE 64 +#endif +#endif +#if (SERIAL_TX_BUFFER_SIZE>256) +typedef uint16_t tx_buffer_index_t; +#else +typedef uint8_t tx_buffer_index_t; +#endif +#if (SERIAL_RX_BUFFER_SIZE>256) +typedef uint16_t rx_buffer_index_t; +#else +typedef uint8_t rx_buffer_index_t; +#endif + +// Define config for Serial.begin(baud, config); +#define SERIAL_5N1 0x00 +#define SERIAL_6N1 0x02 +#define SERIAL_7N1 0x04 +#define SERIAL_8N1 0x06 +#define SERIAL_5N2 0x08 +#define SERIAL_6N2 0x0A +#define SERIAL_7N2 0x0C +#define SERIAL_8N2 0x0E +#define SERIAL_5E1 0x20 +#define SERIAL_6E1 0x22 +#define SERIAL_7E1 0x24 +#define SERIAL_8E1 0x26 +#define SERIAL_5E2 0x28 +#define SERIAL_6E2 0x2A +#define SERIAL_7E2 0x2C +#define SERIAL_8E2 0x2E +#define SERIAL_5O1 0x30 +#define SERIAL_6O1 0x32 +#define SERIAL_7O1 0x34 +#define SERIAL_8O1 0x36 +#define SERIAL_5O2 0x38 +#define SERIAL_6O2 0x3A +#define SERIAL_7O2 0x3C +#define SERIAL_8O2 0x3E + +class HardwareSerial : public Stream +{ + protected: + volatile uint8_t * const _ubrrh; + volatile uint8_t * const _ubrrl; + volatile uint8_t * const _ucsra; + volatile uint8_t * const _ucsrb; + volatile uint8_t * const _ucsrc; + volatile uint8_t * const _udr; + // Has any byte been written to the UART since begin() + bool _written; + + volatile rx_buffer_index_t _rx_buffer_head; + volatile rx_buffer_index_t _rx_buffer_tail; + volatile tx_buffer_index_t _tx_buffer_head; + volatile tx_buffer_index_t _tx_buffer_tail; + + // Don't put any members after these buffers, since only the first + // 32 bytes of this struct can be accessed quickly using the ldd + // instruction. + unsigned char _rx_buffer[SERIAL_RX_BUFFER_SIZE]; + unsigned char _tx_buffer[SERIAL_TX_BUFFER_SIZE]; + + public: + inline HardwareSerial( + volatile uint8_t *ubrrh, volatile uint8_t *ubrrl, + volatile uint8_t *ucsra, volatile uint8_t *ucsrb, + volatile uint8_t *ucsrc, volatile uint8_t *udr); + void begin(unsigned long baud) { begin(baud, SERIAL_8N1); } + void begin(unsigned long, uint8_t); + void end(); + virtual int available(void); + virtual int peek(void); + virtual int read(void); + int availableForWrite(void); + virtual void flush(void); + virtual size_t write(uint8_t); + 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); } + using Print::write; // pull in write(str) and write(buf, size) from Print + operator bool() { return true; } + + // Interrupt handlers - Not intended to be called externally + inline void _rx_complete_irq(void); + void _tx_udr_empty_irq(void); +}; + +#if defined(UBRRH) || defined(UBRR0H) + extern HardwareSerial Serial; + #define HAVE_HWSERIAL0 +#endif +#if defined(UBRR1H) + extern HardwareSerial Serial1; + #define HAVE_HWSERIAL1 +#endif +#if defined(UBRR2H) + extern HardwareSerial Serial2; + #define HAVE_HWSERIAL2 +#endif +#if defined(UBRR3H) + extern HardwareSerial Serial3; + #define HAVE_HWSERIAL3 +#endif + +extern void serialEventRun(void) __attribute__((weak)); + +#endif diff --git a/hardware/arduino/esp8266/cores/esp8266/HardwareSerial_private.h b/hardware/arduino/esp8266/cores/esp8266/HardwareSerial_private.h new file mode 100644 index 000000000..761a5e559 --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/HardwareSerial_private.h @@ -0,0 +1,123 @@ +/* + HardwareSerial_private.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 23 November 2006 by David A. Mellis + Modified 28 September 2010 by Mark Sproul + Modified 14 August 2012 by Alarus +*/ + +#include "wiring_private.h" + +// this next line disables the entire HardwareSerial.cpp, +// this is so I can support Attiny series and any other chip without a uart +#if defined(HAVE_HWSERIAL0) || defined(HAVE_HWSERIAL1) || defined(HAVE_HWSERIAL2) || defined(HAVE_HWSERIAL3) + +// Ensure that the various bit positions we use are available with a 0 +// postfix, so we can always use the values for UART0 for all UARTs. The +// alternative, passing the various values for each UART to the +// HardwareSerial constructor also works, but makes the code bigger and +// slower. +#if !defined(TXC0) +#if defined(TXC) +// Some chips like ATmega8 don't have UPE, only PE. The other bits are +// named as expected. +#if !defined(UPE) && defined(PE) +#define UPE PE +#endif +// On ATmega8, the uart and its bits are not numbered, so there is no TXC0 etc. +#define TXC0 TXC +#define RXEN0 RXEN +#define TXEN0 TXEN +#define RXCIE0 RXCIE +#define UDRIE0 UDRIE +#define U2X0 U2X +#define UPE0 UPE +#define UDRE0 UDRE +#elif defined(TXC1) +// Some devices have uart1 but no uart0 +#define TXC0 TXC1 +#define RXEN0 RXEN1 +#define TXEN0 TXEN1 +#define RXCIE0 RXCIE1 +#define UDRIE0 UDRIE1 +#define U2X0 U2X1 +#define UPE0 UPE1 +#define UDRE0 UDRE1 +#else +#error No UART found in HardwareSerial.cpp +#endif +#endif // !defined TXC0 + +// Check at compiletime that it is really ok to use the bit positions of +// UART0 for the other UARTs as well, in case these values ever get +// changed for future hardware. +#if defined(TXC1) && (TXC1 != TXC0 || RXEN1 != RXEN0 || RXCIE1 != RXCIE0 || \ + UDRIE1 != UDRIE0 || U2X1 != U2X0 || UPE1 != UPE0 || \ + UDRE1 != UDRE0) +#error "Not all bit positions for UART1 are the same as for UART0" +#endif +#if defined(TXC2) && (TXC2 != TXC0 || RXEN2 != RXEN0 || RXCIE2 != RXCIE0 || \ + UDRIE2 != UDRIE0 || U2X2 != U2X0 || UPE2 != UPE0 || \ + UDRE2 != UDRE0) +#error "Not all bit positions for UART2 are the same as for UART0" +#endif +#if defined(TXC3) && (TXC3 != TXC0 || RXEN3 != RXEN0 || RXCIE3 != RXCIE0 || \ + UDRIE3 != UDRIE0 || U3X3 != U3X0 || UPE3 != UPE0 || \ + UDRE3 != UDRE0) +#error "Not all bit positions for UART3 are the same as for UART0" +#endif + +// Constructors //////////////////////////////////////////////////////////////// + +HardwareSerial::HardwareSerial( + volatile uint8_t *ubrrh, volatile uint8_t *ubrrl, + volatile uint8_t *ucsra, volatile uint8_t *ucsrb, + volatile uint8_t *ucsrc, volatile uint8_t *udr) : + _ubrrh(ubrrh), _ubrrl(ubrrl), + _ucsra(ucsra), _ucsrb(ucsrb), _ucsrc(ucsrc), + _udr(udr), + _rx_buffer_head(0), _rx_buffer_tail(0), + _tx_buffer_head(0), _tx_buffer_tail(0) +{ +} + +// Actual interrupt handlers ////////////////////////////////////////////////////////////// + +void HardwareSerial::_rx_complete_irq(void) +{ + if (bit_is_clear(*_ucsra, UPE0)) { + // No Parity error, read byte and store it in the buffer if there is + // room + unsigned char c = *_udr; + rx_buffer_index_t i = (unsigned int)(_rx_buffer_head + 1) % SERIAL_RX_BUFFER_SIZE; + + // if we should be storing the received character into the location + // just before the tail (meaning that the head would advance to the + // current location of the tail), we're about to overflow the buffer + // and so we don't write the character or advance the head. + if (i != _rx_buffer_tail) { + _rx_buffer[_rx_buffer_head] = c; + _rx_buffer_head = i; + } + } else { + // Parity error, read byte but discard it + *_udr; + }; +} + +#endif // whole file diff --git a/hardware/arduino/esp8266/cores/esp8266/IPAddress.cpp b/hardware/arduino/esp8266/cores/esp8266/IPAddress.cpp new file mode 100644 index 000000000..ab62dad6c --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/IPAddress.cpp @@ -0,0 +1,75 @@ +/* + 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 +#include +#include + +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; +} + diff --git a/hardware/arduino/esp8266/cores/esp8266/IPAddress.h b/hardware/arduino/esp8266/cores/esp8266/IPAddress.h new file mode 100644 index 000000000..94acdc456 --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/IPAddress.h @@ -0,0 +1,75 @@ +/* + 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 +#include + +// 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); + + // 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; + + 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 diff --git a/hardware/arduino/esp8266/cores/esp8266/Print.cpp b/hardware/arduino/esp8266/cores/esp8266/Print.cpp new file mode 100644 index 000000000..2916c25f7 --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/Print.cpp @@ -0,0 +1,248 @@ +/* + 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 + */ + +#include +#include +#include +#include +#include "Arduino.h" + +#include "Print.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::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::print(const Printable& x) +{ + return x.printTo(*this); +} + +size_t Print::println(void) +{ + size_t n = print('\r'); + n += print('\n'); + return 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 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; +} diff --git a/hardware/arduino/esp8266/cores/esp8266/Print.h b/hardware/arduino/esp8266/cores/esp8266/Print.h new file mode 100644 index 000000000..23db89cba --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/Print.h @@ -0,0 +1,82 @@ +/* + 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 +#include // for size_t + +#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) {} + + 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 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 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 diff --git a/hardware/arduino/esp8266/cores/esp8266/Printable.h b/hardware/arduino/esp8266/cores/esp8266/Printable.h new file mode 100644 index 000000000..2a1b2e9f2 --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/Printable.h @@ -0,0 +1,40 @@ +/* + 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 + +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 size_t printTo(Print& p) const = 0; +}; + +#endif + diff --git a/hardware/arduino/esp8266/cores/esp8266/Server.h b/hardware/arduino/esp8266/cores/esp8266/Server.h new file mode 100644 index 000000000..69e3e39fe --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/Server.h @@ -0,0 +1,30 @@ +/* + 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 diff --git a/hardware/arduino/esp8266/cores/esp8266/Stream.cpp b/hardware/arduino/esp8266/cores/esp8266/Stream.cpp new file mode 100644 index 000000000..9c581bee1 --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/Stream.cpp @@ -0,0 +1,270 @@ +/* + 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 "Arduino.h" +#include "Stream.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(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(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(char *target, 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(char *target, size_t targetLen, 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; +} + diff --git a/hardware/arduino/esp8266/cores/esp8266/Stream.h b/hardware/arduino/esp8266/cores/esp8266/Stream.h new file mode 100644 index 000000000..5cf5ddf01 --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/Stream.h @@ -0,0 +1,102 @@ +/* + 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 +#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() {_timeout=1000;} + +// parsing methods + + void setTimeout(unsigned long timeout); // sets maximum milliseconds to wait for stream data, default is 1 second + + bool find(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(char *target, size_t length); // reads data from the stream until the target string of given length is found + bool find(uint8_t *target, size_t length) { return find ((char *)target, length); } + // returns true if target string is found, false if timed out + + bool findUntil(char *target, char *terminator); // as find but search ends if the terminator string is found + bool findUntil(uint8_t *target, char *terminator) { return findUntil((char *)target, terminator); } + + bool findUntil(char *target, size_t targetLen, char *terminate, size_t termLen); // as above but search ends if the terminate string is found + bool findUntil(uint8_t *target, size_t targetLen, 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 diff --git a/hardware/arduino/esp8266/cores/esp8266/Tone.cpp b/hardware/arduino/esp8266/cores/esp8266/Tone.cpp new file mode 100644 index 000000000..25e4a103a --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/Tone.cpp @@ -0,0 +1,49 @@ +/* Tone.cpp + + A Tone Generator Library + + Written by Brett Hagman + + 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 + +Version Modified By Date Comments +------- ----------- -------- -------- +0001 B Hagman 09/08/02 Initial coding +0002 B Hagman 09/08/18 Multiple pins +0003 B Hagman 09/08/18 Moved initialization from constructor to begin() +0004 B Hagman 09/09/26 Fixed problems with ATmega8 +0005 B Hagman 09/11/23 Scanned prescalars for best fit on 8 bit timers + 09/11/25 Changed pin toggle method to XOR + 09/11/25 Fixed timer0 from being excluded +0006 D Mellis 09/12/29 Replaced objects with functions +0007 M Sproul 10/08/29 Changed #ifdefs from cpu to register +0008 S Kanemoto 12/06/22 Fixed for Leonardo by @maris_HY +*************************************************/ + +#include "Arduino.h" +#include "pins_arduino.h" + + +static int8_t toneBegin(uint8_t _pin) +{ +} + +void tone(uint8_t _pin, unsigned int frequency, unsigned long duration) +{ +} + +void noTone(uint8_t _pin) +{ +} diff --git a/hardware/arduino/esp8266/cores/esp8266/Udp.h b/hardware/arduino/esp8266/cores/esp8266/Udp.h new file mode 100644 index 000000000..dc5644b9d --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/Udp.h @@ -0,0 +1,88 @@ +/* + * 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 +#include + +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 diff --git a/hardware/arduino/esp8266/cores/esp8266/WCharacter.h b/hardware/arduino/esp8266/cores/esp8266/WCharacter.h new file mode 100644 index 000000000..79733b50a --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/WCharacter.h @@ -0,0 +1,168 @@ +/* + 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 + +// 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 \ No newline at end of file diff --git a/hardware/arduino/esp8266/cores/esp8266/WInterrupts.c b/hardware/arduino/esp8266/cores/esp8266/WInterrupts.c new file mode 100644 index 000000000..f4ee9d3b9 --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/WInterrupts.c @@ -0,0 +1,38 @@ +/* -*- mode: jde; c-basic-offset: 2; indent-tabs-mode: nil -*- */ + +/* + Part of the Wiring project - http://wiring.uniandes.edu.co + + Copyright (c) 2004-05 Hernando Barragan + + 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 + + Modified 24 November 2006 by David A. Mellis + Modified 1 August 2010 by Mark Sproul +*/ + +#include +#include + +#include "wiring_private.h" + + +void attachInterrupt(uint8_t interruptNum, void (*userFunc)(void), int mode) { +} + +void detachInterrupt(uint8_t interruptNum) { +} + diff --git a/hardware/arduino/esp8266/cores/esp8266/WMath.cpp b/hardware/arduino/esp8266/cores/esp8266/WMath.cpp new file mode 100644 index 000000000..ea10726fb --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/WMath.cpp @@ -0,0 +1,60 @@ +/* -*- 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 +} + +void randomSeed(unsigned int 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; } \ No newline at end of file diff --git a/hardware/arduino/esp8266/cores/esp8266/WString.cpp b/hardware/arduino/esp8266/cores/esp8266/WString.cpp new file mode 100644 index 000000000..ea995945a --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/WString.cpp @@ -0,0 +1,704 @@ +/* + 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 + + 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" +/*********************************************/ +/* Constructors */ +/*********************************************/ + +String::String(const char *cstr) +{ + init(); + if (cstr) copy(cstr, strlen(cstr)); +} + +String::String(const String &value) +{ + init(); + *this = value; +} + +#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() +{ + free(buffer); +} + +/*********************************************/ +/* Memory Management */ +/*********************************************/ + +inline void String::init(void) +{ + buffer = NULL; + capacity = 0; + len = 0; +} + +void String::invalidate(void) +{ + if (buffer) free(buffer); + buffer = NULL; + capacity = len = 0; +} + +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) +{ + char *newbuffer = (char *)realloc(buffer, maxStrLen + 1); + if (newbuffer) { + buffer = newbuffer; + capacity = maxStrLen; + return 1; + } + 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; +} + + +#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; +} + + +/*********************************************/ +/* 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)); +} + +/*********************************************/ +/* Concatenate */ +/*********************************************/ + +StringSumHelper & operator + (const StringSumHelper &lhs, const String &rhs) +{ + StringSumHelper &a = const_cast(lhs); + if (!a.concat(rhs.buffer, rhs.len)) a.invalidate(); + return a; +} + +StringSumHelper & operator + (const StringSumHelper &lhs, const char *cstr) +{ + StringSumHelper &a = const_cast(lhs); + if (!cstr || !a.concat(cstr, strlen(cstr))) a.invalidate(); + return a; +} + +StringSumHelper & operator + (const StringSumHelper &lhs, char c) +{ + StringSumHelper &a = const_cast(lhs); + if (!a.concat(c)) a.invalidate(); + return a; +} + +StringSumHelper & operator + (const StringSumHelper &lhs, unsigned char num) +{ + StringSumHelper &a = const_cast(lhs); + if (!a.concat(num)) a.invalidate(); + return a; +} + +StringSumHelper & operator + (const StringSumHelper &lhs, int num) +{ + StringSumHelper &a = const_cast(lhs); + if (!a.concat(num)) a.invalidate(); + return a; +} + +StringSumHelper & operator + (const StringSumHelper &lhs, unsigned int num) +{ + StringSumHelper &a = const_cast(lhs); + if (!a.concat(num)) a.invalidate(); + return a; +} + +StringSumHelper & operator + (const StringSumHelper &lhs, long num) +{ + StringSumHelper &a = const_cast(lhs); + if (!a.concat(num)) a.invalidate(); + return a; +} + +StringSumHelper & operator + (const StringSumHelper &lhs, unsigned long num) +{ + StringSumHelper &a = const_cast(lhs); + if (!a.concat(num)) a.invalidate(); + return a; +} + +StringSumHelper & operator + (const StringSumHelper &lhs, float num) +{ + StringSumHelper &a = const_cast(lhs); + if (!a.concat(num)) a.invalidate(); + return a; +} + +StringSumHelper & operator + (const StringSumHelper &lhs, double num) +{ + StringSumHelper &a = const_cast(lhs); + if (!a.concat(num)) 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 float(atof(buffer)); + return 0; +} diff --git a/hardware/arduino/esp8266/cores/esp8266/WString.h b/hardware/arduino/esp8266/cores/esp8266/WString.h new file mode 100644 index 000000000..abba02f22 --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/WString.h @@ -0,0 +1,209 @@ +/* + 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 +#include +#include +#define PROGMEM + +// An inherited class for holding the result of a concatenation. These +// result objects are assumed to be writable by subsequent concatenations. +class StringSumHelper; + +// 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); + #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 {return len;} + + // 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); + #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); + + // 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);} + + 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); + + // 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); + #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 diff --git a/hardware/arduino/esp8266/cores/esp8266/abi.cpp b/hardware/arduino/esp8266/cores/esp8266/abi.cpp new file mode 100644 index 000000000..8d719b8e6 --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/abi.cpp @@ -0,0 +1,35 @@ +/* + Copyright (c) 2014 Arduino. 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 + +extern "C" void __cxa_pure_virtual(void) __attribute__ ((__noreturn__)); +extern "C" void __cxa_deleted_virtual(void) __attribute__ ((__noreturn__)); + +void __cxa_pure_virtual(void) { + // We might want to write some diagnostics to uart in this case + //std::terminate(); + abort(); +} + +void __cxa_deleted_virtual(void) { + // We might want to write some diagnostics to uart in this case + //std::terminate(); + abort(); +} + diff --git a/hardware/arduino/esp8266/cores/esp8266/binary.h b/hardware/arduino/esp8266/cores/esp8266/binary.h new file mode 100644 index 000000000..aec4c733d --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/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 diff --git a/hardware/arduino/esp8266/cores/esp8266/hooks.c b/hardware/arduino/esp8266/cores/esp8266/hooks.c new file mode 100644 index 000000000..641eabc73 --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/hooks.c @@ -0,0 +1,31 @@ +/* + Copyright (c) 2012 Arduino. 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 +*/ + +/** + * Empty yield() hook. + * + * This function is intended to be used by library writers to build + * libraries or sketches that supports cooperative threads. + * + * Its defined as a weak symbol and it can be redefined to implement a + * real cooperative scheduler. + */ +static void __empty() { + // Empty +} +void yield(void) __attribute__ ((weak, alias("__empty"))); diff --git a/hardware/arduino/esp8266/cores/esp8266/main.cpp b/hardware/arduino/esp8266/cores/esp8266/main.cpp new file mode 100644 index 000000000..56dadc936 --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/main.cpp @@ -0,0 +1,68 @@ +/* + main.cpp - Main loop for Arduino sketches + 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 +*/ + +#include +extern "C" { +#include "ets_sys.h" +#include "os_type.h" +#include "osapi.h" +#include "mem.h" +#include "user_interface.h" +} + +//Declared weak in Arduino.h to allow user redefinitions. +int atexit(void (*func)()) { return 0; } + +// Weak empty variant initialization function. +// May be redefined by variant files. +void initVariant() __attribute__((weak)); +void initVariant() { } + +extern void loop(); +extern void setup(); + +#define LOOP_TASK_PRIORITY 0 +#define LOOP_QUEUE_SIZE 1 + +os_event_t loop_queue[LOOP_QUEUE_SIZE]; + +void loop_task(os_event_t *events) +{ + loop(); + system_os_post(LOOP_TASK_PRIORITY, 0, 0); +} + +extern "C" { +void user_init(void) +{ + init(); + + initVariant(); + + system_os_task( loop_task, + LOOP_TASK_PRIORITY, + loop_queue, + LOOP_QUEUE_SIZE); + setup(); + loop_task(0); +} +} + + + diff --git a/hardware/arduino/esp8266/cores/esp8266/new.cpp b/hardware/arduino/esp8266/cores/esp8266/new.cpp new file mode 100644 index 000000000..cf6f89c17 --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/new.cpp @@ -0,0 +1,36 @@ +/* + Copyright (c) 2014 Arduino. 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 + +void *operator new(size_t size) { + return malloc(size); +} + +void *operator new[](size_t size) { + return malloc(size); +} + +void operator delete(void * ptr) { + free(ptr); +} + +void operator delete[](void * ptr) { + free(ptr); +} + diff --git a/hardware/arduino/esp8266/cores/esp8266/new.h b/hardware/arduino/esp8266/cores/esp8266/new.h new file mode 100644 index 000000000..6e1b68f0d --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/new.h @@ -0,0 +1,30 @@ +/* + Copyright (c) 2014 Arduino. 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 NEW_H +#define NEW_H + +#include + +void * operator new(size_t size); +void * operator new[](size_t size); +void operator delete(void * ptr); +void operator delete[](void * ptr); + +#endif + diff --git a/hardware/arduino/esp8266/cores/esp8266/stdlib_noniso.c b/hardware/arduino/esp8266/cores/esp8266/stdlib_noniso.c new file mode 100644 index 000000000..6b623310e --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/stdlib_noniso.c @@ -0,0 +1,38 @@ +#include +#include "stdlib_noniso.h" + +char * itoa (int val, char *s, int radix) +{ + *s = 0; + return s; +} + +char * ltoa (long val, char *s, int radix) +{ + *s = 0; + return s; +} + +char * utoa (unsigned int val, char *s, int radix) +{ + *s = 0; + return s; +} + +char * ultoa (unsigned long val, char *s, int radix) +{ + *s = 0; + return s; +} + +char * dtostre (double __val, char *__s, unsigned char __prec, unsigned char __flags) +{ + *__s = 0; + return __s; +} + +char * dtostrf (double __val, signed char __width, unsigned char __prec, char *__s) +{ + *__s = 0; + return __s; +} diff --git a/hardware/arduino/esp8266/cores/esp8266/stdlib_noniso.h b/hardware/arduino/esp8266/cores/esp8266/stdlib_noniso.h new file mode 100644 index 000000000..c2bd41bba --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/stdlib_noniso.h @@ -0,0 +1,26 @@ +#ifndef STDLIB_NONISO_H +#define STDLIB_NONISO_H + +#ifdef __cplusplus +extern "C"{ +#endif + + +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* dtostre (double val, char *s, unsigned char prec, unsigned char flags); + +char* dtostrf (double val, signed char width, unsigned char prec, char *s); + +#ifdef __cplusplus +} // extern "C" +#endif + + +#endif diff --git a/hardware/arduino/esp8266/cores/esp8266/user_config.h b/hardware/arduino/esp8266/cores/esp8266/user_config.h new file mode 100755 index 000000000..8b1378917 --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/user_config.h @@ -0,0 +1 @@ + diff --git a/hardware/arduino/esp8266/cores/esp8266/wiring.c b/hardware/arduino/esp8266/cores/esp8266/wiring.c new file mode 100644 index 000000000..6afe05cb9 --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/wiring.c @@ -0,0 +1,68 @@ +/* + wiring.c - Partial implementation of the Wiring API for the ATmega8. + 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$ +*/ + +#include "wiring_private.h" + +// the prescaler is set so that timer0 ticks every 64 clock cycles, and the +// the overflow handler is called every 256 ticks. +#define MICROSECONDS_PER_TIMER0_OVERFLOW (clockCyclesToMicroseconds(64 * 256)) + +// the whole number of milliseconds per timer0 overflow +#define MILLIS_INC (MICROSECONDS_PER_TIMER0_OVERFLOW / 1000) + +// the fractional number of milliseconds per timer0 overflow. we shift right +// by three to fit these numbers into a byte. (for the clock speeds we care +// about - 8 and 16 MHz - this doesn't lose precision.) +#define FRACT_INC ((MICROSECONDS_PER_TIMER0_OVERFLOW % 1000) >> 3) +#define FRACT_MAX (1000 >> 3) + +volatile unsigned long timer0_overflow_count = 0; +volatile unsigned long timer0_millis = 0; +static unsigned char timer0_fract = 0; + + +unsigned long millis() +{ + unsigned long m = 0; + + return m; +} + +unsigned long micros() { + unsigned long m = 0; + + return m; +} + +void delay(unsigned long ms) +{ +} + +void delayMicroseconds(unsigned int us) +{ +} + +void init() +{ +} diff --git a/hardware/arduino/esp8266/cores/esp8266/wiring_analog.c b/hardware/arduino/esp8266/cores/esp8266/wiring_analog.c new file mode 100644 index 000000000..00bba350b --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/wiring_analog.c @@ -0,0 +1,55 @@ +/* + wiring_analog.c - analog input and output + 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 + + Modified 28 September 2010 by Mark Sproul + + $Id: wiring.c 248 2007-02-03 15:36:30Z mellis $ +*/ + +#include "wiring_private.h" +#include "pins_arduino.h" + +uint8_t analog_reference = DEFAULT; + +void analogReference(uint8_t mode) +{ + analog_reference = mode; +} + +int analogRead(uint8_t pin) +{ + uint8_t low, high; + + low = 0; + high = 0; + + // combine the two bytes + return (high << 8) | low; +} + +// Right now, PWM output only works on the pins with +// hardware support. These are defined in the appropriate +// pins_*.c file. For the rest of the pins, we default +// to digital output. +void analogWrite(uint8_t pin, int val) +{ +} + diff --git a/hardware/arduino/esp8266/cores/esp8266/wiring_digital.c b/hardware/arduino/esp8266/cores/esp8266/wiring_digital.c new file mode 100644 index 000000000..aa93d99ed --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/wiring_digital.c @@ -0,0 +1,45 @@ +/* + wiring_digital.c - digital input and output functions + 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 + + Modified 28 September 2010 by Mark Sproul + + $Id: wiring.c 248 2007-02-03 15:36:30Z mellis $ +*/ + +#define ARDUINO_MAIN +#include "wiring_private.h" +#include "pins_arduino.h" + +void pinMode(uint8_t pin, uint8_t mode) +{ + +} + +void digitalWrite(uint8_t pin, uint8_t val) +{ + +} + +int digitalRead(uint8_t pin) +{ + + return LOW; +} diff --git a/hardware/arduino/esp8266/cores/esp8266/wiring_private.h b/hardware/arduino/esp8266/cores/esp8266/wiring_private.h new file mode 100644 index 000000000..0d16936ba --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/wiring_private.h @@ -0,0 +1,61 @@ +/* + 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 +#include + +#include "Arduino.h" + +#ifdef __cplusplus +extern "C"{ +#endif + +#ifndef cbi +#define cbi(sfr, bit) +#endif +#ifndef sbi +#define sbi(sfr, bit) +#endif + +#define EXTERNAL_INT_0 0 +#define EXTERNAL_INT_1 1 +#define EXTERNAL_INT_2 2 +#define EXTERNAL_INT_3 3 +#define EXTERNAL_INT_4 4 +#define EXTERNAL_INT_5 5 +#define EXTERNAL_INT_6 6 +#define EXTERNAL_INT_7 7 + +#define EXTERNAL_NUM_INTERRUPTS 2 + +typedef void (*voidFuncPtr)(void); + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif diff --git a/hardware/arduino/esp8266/cores/esp8266/wiring_pulse.c b/hardware/arduino/esp8266/cores/esp8266/wiring_pulse.c new file mode 100644 index 000000000..ad9cd491e --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/wiring_pulse.c @@ -0,0 +1,35 @@ +/* + wiring_pulse.c - pulseIn() function + 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.c 248 2007-02-03 15:36:30Z mellis $ +*/ + +#include "wiring_private.h" +#include "pins_arduino.h" + +/* Measures the length (in microseconds) of a pulse on the pin; state is HIGH + * or LOW, the type of pulse to measure. Works on pulses from 2-3 microseconds + * to 3 minutes in length, but must be called at least a few dozen microseconds + * before the start of the pulse. */ +unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout) +{ + return 0; +} diff --git a/hardware/arduino/esp8266/cores/esp8266/wiring_shift.c b/hardware/arduino/esp8266/cores/esp8266/wiring_shift.c new file mode 100644 index 000000000..cfe786758 --- /dev/null +++ b/hardware/arduino/esp8266/cores/esp8266/wiring_shift.c @@ -0,0 +1,55 @@ +/* + wiring_shift.c - shiftOut() function + 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.c 248 2007-02-03 15:36:30Z mellis $ +*/ + +#include "wiring_private.h" + +uint8_t shiftIn(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder) { + uint8_t value = 0; + uint8_t i; + + for (i = 0; i < 8; ++i) { + digitalWrite(clockPin, HIGH); + if (bitOrder == LSBFIRST) + value |= digitalRead(dataPin) << i; + else + value |= digitalRead(dataPin) << (7 - i); + digitalWrite(clockPin, LOW); + } + return value; +} + +void shiftOut(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t val) +{ + uint8_t i; + + for (i = 0; i < 8; i++) { + if (bitOrder == LSBFIRST) + digitalWrite(dataPin, !!(val & (1 << i))); + else + digitalWrite(dataPin, !!(val & (1 << (7 - i)))); + + digitalWrite(clockPin, HIGH); + digitalWrite(clockPin, LOW); + } +} diff --git a/hardware/arduino/esp8266/platform.txt b/hardware/arduino/esp8266/platform.txt new file mode 100644 index 000000000..552cbcae6 --- /dev/null +++ b/hardware/arduino/esp8266/platform.txt @@ -0,0 +1,107 @@ + +# Arduino ESP8266 platform +# ------------------------------ + +# For more info: +# https://github.com/arduino/Arduino/wiki/Arduino-IDE-1.5---3rd-party-Hardware-specification + +name=Arduino ESP8266 +version=1.5.8 + +compiler.tools.path={runtime.ide.path}/hardware/tools/esp8266/ +compiler.path={compiler.tools.path}/xtensa-lx106-elf/bin/ +compiler.sdk.path={compiler.tools.path}/sdk/ + +compiler.cpreprocessor.flags=-D__ets__ -DICACHE_FLASH -I{compiler.sdk.path}/include + +compiler.c.cmd=xtensa-lx106-elf-gcc +compiler.c.flags=-c -Os -Wpointer-arith -Wno-implicit-function-declaration -Wl,-EL -fno-inline-functions -nostdlib -mlongcalls -MMD + +compiler.c.elf.ldscript={compiler.sdk.path}/ld/eagle.app.v6.ld +compiler.c.elf.flags=-nostdlib -Wl,--no-check-sections -u call_user_start -Wl,-static -L{compiler.sdk.path}/lib -T{compiler.c.elf.ldscript} +compiler.c.elf.cmd=xtensa-lx106-elf-gcc +compiler.c.elf.libs=-lc -lgcc -lhal -lphy -lnet80211 -llwip -lwpa -lmain + +compiler.cpp.cmd=xtensa-lx106-elf-g++ +compiler.cpp.flags=-c -Os -mlongcalls -fno-exceptions -MMD + +compiler.ar.cmd=xtensa-lx106-elf-ar +compiler.ar.flags=cru + +compiler.elf2hex.cmd=esptool + +compiler.elf2hex.flags= + +compiler.esptool.cmd=esptool + +# This can be overriden in boards.txt +build.extra_flags= + +# These can be overridden in platform.local.txt +compiler.c.extra_flags= +compiler.c.elf.extra_flags= +compiler.S.extra_flags= +compiler.cpp.extra_flags= +compiler.ar.extra_flags= +compiler.objcopy.eep.extra_flags= +compiler.elf2hex.extra_flags= + +## Compile c files +recipe.c.o.pattern="{compiler.path}{compiler.c.cmd}" {compiler.cpreprocessor.flags} {compiler.c.flags} -DF_CPU={build.f_cpu} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DARDUINO_ARCH_{build.arch} {compiler.c.extra_flags} {build.extra_flags} {includes} "{source_file}" -o "{object_file}" + +## Compile c++ files +recipe.cpp.o.pattern="{compiler.path}{compiler.cpp.cmd}" {compiler.cpreprocessor.flags} {compiler.cpp.flags} -DF_CPU={build.f_cpu} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DARDUINO_ARCH_{build.arch} {compiler.cpp.extra_flags} {build.extra_flags} {includes} "{source_file}" -o "{object_file}" + +## Compile S files +recipe.S.o.pattern= + +## Create archives +recipe.ar.pattern="{compiler.path}{compiler.ar.cmd}" {compiler.ar.flags} {compiler.ar.extra_flags} "{build.path}/{archive_file}" "{object_file}" + +## Combine gc-sections, archives, and objects +recipe.c.combine.pattern="{compiler.path}{compiler.c.elf.cmd}" {compiler.c.elf.flags} {compiler.c.elf.extra_flags} -o "{build.path}/{build.project_name}.elf" -Wl,--start-group {object_files} "{build.path}/{archive_file}" {compiler.c.elf.libs} -Wl,--end-group "-L{build.path}" + +## Create eeprom +recipe.objcopy.eep.pattern=echo EEP + +## Create hex +#recipe.objcopy.hex.pattern="{compiler.path}{compiler.elf2hex.cmd}" {compiler.elf2hex.flags} {compiler.elf2hex.extra_flags} "{build.path}/{build.project_name}.elf" "{build.path}/{build.project_name}.hex" + +recipe.objcopy.hex.pattern={compiler.tools.path}{compiler.esptool.cmd} -eo "{build.path}/{build.project_name}.elf" -bo "{build.path}/{build.project_name}_00000.bin" -bs .text -bs .data -bs .rodata -bc -ec && {compiler.tools.path}{compiler.esptool.cmd} -eo "{build.path}/{build.project_name}.elf" -es .irom0.text "{build.path}/{build.project_name}_40000.bin" -ec + +## Compute size +#recipe.size.pattern="{compiler.path}{compiler.size.cmd}" -A "{build.path}/{build.project_name}.elf" +recipe.size.pattern= +recipe.size.regex=^(?:\.text|\.data|\.bootloader)\s+([0-9]+).* +recipe.size.regex.data=^(?:\.data|\.bss|\.noinit)\s+([0-9]+).* +recipe.size.regex.eeprom=^(?:\.eeprom)\s+([0-9]+).* + + +# AVR Uploader/Programmers tools +# ------------------------------ + +tools.avrdude.cmd.path={runtime.ide.path}/hardware/tools/avr/bin/avrdude +tools.avrdude.config.path={runtime.ide.path}/hardware/tools/avr/etc/avrdude.conf + +tools.avrdude.upload.params.verbose=-v +tools.avrdude.upload.params.quiet=-q -q +tools.avrdude.upload.pattern="{cmd.path}" "-C{config.path}" {upload.verbose} -p{build.mcu} -c{upload.protocol} -P{serial.port} -b{upload.speed} -D "-Uflash:w:{build.path}/{build.project_name}.hex:i" + +tools.avrdude.program.params.verbose=-v +tools.avrdude.program.params.quiet=-q -q +tools.avrdude.program.pattern="{cmd.path}" "-C{config.path}" {program.verbose} -p{build.mcu} -c{protocol} {program.extra_params} "-Uflash:w:{build.path}/{build.project_name}.hex:i" + +tools.avrdude.erase.params.verbose=-v +tools.avrdude.erase.params.quiet=-q -q +tools.avrdude.erase.pattern="{cmd.path}" "-C{config.path}" {erase.verbose} -p{build.mcu} -c{protocol} {program.extra_params} -e -Ulock:w:{bootloader.unlock_bits}:m -Uefuse:w:{bootloader.extended_fuses}:m -Uhfuse:w:{bootloader.high_fuses}:m -Ulfuse:w:{bootloader.low_fuses}:m + +tools.avrdude.bootloader.params.verbose=-v +tools.avrdude.bootloader.params.quiet=-q -q +tools.avrdude.bootloader.pattern="{cmd.path}" "-C{config.path}" {bootloader.verbose} -p{build.mcu} -c{protocol} {program.extra_params} "-Uflash:w:{runtime.platform.path}/bootloaders/{bootloader.file}:i" -Ulock:w:{bootloader.lock_bits}:m + + +# USB Default Flags +# Default blank usb manufacturer will be filled it at compile time +# - from numeric vendor ID, set to Unknown otherwise +build.usb_manufacturer= +build.usb_flags=-DUSB_VID={build.vid} -DUSB_PID={build.pid} '-DUSB_MANUFACTURER={build.usb_manufacturer}' '-DUSB_PRODUCT={build.usb_product}' diff --git a/hardware/arduino/esp8266/programmers.txt b/hardware/arduino/esp8266/programmers.txt new file mode 100644 index 000000000..a1f415c38 --- /dev/null +++ b/hardware/arduino/esp8266/programmers.txt @@ -0,0 +1,6 @@ +esptoolpy.name=esptool +esptoolpy.communication=serial +esptoolpy.protocol=esp +esptoolpy.program.protocol=esp +esptoolpy.program.tool=esptool.py +esptoolpy.program.extra_params=--port {serial.port} diff --git a/hardware/arduino/esp8266/variants/esp01/pins_arduino.h b/hardware/arduino/esp8266/variants/esp01/pins_arduino.h new file mode 100644 index 000000000..1ed0a4633 --- /dev/null +++ b/hardware/arduino/esp8266/variants/esp01/pins_arduino.h @@ -0,0 +1,86 @@ +/* + pins_arduino.h - Pin definition functions for Arduino + Part of Arduino - http://www.arduino.cc/ + + Copyright (c) 2007 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 249 2007-02-03 16:52:51Z mellis $ +*/ + +#ifndef Pins_Arduino_h +#define Pins_Arduino_h + +#define PROGMEM + +#define NUM_DIGITAL_PINS 30 +#define NUM_ANALOG_INPUTS 12 + +#define TX_RX_LED_INIT +#define TXLED0 +#define TXLED1 +#define RXLED0 +#define RXLED1 + +static const uint8_t SDA = 2; +static const uint8_t SCL = 3; +#define LED_BUILTIN 13 + +// Map SPI port to 'new' pins D14..D17 +static const uint8_t SS = 17; +static const uint8_t MOSI = 16; +static const uint8_t MISO = 14; +static const uint8_t SCK = 15; + +// Mapping of analog pins as digital I/O +// A6-A11 share with digital pins +static const uint8_t A0 = 18; +static const uint8_t A1 = 19; +static const uint8_t A2 = 20; +static const uint8_t A3 = 21; +static const uint8_t A4 = 22; +static const uint8_t A5 = 23; +static const uint8_t A6 = 24; // D4 +static const uint8_t A7 = 25; // D6 +static const uint8_t A8 = 26; // D8 +static const uint8_t A9 = 27; // D9 +static const uint8_t A10 = 28; // D10 +static const uint8_t A11 = 29; // D12 + + + +// These serial port names are intended to allow libraries and architecture-neutral +// sketches to automatically default to the correct port name for a particular type +// of use. For example, a GPS module would normally connect to SERIAL_PORT_HARDWARE_OPEN, +// the first hardware serial port whose RX/TX pins are not dedicated to another use. +// +// SERIAL_PORT_MONITOR Port which normally prints to the Arduino Serial Monitor +// +// SERIAL_PORT_USBVIRTUAL Port which is USB virtual serial +// +// SERIAL_PORT_LINUXBRIDGE Port which connects to a Linux system via Bridge library +// +// SERIAL_PORT_HARDWARE Hardware serial port, physical RX & TX pins. +// +// SERIAL_PORT_HARDWARE_OPEN Hardware serial ports which are open for use. Their RX & TX +// pins are NOT connected to anything by default. +#define SERIAL_PORT_MONITOR Serial +#define SERIAL_PORT_USBVIRTUAL Serial +#define SERIAL_PORT_HARDWARE Serial1 +#define SERIAL_PORT_HARDWARE_OPEN Serial1 + +#endif /* Pins_Arduino_h */ diff --git a/hardware/tools/esp8266/esptool.py b/hardware/tools/esp8266/esptool.py new file mode 100755 index 000000000..b8d33a72f --- /dev/null +++ b/hardware/tools/esp8266/esptool.py @@ -0,0 +1,383 @@ +#!/usr/bin/env python +# +# ESP8266 ROM Bootloader Utility +# https://github.com/themadinventor/esptool +# +# Copyright (C) 2014 Fredrik Ahlberg +# +# This program is free software; you can redistribute it and/or modify it under +# the terms of the GNU General Public License as published by the Free Software +# Foundation; either version 2 of the License, or (at your option) any later version. +# +# This program 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 General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., 51 Franklin +# Street, Fifth Floor, Boston, MA 02110-1301 USA. + +import sys +import struct +import serial +import math +import time +import argparse + +class ESPROM: + + # These are the currently known commands supported by the ROM + ESP_FLASH_BEGIN = 0x02 + ESP_FLASH_DATA = 0x03 + ESP_FLASH_END = 0x04 + ESP_MEM_BEGIN = 0x05 + ESP_MEM_END = 0x06 + ESP_MEM_DATA = 0x07 + ESP_SYNC = 0x08 + ESP_WRITE_REG = 0x09 + ESP_READ_REG = 0x0a + + # Maximum block sized for RAM and Flash writes, respectively. + ESP_RAM_BLOCK = 0x1800 + ESP_FLASH_BLOCK = 0x400 + + # Default baudrate used by the ROM. Don't know if it is possible to change. + ESP_ROM_BAUD = 57600 + + # First byte of the application image + ESP_IMAGE_MAGIC = 0xe9 + + # Initial state for the checksum routine + ESP_CHECKSUM_MAGIC = 0xef + + def __init__(self, port = 0): + self._port = serial.Serial(port, self.ESP_ROM_BAUD) + + """ Read bytes from the serial port while performing SLIP unescaping """ + def read(self, length = 1): + b = '' + while len(b) < length: + c = self._port.read(1) + if c == '\xdb': + c = self._port.read(1) + if c == '\xdc': + b = b + '\xc0' + elif c == '\xdd': + b = b + '\xdb' + else: + raise Exception('Invalid SLIP escape') + else: + b = b + c + return b + + """ Write bytes to the serial port while performing SLIP escaping """ + def write(self, packet): + buf = '\xc0' + for b in packet: + if b == '\xc0': + buf += '\xdb\xdc' + elif b == '\xdb': + buf += '\xdb\xdd' + else: + buf += b + buf += '\xc0' + self._port.write(buf) + + """ Calculate checksum of a blob, as it is defined by the ROM """ + @staticmethod + def checksum(data, state = ESP_CHECKSUM_MAGIC): + for b in data: + state ^= ord(b) + return state + + """ Send a request and read the response """ + def command(self, op = None, data = None, chk = 0): + if op: + # Construct and send request + pkt = struct.pack(' 16: + raise Exception('Invalid firmware image') + + for i in xrange(segments): + (offset, size) = struct.unpack(' 0x40200000 or offset < 0x3ffe0000 or size > 65536: + raise Exception('Suspicious segment %x,%d' % (offset, size)) + self.segments.append((offset, size, f.read(size))) + + # Skip the padding. The checksum is stored in the last byte so that the + # file is a multiple of 16 bytes. + align = 15-(f.tell() % 16) + f.seek(align, 1) + + self.checksum = ord(f.read(1)) + + def add_segment(self, addr, data): + self.segments.append((addr, len(data), data)) + + def save(self, filename): + f = file(filename, 'wb') + f.write(struct.pack(' 0: + esp.mem_block(data[0:esp.ESP_RAM_BLOCK], seq) + data = data[esp.ESP_RAM_BLOCK:] + seq += 1 + print 'done!' + + print 'All segments done, executing at %08x' % image.entrypoint + esp.mem_finish(image.entrypoint) + + elif args.operation == 'read_mem': + print '0x%08x = 0x%08x' % (args.address, esp.read_reg(args.address)) + + elif args.operation == 'write_mem': + esp.write_reg(args.address, args.value, args.mask, 0) + print 'Wrote %08x, mask %08x to %08x' % (args.value, args.mask, args.address) + + elif args.operation == 'dump_mem': + f = file(args.filename, 'wb') + for i in xrange(args.size/4): + d = esp.read_reg(args.address+(i*4)) + f.write(struct.pack(' 0: + print '\rWriting at 0x%08x... (%d %%)' % (args.address + seq*esp.ESP_FLASH_BLOCK, 100*seq/blocks), + sys.stdout.flush() + esp.flash_block(image[0:esp.ESP_FLASH_BLOCK], seq) + image = image[esp.ESP_FLASH_BLOCK:] + seq += 1 + print '\nLeaving...' + esp.flash_finish(False) + + elif args.operation == 'image_info': + image = ESPFirmwareImage(args.filename) + print ('Entry point: %08x' % image.entrypoint) if image.entrypoint != 0 else 'Entry point not set' + print '%d segments' % len(image.segments) + print + checksum = ESPROM.ESP_CHECKSUM_MAGIC + for (idx, (offset, size, data)) in enumerate(image.segments): + print 'Segment %d: %5d bytes at %08x' % (idx+1, size, offset) + checksum = ESPROM.checksum(data, checksum) + print + print 'Checksum: %02x (%s)' % (image.checksum, 'valid' if image.checksum == checksum else 'invalid!') + + elif args.operation == 'make_image': + image = ESPFirmwareImage() + if len(args.segfile) == 0: + raise Exception('No segments specified') + if len(args.segfile) != len(args.segaddr): + raise Exception('Number of specified files does not match number of specified addresses') + for (seg, addr) in zip(args.segfile, args.segaddr): + data = file(seg, 'rb').read() + image.add_segment(addr, data) + image.entrypoint = args.entrypoint + image.save(args.output) diff --git a/hardware/tools/esp8266/sdk/include/c_types.h b/hardware/tools/esp8266/sdk/include/c_types.h new file mode 100755 index 000000000..73432f9f4 --- /dev/null +++ b/hardware/tools/esp8266/sdk/include/c_types.h @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2010 - 2011 Espressif System + * + */ + +#ifndef _C_TYPES_H_ +#define _C_TYPES_H_ +#include + +// typedef unsigned char uint8_t; +typedef signed char sint8_t; +// typedef signed char int8_t; +// typedef unsigned short uint16_t; +typedef signed short sint16_t; +// typedef signed short int16_t; +// typedef unsigned long uint32_t; +typedef signed long sint32_t; +// typedef signed long int32_t; +typedef signed long long sint64_t; +// typedef unsigned long long uint64_t; +typedef unsigned long long u_int64_t; +typedef float real32_t; +typedef double real64_t; + +typedef unsigned char uint8; +typedef unsigned char u8; +typedef signed char sint8; +typedef signed char int8; +typedef signed char s8; +typedef unsigned short uint16; +typedef unsigned short u16; +typedef signed short sint16; +typedef signed short s16; +typedef unsigned int uint32; +typedef unsigned int u_int; +typedef unsigned int u32; +typedef signed int sint32; +typedef signed int s32; +typedef int int32; +typedef signed long long sint64; +typedef unsigned long long uint64; +typedef unsigned long long u64; +typedef float real32; +typedef double real64; + +#define __le16 u16 + +//typedef unsigned int size_t; + +#define __packed __attribute__((packed)) + +#define LOCAL static + +#ifndef NULL +#define NULL (void *)0 +#endif /* NULL */ + +/* probably should not put STATUS here */ +typedef enum { + OK = 0, + FAIL, + PENDING, + BUSY, + CANCEL, +} STATUS; + +#define BIT(nr) (1UL << (nr)) + +#define REG_SET_BIT(_r, _b) (*(volatile uint32_t*)(_r) |= (_b)) +#define REG_CLR_BIT(_r, _b) (*(volatile uint32_t*)(_r) &= ~(_b)) + +#define DMEM_ATTR __attribute__((section(".bss"))) +#define SHMEM_ATTR + +#ifdef ICACHE_FLASH +#define ICACHE_FLASH_ATTR __attribute__((section(".irom0.text"))) +#else +#define ICACHE_FLASH_ATTR +#endif /* ICACHE_FLASH */ + +#ifndef __cplusplus +typedef unsigned char bool; +#define BOOL bool +#define true (1) +#define false (0) +#define TRUE true +#define FALSE false + + +#endif /* !__cplusplus */ + +#endif /* _C_TYPES_H_ */ diff --git a/hardware/tools/esp8266/sdk/include/eagle_soc.h b/hardware/tools/esp8266/sdk/include/eagle_soc.h new file mode 100755 index 000000000..53ac61772 --- /dev/null +++ b/hardware/tools/esp8266/sdk/include/eagle_soc.h @@ -0,0 +1,255 @@ +/* + * Copyright (c) Espressif System 2010 - 2012 + * + */ + +#ifndef _EAGLE_SOC_H_ +#define _EAGLE_SOC_H_ + +//Register Bits{{ +#define BIT31 0x80000000 +#define BIT30 0x40000000 +#define BIT29 0x20000000 +#define BIT28 0x10000000 +#define BIT27 0x08000000 +#define BIT26 0x04000000 +#define BIT25 0x02000000 +#define BIT24 0x01000000 +#define BIT23 0x00800000 +#define BIT22 0x00400000 +#define BIT21 0x00200000 +#define BIT20 0x00100000 +#define BIT19 0x00080000 +#define BIT18 0x00040000 +#define BIT17 0x00020000 +#define BIT16 0x00010000 +#define BIT15 0x00008000 +#define BIT14 0x00004000 +#define BIT13 0x00002000 +#define BIT12 0x00001000 +#define BIT11 0x00000800 +#define BIT10 0x00000400 +#define BIT9 0x00000200 +#define BIT8 0x00000100 +#define BIT7 0x00000080 +#define BIT6 0x00000040 +#define BIT5 0x00000020 +#define BIT4 0x00000010 +#define BIT3 0x00000008 +#define BIT2 0x00000004 +#define BIT1 0x00000002 +#define BIT0 0x00000001 +//}} + +//Registers Operation {{ +#define ETS_UNCACHED_ADDR(addr) (addr) +#define ETS_CACHED_ADDR(addr) (addr) + + +#define READ_PERI_REG(addr) (*((volatile uint32_t *)ETS_UNCACHED_ADDR(addr))) +#define WRITE_PERI_REG(addr, val) (*((volatile uint32_t *)ETS_UNCACHED_ADDR(addr))) = (uint32_t)(val) +#define CLEAR_PERI_REG_MASK(reg, mask) WRITE_PERI_REG((reg), (READ_PERI_REG(reg)&(~(mask)))) +#define SET_PERI_REG_MASK(reg, mask) WRITE_PERI_REG((reg), (READ_PERI_REG(reg)|(mask))) +#define GET_PERI_REG_BITS(reg, hipos,lowpos) ((READ_PERI_REG(reg)>>(lowpos))&((1<<((hipos)-(lowpos)+1))-1)) +#define SET_PERI_REG_BITS(reg,bit_map,value,shift) (WRITE_PERI_REG((reg),(READ_PERI_REG(reg)&(~((bit_map)<<(shift))))|((value)<<(shift)) )) +//}} + +//Periheral Clock {{ +#define CPU_CLK_FREQ 80*1000000 //unit: Hz +#define APB_CLK_FREQ CPU_CLK_FREQ +#define UART_CLK_FREQ APB_CLK_FREQ +#define TIMER_CLK_FREQ (APB_CLK_FREQ>>8) //divided by 256 +//}} + +//Peripheral device base address define{{ +#define PERIPHS_DPORT_BASEADDR 0x3ff00000 +#define PERIPHS_GPIO_BASEADDR 0x60000300 +#define PERIPHS_TIMER_BASEDDR 0x60000600 +#define PERIPHS_RTC_BASEADDR 0x60000700 +#define PERIPHS_IO_MUX 0x60000800 +//}} + +//Interrupt remap control registers define{{ +#define EDGE_INT_ENABLE_REG (PERIPHS_DPORT_BASEADDR+0x04) +#define TM1_EDGE_INT_ENABLE() SET_PERI_REG_MASK(EDGE_INT_ENABLE_REG, BIT1) +#define TM1_EDGE_INT_DISABLE() CLEAR_PERI_REG_MASK(EDGE_INT_ENABLE_REG, BIT1) +//}} + +//GPIO reg {{ +#define GPIO_REG_READ(reg) READ_PERI_REG(PERIPHS_GPIO_BASEADDR + reg) +#define GPIO_REG_WRITE(reg, val) WRITE_PERI_REG(PERIPHS_GPIO_BASEADDR + reg, val) +#define GPIO_OUT_ADDRESS 0x00 +#define GPIO_OUT_W1TS_ADDRESS 0x04 +#define GPIO_OUT_W1TC_ADDRESS 0x08 + +#define GPIO_ENABLE_ADDRESS 0x0c +#define GPIO_ENABLE_W1TS_ADDRESS 0x10 +#define GPIO_ENABLE_W1TC_ADDRESS 0x14 +#define GPIO_OUT_W1TC_DATA_MASK 0x0000ffff + +#define GPIO_IN_ADDRESS 0x18 + +#define GPIO_STATUS_ADDRESS 0x1c +#define GPIO_STATUS_W1TS_ADDRESS 0x20 +#define GPIO_STATUS_W1TC_ADDRESS 0x24 +#define GPIO_STATUS_INTERRUPT_MASK 0x0000ffff + +#define GPIO_RTC_CALIB_SYNC PERIPHS_GPIO_BASEADDR+0x6c +#define RTC_CALIB_START BIT31 //first write to zero, then to one to start +#define RTC_PERIOD_NUM_MASK 0x3ff //max 8ms +#define GPIO_RTC_CALIB_VALUE PERIPHS_GPIO_BASEADDR+0x70 +#define RTC_CALIB_RDY_S 31 //after measure, flag to one, when start from zero to one, turn to zero +#define RTC_CALIB_VALUE_MASK 0xfffff + +#define GPIO_PIN0_ADDRESS 0x28 + +#define GPIO_ID_PIN0 0 +#define GPIO_ID_PIN(n) (GPIO_ID_PIN0+(n)) +#define GPIO_LAST_REGISTER_ID GPIO_ID_PIN(15) +#define GPIO_ID_NONE 0xffffffff + +#define GPIO_PIN_COUNT 16 + +#define GPIO_PIN_CONFIG_MSB 12 +#define GPIO_PIN_CONFIG_LSB 11 +#define GPIO_PIN_CONFIG_MASK 0x00001800 +#define GPIO_PIN_CONFIG_GET(x) (((x) & GPIO_PIN_CONFIG_MASK) >> GPIO_PIN_CONFIG_LSB) +#define GPIO_PIN_CONFIG_SET(x) (((x) << GPIO_PIN_CONFIG_LSB) & GPIO_PIN_CONFIG_MASK) + +#define GPIO_WAKEUP_ENABLE 1 +#define GPIO_WAKEUP_DISABLE (~GPIO_WAKEUP_ENABLE) +#define GPIO_PIN_WAKEUP_ENABLE_MSB 10 +#define GPIO_PIN_WAKEUP_ENABLE_LSB 10 +#define GPIO_PIN_WAKEUP_ENABLE_MASK 0x00000400 +#define GPIO_PIN_WAKEUP_ENABLE_GET(x) (((x) & GPIO_PIN_WAKEUP_ENABLE_MASK) >> GPIO_PIN_WAKEUP_ENABLE_LSB) +#define GPIO_PIN_WAKEUP_ENABLE_SET(x) (((x) << GPIO_PIN_WAKEUP_ENABLE_LSB) & GPIO_PIN_WAKEUP_ENABLE_MASK) + +#define GPIO_PIN_INT_TYPE_MASK 0x380 +#define GPIO_PIN_INT_TYPE_MSB 9 +#define GPIO_PIN_INT_TYPE_LSB 7 +#define GPIO_PIN_INT_TYPE_GET(x) (((x) & GPIO_PIN_INT_TYPE_MASK) >> GPIO_PIN_INT_TYPE_LSB) +#define GPIO_PIN_INT_TYPE_SET(x) (((x) << GPIO_PIN_INT_TYPE_LSB) & GPIO_PIN_INT_TYPE_MASK) + +#define GPIO_PAD_DRIVER_ENABLE 1 +#define GPIO_PAD_DRIVER_DISABLE (~GPIO_PAD_DRIVER_ENABLE) +#define GPIO_PIN_PAD_DRIVER_MSB 2 +#define GPIO_PIN_PAD_DRIVER_LSB 2 +#define GPIO_PIN_PAD_DRIVER_MASK 0x00000004 +#define GPIO_PIN_PAD_DRIVER_GET(x) (((x) & GPIO_PIN_PAD_DRIVER_MASK) >> GPIO_PIN_PAD_DRIVER_LSB) +#define GPIO_PIN_PAD_DRIVER_SET(x) (((x) << GPIO_PIN_PAD_DRIVER_LSB) & GPIO_PIN_PAD_DRIVER_MASK) + +#define GPIO_AS_PIN_SOURCE 0 +#define SIGMA_AS_PIN_SOURCE (~GPIO_AS_PIN_SOURCE) +#define GPIO_PIN_SOURCE_MSB 0 +#define GPIO_PIN_SOURCE_LSB 0 +#define GPIO_PIN_SOURCE_MASK 0x00000001 +#define GPIO_PIN_SOURCE_GET(x) (((x) & GPIO_PIN_SOURCE_MASK) >> GPIO_PIN_SOURCE_LSB) +#define GPIO_PIN_SOURCE_SET(x) (((x) << GPIO_PIN_SOURCE_LSB) & GPIO_PIN_SOURCE_MASK) +// }} + +// TIMER reg {{ +#define RTC_REG_READ(addr) READ_PERI_REG(PERIPHS_TIMER_BASEDDR + addr) +#define RTC_REG_WRITE(addr, val) WRITE_PERI_REG(PERIPHS_TIMER_BASEDDR + addr, val) +#define RTC_CLR_REG_MASK(reg, mask) CLEAR_PERI_REG_MASK(PERIPHS_TIMER_BASEDDR +reg, mask) +/* Returns the current time according to the timer timer. */ +#define NOW() RTC_REG_READ(FRC2_COUNT_ADDRESS) + +//load initial_value to timer1 +#define FRC1_LOAD_ADDRESS 0x00 + +//timer1's counter value(count from initial_value to 0) +#define FRC1_COUNT_ADDRESS 0x04 + +#define FRC1_CTRL_ADDRESS 0x08 + +//clear timer1's interrupt when write this address +#define FRC1_INT_ADDRESS 0x0c +#define FRC1_INT_CLR_MASK 0x00000001 + +//timer2's counter value(count from initial_value to 0) +#define FRC2_COUNT_ADDRESS 0x24 +// }} + +//RTC reg {{ +#define REG_RTC_BASE PERIPHS_RTC_BASEADDR + +#define RTC_GPIO_OUT (REG_RTC_BASE + 0x068) +#define RTC_GPIO_ENABLE (REG_RTC_BASE + 0x074) +#define RTC_GPIO_IN_DATA (REG_RTC_BASE + 0x08C) +#define RTC_GPIO_CONF (REG_RTC_BASE + 0x090) +#define PAD_XPD_DCDC_CONF (REG_RTC_BASE + 0x0A0) +//}} + +//PIN Mux reg {{ +#define PERIPHS_IO_MUX_FUNC 0x13 +#define PERIPHS_IO_MUX_FUNC_S 4 +#define PERIPHS_IO_MUX_PULLUP BIT7 +#define PERIPHS_IO_MUX_PULLDWN BIT6 +#define PERIPHS_IO_MUX_SLEEP_PULLUP BIT3 +#define PERIPHS_IO_MUX_SLEEP_PULLDWN BIT2 +#define PERIPHS_IO_MUX_SLEEP_OE BIT1 +#define PERIPHS_IO_MUX_OE BIT0 + +#define PERIPHS_IO_MUX_CONF_U (PERIPHS_IO_MUX + 0x00) +#define SPI0_CLK_EQU_SYS_CLK BIT8 +#define SPI1_CLK_EQU_SYS_CLK BIT9 +#define PERIPHS_IO_MUX_MTDI_U (PERIPHS_IO_MUX + 0x04) +#define FUNC_GPIO12 3 +#define PERIPHS_IO_MUX_MTCK_U (PERIPHS_IO_MUX + 0x08) +#define FUNC_GPIO13 3 +#define PERIPHS_IO_MUX_MTMS_U (PERIPHS_IO_MUX + 0x0C) +#define FUNC_GPIO14 3 +#define PERIPHS_IO_MUX_MTDO_U (PERIPHS_IO_MUX + 0x10) +#define FUNC_GPIO15 3 +#define FUNC_U0RTS 4 +#define PERIPHS_IO_MUX_U0RXD_U (PERIPHS_IO_MUX + 0x14) +#define FUNC_GPIO3 3 +#define PERIPHS_IO_MUX_U0TXD_U (PERIPHS_IO_MUX + 0x18) +#define FUNC_U0TXD 0 +#define FUNC_GPIO1 3 +#define PERIPHS_IO_MUX_SD_CLK_U (PERIPHS_IO_MUX + 0x1c) +#define FUNC_SDCLK 0 +#define FUNC_SPICLK 1 +#define PERIPHS_IO_MUX_SD_DATA0_U (PERIPHS_IO_MUX + 0x20) +#define FUNC_SDDATA0 0 +#define FUNC_SPIQ 1 +#define FUNC_U1TXD 4 +#define PERIPHS_IO_MUX_SD_DATA1_U (PERIPHS_IO_MUX + 0x24) +#define FUNC_SDDATA1 0 +#define FUNC_SPID 1 +#define FUNC_U1RXD 4 +#define FUNC_SDDATA1_U1RXD 7 +#define PERIPHS_IO_MUX_SD_DATA2_U (PERIPHS_IO_MUX + 0x28) +#define FUNC_SDDATA2 0 +#define FUNC_SPIHD 1 +#define FUNC_GPIO9 3 +#define PERIPHS_IO_MUX_SD_DATA3_U (PERIPHS_IO_MUX + 0x2c) +#define FUNC_SDDATA3 0 +#define FUNC_SPIWP 1 +#define FUNC_GPIO10 3 +#define PERIPHS_IO_MUX_SD_CMD_U (PERIPHS_IO_MUX + 0x30) +#define FUNC_SDCMD 0 +#define FUNC_SPICS0 1 +#define PERIPHS_IO_MUX_GPIO0_U (PERIPHS_IO_MUX + 0x34) +#define FUNC_GPIO0 0 +#define PERIPHS_IO_MUX_GPIO2_U (PERIPHS_IO_MUX + 0x38) +#define FUNC_GPIO2 0 +#define FUNC_U1TXD_BK 2 +#define FUNC_U0TXD_BK 4 +#define PERIPHS_IO_MUX_GPIO4_U (PERIPHS_IO_MUX + 0x3C) +#define FUNC_GPIO4 0 +#define PERIPHS_IO_MUX_GPIO5_U (PERIPHS_IO_MUX + 0x40) +#define FUNC_GPIO5 0 + +#define PIN_PULLUP_DIS(PIN_NAME) CLEAR_PERI_REG_MASK(PIN_NAME, PERIPHS_IO_MUX_PULLUP) +#define PIN_PULLUP_EN(PIN_NAME) SET_PERI_REG_MASK(PIN_NAME, PERIPHS_IO_MUX_PULLUP) +#define PIN_PULLDWN_DIS(PIN_NAME) CLEAR_PERI_REG_MASK(PIN_NAME, PERIPHS_IO_MUX_PULLDWN) +#define PIN_PULLDWN_EN(PIN_NAME) SET_PERI_REG_MASK(PIN_NAME, PERIPHS_IO_MUX_PULLDWN) +#define PIN_FUNC_SELECT(PIN_NAME, FUNC) do { \ + CLEAR_PERI_REG_MASK(PIN_NAME, (PERIPHS_IO_MUX_FUNC<= GPIO_ID_PIN0) && (reg_id <= GPIO_ID_PIN(GPIO_PIN_COUNT-1))) + +#define GPIO_REGID_TO_PINIDX(reg_id) ((reg_id) - GPIO_ID_PIN0) + +typedef enum { + GPIO_PIN_INTR_DISABLE = 0, + GPIO_PIN_INTR_POSEDGE = 1, + GPIO_PIN_INTR_NEGEDGE = 2, + GPIO_PIN_INTR_ANYEGDE = 3, + GPIO_PIN_INTR_LOLEVEL = 4, + GPIO_PIN_INTR_HILEVEL = 5 +} GPIO_INT_TYPE; + +#define GPIO_OUTPUT_SET(gpio_no, bit_value) \ + gpio_output_set(bit_value<>gpio_no)&BIT0) + +/* GPIO interrupt handler, registered through gpio_intr_handler_register */ +typedef void (* gpio_intr_handler_fn_t)(uint32 intr_mask, void *arg); + + +/* + * Initialize GPIO. This includes reading the GPIO Configuration DataSet + * to initialize "output enables" and pin configurations for each gpio pin. + * Must be called once during startup. + */ +void gpio_init(void); + +/* + * Change GPIO pin output by setting, clearing, or disabling pins. + * In general, it is expected that a bit will be set in at most one + * of these masks. If a bit is clear in all masks, the output state + * remains unchanged. + * + * There is no particular ordering guaranteed; so if the order of + * writes is significant, calling code should divide a single call + * into multiple calls. + */ +void gpio_output_set(uint32 set_mask, + uint32 clear_mask, + uint32 enable_mask, + uint32 disable_mask); + +/* + * Sample the value of GPIO input pins and returns a bitmask. + */ +uint32 gpio_input_get(void); + +/* + * Set the specified GPIO register to the specified value. + * This is a very general and powerful interface that is not + * expected to be used during normal operation. It is intended + * mainly for debug, or for unusual requirements. + */ +void gpio_register_set(uint32 reg_id, uint32 value); + +/* Get the current value of the specified GPIO register. */ +uint32 gpio_register_get(uint32 reg_id); + +/* + * Register an application-specific interrupt handler for GPIO pin + * interrupts. Once the interrupt handler is called, it will not + * be called again until after a call to gpio_intr_ack. Any GPIO + * interrupts that occur during the interim are masked. + * + * The application-specific handler is called with a mask of + * pending GPIO interrupts. After processing pin interrupts, the + * application-specific handler may wish to use gpio_intr_pending + * to check for any additional pending interrupts before it returns. + */ +void gpio_intr_handler_register(gpio_intr_handler_fn_t fn, void *arg); + +/* Determine which GPIO interrupts are pending. */ +uint32 gpio_intr_pending(void); + +/* + * Acknowledge GPIO interrupts. + * Intended to be called from the gpio_intr_handler_fn. + */ +void gpio_intr_ack(uint32 ack_mask); + +void gpio_pin_wakeup_enable(uint32 i, GPIO_INT_TYPE intr_state); + +void gpio_pin_wakeup_disable(); + +void gpio_pin_intr_state_set(uint32 i, GPIO_INT_TYPE intr_state); + +#endif // _GPIO_H_ diff --git a/hardware/tools/esp8266/sdk/include/ip_addr.h b/hardware/tools/esp8266/sdk/include/ip_addr.h new file mode 100755 index 000000000..bd757a49b --- /dev/null +++ b/hardware/tools/esp8266/sdk/include/ip_addr.h @@ -0,0 +1,64 @@ +#ifndef __IP_ADDR_H__ +#define __IP_ADDR_H__ + +#include "c_types.h" + +struct ip_addr { + uint32 addr; +}; + +typedef struct ip_addr ip_addr_t; + +struct ip_info { + struct ip_addr ip; + struct ip_addr netmask; + struct ip_addr gw; +}; + +#define IP4_ADDR(ipaddr, a,b,c,d) \ + (ipaddr)->addr = ((uint32)((d) & 0xff) << 24) | \ + ((uint32)((c) & 0xff) << 16) | \ + ((uint32)((b) & 0xff) << 8) | \ + (uint32)((a) & 0xff) + +/** + * Determine if two address are on the same network. + * + * @arg addr1 IP address 1 + * @arg addr2 IP address 2 + * @arg mask network identifier mask + * @return !0 if the network identifiers of both address match + */ +#define ip_addr_netcmp(addr1, addr2, mask) (((addr1)->addr & \ + (mask)->addr) == \ + ((addr2)->addr & \ + (mask)->addr)) + +/** Set an IP address given by the four byte-parts. + Little-endian version that prevents the use of htonl. */ +#define IP4_ADDR(ipaddr, a,b,c,d) \ + (ipaddr)->addr = ((uint32)((d) & 0xff) << 24) | \ + ((uint32)((c) & 0xff) << 16) | \ + ((uint32)((b) & 0xff) << 8) | \ + (uint32)((a) & 0xff) + +#define ip4_addr1(ipaddr) (((uint8*)(ipaddr))[0]) +#define ip4_addr2(ipaddr) (((uint8*)(ipaddr))[1]) +#define ip4_addr3(ipaddr) (((uint8*)(ipaddr))[2]) +#define ip4_addr4(ipaddr) (((uint8*)(ipaddr))[3]) + +#define ip4_addr1_16(ipaddr) ((uint16)ip4_addr1(ipaddr)) +#define ip4_addr2_16(ipaddr) ((uint16)ip4_addr2(ipaddr)) +#define ip4_addr3_16(ipaddr) ((uint16)ip4_addr3(ipaddr)) +#define ip4_addr4_16(ipaddr) ((uint16)ip4_addr4(ipaddr)) + +uint32 ipaddr_addr(const char *cp); + +#define IP2STR(ipaddr) ip4_addr1_16(ipaddr), \ + ip4_addr2_16(ipaddr), \ + ip4_addr3_16(ipaddr), \ + ip4_addr4_16(ipaddr) + +#define IPSTR "%d.%d.%d.%d" + +#endif /* __IP_ADDR_H__ */ diff --git a/hardware/tools/esp8266/sdk/include/mem.h b/hardware/tools/esp8266/sdk/include/mem.h new file mode 100755 index 000000000..b3fb8f480 --- /dev/null +++ b/hardware/tools/esp8266/sdk/include/mem.h @@ -0,0 +1,12 @@ +#ifndef __MEM_H__ +#define __MEM_H__ + +//void *pvPortMalloc( size_t xWantedSize ); +//void vPortFree( void *pv ); +//void *pvPortZalloc(size_t size); + +#define os_malloc pvPortMalloc +#define os_free vPortFree +#define os_zalloc pvPortZalloc + +#endif diff --git a/hardware/tools/esp8266/sdk/include/os_type.h b/hardware/tools/esp8266/sdk/include/os_type.h new file mode 100755 index 000000000..a9901061a --- /dev/null +++ b/hardware/tools/esp8266/sdk/include/os_type.h @@ -0,0 +1,19 @@ +/* + * copyright (c) Espressif System 2010 + * + * mapping to ETS structures + * + */ +#ifndef _OS_TYPES_H_ +#define _OS_TYPES_H_ + +#include "ets_sys.h" + +#define os_signal_t ETSSignal +#define os_param_t ETSParam +#define os_event_t ETSEvent +#define os_task_t ETSTask +#define os_timer_t ETSTimer +#define os_timer_func_t ETSTimerFunc + +#endif diff --git a/hardware/tools/esp8266/sdk/include/osapi.h b/hardware/tools/esp8266/sdk/include/osapi.h new file mode 100755 index 000000000..055085f0d --- /dev/null +++ b/hardware/tools/esp8266/sdk/include/osapi.h @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2010 Espressif System + */ + +#ifndef _OSAPI_H_ +#define _OSAPI_H_ + +#include +#include "user_config.h" + +#define os_bzero ets_bzero +#define os_delay_us ets_delay_us +#define os_install_putc1 ets_install_putc1 +#define os_install_putc2 ets_install_putc2 +#define os_intr_lock ets_intr_lock +#define os_intr_unlock ets_intr_unlock +#define os_isr_attach ets_isr_attach +#define os_isr_mask ets_isr_mask +#define os_isr_unmask ets_isr_unmask +#define os_memcmp ets_memcmp +#define os_memcpy ets_memcpy +#define os_memmove ets_memmove +#define os_memset ets_memset +#define os_putc ets_putc +#define os_str2macaddr ets_str2macaddr +#define os_strcat strcat +#define os_strchr strchr +#define os_strcmp ets_strcmp +#define os_strcpy ets_strcpy +#define os_strlen ets_strlen +#define os_strncmp ets_strncmp +#define os_strncpy ets_strncpy +#define os_strstr ets_strstr +#ifdef USE_US_TIMER +#define os_timer_arm_us(a, b, c) ets_timer_arm_new(a, b, c, 0) +#endif +#define os_timer_arm(a, b, c) ets_timer_arm_new(a, b, c, 1) +#define os_timer_disarm ets_timer_disarm +#define os_timer_done ets_timer_done +#define os_timer_handler_isr ets_timer_handler_isr +#define os_timer_init ets_timer_init +#define os_timer_setfn ets_timer_setfn + +#define os_sprintf ets_sprintf +#define os_update_cpu_frequency ets_update_cpu_frequency + +#endif + diff --git a/hardware/tools/esp8266/sdk/include/queue.h b/hardware/tools/esp8266/sdk/include/queue.h new file mode 100755 index 000000000..a760c8db1 --- /dev/null +++ b/hardware/tools/esp8266/sdk/include/queue.h @@ -0,0 +1,204 @@ +#ifndef _SYS_QUEUE_H_ +#define _SYS_QUEUE_H_ + +#define QMD_SAVELINK(name, link) +#define TRASHIT(x) + +/* + * Singly-linked List declarations. + */ +#define SLIST_HEAD(name, type) \ +struct name { \ + struct type *slh_first; /* first element */ \ +} + +#define SLIST_HEAD_INITIALIZER(head) \ + { NULL } + +#define SLIST_ENTRY(type) \ +struct { \ + struct type *sle_next; /* next element */ \ +} + +/* + * Singly-linked List functions. + */ +#define SLIST_EMPTY(head) ((head)->slh_first == NULL) + +#define SLIST_FIRST(head) ((head)->slh_first) + +#define SLIST_FOREACH(var, head, field) \ + for ((var) = SLIST_FIRST((head)); \ + (var); \ + (var) = SLIST_NEXT((var), field)) + +#define SLIST_FOREACH_SAFE(var, head, field, tvar) \ + for ((var) = SLIST_FIRST((head)); \ + (var) && ((tvar) = SLIST_NEXT((var), field), 1); \ + (var) = (tvar)) + +#define SLIST_FOREACH_PREVPTR(var, varp, head, field) \ + for ((varp) = &SLIST_FIRST((head)); \ + ((var) = *(varp)) != NULL; \ + (varp) = &SLIST_NEXT((var), field)) + +#define SLIST_INIT(head) do { \ + SLIST_FIRST((head)) = NULL; \ +} while (0) + +#define SLIST_INSERT_AFTER(slistelm, elm, field) do { \ + SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field); \ + SLIST_NEXT((slistelm), field) = (elm); \ +} while (0) + +#define SLIST_INSERT_HEAD(head, elm, field) do { \ + SLIST_NEXT((elm), field) = SLIST_FIRST((head)); \ + SLIST_FIRST((head)) = (elm); \ +} while (0) + +#define SLIST_NEXT(elm, field) ((elm)->field.sle_next) + +#define SLIST_REMOVE(head, elm, type, field) do { \ + QMD_SAVELINK(oldnext, (elm)->field.sle_next); \ + if (SLIST_FIRST((head)) == (elm)) { \ + SLIST_REMOVE_HEAD((head), field); \ + } \ + else { \ + struct type *curelm = SLIST_FIRST((head)); \ + while (SLIST_NEXT(curelm, field) != (elm)) \ + curelm = SLIST_NEXT(curelm, field); \ + SLIST_REMOVE_AFTER(curelm, field); \ + } \ + TRASHIT(*oldnext); \ +} while (0) + +#define SLIST_REMOVE_AFTER(elm, field) do { \ + SLIST_NEXT(elm, field) = \ + SLIST_NEXT(SLIST_NEXT(elm, field), field); \ +} while (0) + +#define SLIST_REMOVE_HEAD(head, field) do { \ + SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field); \ +} while (0) + +/* + * Singly-linked Tail queue declarations. + */ +#define STAILQ_HEAD(name, type) \ + struct name { \ + struct type *stqh_first;/* first element */ \ + struct type **stqh_last;/* addr of last next element */ \ + } + +#define STAILQ_HEAD_INITIALIZER(head) \ + { NULL, &(head).stqh_first } + +#define STAILQ_ENTRY(type) \ + struct { \ + struct type *stqe_next; /* next element */ \ + } + +/* + * Singly-linked Tail queue functions. + */ +#define STAILQ_CONCAT(head1, head2) do { \ + if (!STAILQ_EMPTY((head2))) { \ + *(head1)->stqh_last = (head2)->stqh_first; \ + (head1)->stqh_last = (head2)->stqh_last; \ + STAILQ_INIT((head2)); \ + } \ + } while (0) + +#define STAILQ_EMPTY(head) ((head)->stqh_first == NULL) + +#define STAILQ_FIRST(head) ((head)->stqh_first) + +#define STAILQ_FOREACH(var, head, field) \ + for((var) = STAILQ_FIRST((head)); \ + (var); \ + (var) = STAILQ_NEXT((var), field)) + + +#define STAILQ_FOREACH_SAFE(var, head, field, tvar) \ + for ((var) = STAILQ_FIRST((head)); \ + (var) && ((tvar) = STAILQ_NEXT((var), field), 1); \ + (var) = (tvar)) + +#define STAILQ_INIT(head) do { \ + STAILQ_FIRST((head)) = NULL; \ + (head)->stqh_last = &STAILQ_FIRST((head)); \ + } while (0) + +#define STAILQ_INSERT_AFTER(head, tqelm, elm, field) do { \ + if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\ + (head)->stqh_last = &STAILQ_NEXT((elm), field); \ + STAILQ_NEXT((tqelm), field) = (elm); \ + } while (0) + +#define STAILQ_INSERT_HEAD(head, elm, field) do { \ + if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL) \ + (head)->stqh_last = &STAILQ_NEXT((elm), field); \ + STAILQ_FIRST((head)) = (elm); \ + } while (0) + +#define STAILQ_INSERT_TAIL(head, elm, field) do { \ + STAILQ_NEXT((elm), field) = NULL; \ + *(head)->stqh_last = (elm); \ + (head)->stqh_last = &STAILQ_NEXT((elm), field); \ + } while (0) + +#define STAILQ_LAST(head, type, field) \ + (STAILQ_EMPTY((head)) ? \ + NULL : \ + ((struct type *)(void *) \ + ((char *)((head)->stqh_last) - __offsetof(struct type, field)))) + +#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next) + +#define STAILQ_REMOVE(head, elm, type, field) do { \ + QMD_SAVELINK(oldnext, (elm)->field.stqe_next); \ + if (STAILQ_FIRST((head)) == (elm)) { \ + STAILQ_REMOVE_HEAD((head), field); \ + } \ + else { \ + struct type *curelm = STAILQ_FIRST((head)); \ + while (STAILQ_NEXT(curelm, field) != (elm)) \ + curelm = STAILQ_NEXT(curelm, field); \ + STAILQ_REMOVE_AFTER(head, curelm, field); \ + } \ + TRASHIT(*oldnext); \ + } while (0) + +#define STAILQ_REMOVE_HEAD(head, field) do { \ + if ((STAILQ_FIRST((head)) = \ + STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL) \ + (head)->stqh_last = &STAILQ_FIRST((head)); \ + } while (0) + +#define STAILQ_REMOVE_AFTER(head, elm, field) do { \ + if ((STAILQ_NEXT(elm, field) = \ + STAILQ_NEXT(STAILQ_NEXT(elm, field), field)) == NULL) \ + (head)->stqh_last = &STAILQ_NEXT((elm), field); \ + } while (0) + +#define STAILQ_SWAP(head1, head2, type) do { \ + struct type *swap_first = STAILQ_FIRST(head1); \ + struct type **swap_last = (head1)->stqh_last; \ + STAILQ_FIRST(head1) = STAILQ_FIRST(head2); \ + (head1)->stqh_last = (head2)->stqh_last; \ + STAILQ_FIRST(head2) = swap_first; \ + (head2)->stqh_last = swap_last; \ + if (STAILQ_EMPTY(head1)) \ + (head1)->stqh_last = &STAILQ_FIRST(head1); \ + if (STAILQ_EMPTY(head2)) \ + (head2)->stqh_last = &STAILQ_FIRST(head2); \ + } while (0) + +#define STAILQ_INSERT_CHAIN_HEAD(head, elm_chead, elm_ctail, field) do { \ + if ((STAILQ_NEXT(elm_ctail, field) = STAILQ_FIRST(head)) == NULL ) { \ + (head)->stqh_last = &STAILQ_NEXT(elm_ctail, field); \ + } \ + STAILQ_FIRST(head) = (elm_chead); \ + } while (0) + +#endif /* !_SYS_QUEUE_H_ */ diff --git a/hardware/tools/esp8266/sdk/include/spi_flash.h b/hardware/tools/esp8266/sdk/include/spi_flash.h new file mode 100755 index 000000000..9dbe10a27 --- /dev/null +++ b/hardware/tools/esp8266/sdk/include/spi_flash.h @@ -0,0 +1,30 @@ +/* + * copyright (c) Espressif System 2010 + * + */ + +#ifndef SPI_FLASH_H +#define SPI_FLASH_H + +typedef enum { + SPI_FLASH_RESULT_OK, + SPI_FLASH_RESULT_ERR, + SPI_FLASH_RESULT_TIMEOUT +} SpiFlashOpResult; + +typedef struct{ + uint32 deviceId; + uint32 chip_size; // chip size in byte + uint32 block_size; + uint32 sector_size; + uint32 page_size; + uint32 status_mask; +} SpiFlashChip; + +#define SPI_FLASH_SEC_SIZE 4096 + +SpiFlashOpResult spi_flash_erase_sector(uint16 sec); +SpiFlashOpResult spi_flash_write(uint32 des_addr, uint32 *src_addr, uint32 size); +SpiFlashOpResult spi_flash_read(uint32 src_addr, uint32 *des_addr, uint32 size); + +#endif diff --git a/hardware/tools/esp8266/sdk/include/uart_register.h b/hardware/tools/esp8266/sdk/include/uart_register.h new file mode 100755 index 000000000..6398879ee --- /dev/null +++ b/hardware/tools/esp8266/sdk/include/uart_register.h @@ -0,0 +1,128 @@ +//Generated at 2012-07-03 18:44:06 +/* + * Copyright (c) 2010 - 2011 Espressif System + * + */ + +#ifndef UART_REGISTER_H_INCLUDED +#define UART_REGISTER_H_INCLUDED +#define REG_UART_BASE( i ) (0x60000000+(i)*0xf00) +//version value:32'h062000 + +#define UART_FIFO( i ) (REG_UART_BASE( i ) + 0x0) +#define UART_RXFIFO_RD_BYTE 0x000000FF +#define UART_RXFIFO_RD_BYTE_S 0 + +#define UART_INT_RAW( i ) (REG_UART_BASE( i ) + 0x4) +#define UART_RXFIFO_TOUT_INT_RAW (BIT(8)) +#define UART_BRK_DET_INT_RAW (BIT(7)) +#define UART_CTS_CHG_INT_RAW (BIT(6)) +#define UART_DSR_CHG_INT_RAW (BIT(5)) +#define UART_RXFIFO_OVF_INT_RAW (BIT(4)) +#define UART_FRM_ERR_INT_RAW (BIT(3)) +#define UART_PARITY_ERR_INT_RAW (BIT(2)) +#define UART_TXFIFO_EMPTY_INT_RAW (BIT(1)) +#define UART_RXFIFO_FULL_INT_RAW (BIT(0)) + +#define UART_INT_ST( i ) (REG_UART_BASE( i ) + 0x8) +#define UART_RXFIFO_TOUT_INT_ST (BIT(8)) +#define UART_BRK_DET_INT_ST (BIT(7)) +#define UART_CTS_CHG_INT_ST (BIT(6)) +#define UART_DSR_CHG_INT_ST (BIT(5)) +#define UART_RXFIFO_OVF_INT_ST (BIT(4)) +#define UART_FRM_ERR_INT_ST (BIT(3)) +#define UART_PARITY_ERR_INT_ST (BIT(2)) +#define UART_TXFIFO_EMPTY_INT_ST (BIT(1)) +#define UART_RXFIFO_FULL_INT_ST (BIT(0)) + +#define UART_INT_ENA( i ) (REG_UART_BASE( i ) + 0xC) +#define UART_RXFIFO_TOUT_INT_ENA (BIT(8)) +#define UART_BRK_DET_INT_ENA (BIT(7)) +#define UART_CTS_CHG_INT_ENA (BIT(6)) +#define UART_DSR_CHG_INT_ENA (BIT(5)) +#define UART_RXFIFO_OVF_INT_ENA (BIT(4)) +#define UART_FRM_ERR_INT_ENA (BIT(3)) +#define UART_PARITY_ERR_INT_ENA (BIT(2)) +#define UART_TXFIFO_EMPTY_INT_ENA (BIT(1)) +#define UART_RXFIFO_FULL_INT_ENA (BIT(0)) + +#define UART_INT_CLR( i ) (REG_UART_BASE( i ) + 0x10) +#define UART_RXFIFO_TOUT_INT_CLR (BIT(8)) +#define UART_BRK_DET_INT_CLR (BIT(7)) +#define UART_CTS_CHG_INT_CLR (BIT(6)) +#define UART_DSR_CHG_INT_CLR (BIT(5)) +#define UART_RXFIFO_OVF_INT_CLR (BIT(4)) +#define UART_FRM_ERR_INT_CLR (BIT(3)) +#define UART_PARITY_ERR_INT_CLR (BIT(2)) +#define UART_TXFIFO_EMPTY_INT_CLR (BIT(1)) +#define UART_RXFIFO_FULL_INT_CLR (BIT(0)) + +#define UART_CLKDIV( i ) (REG_UART_BASE( i ) + 0x14) +#define UART_CLKDIV_CNT 0x000FFFFF +#define UART_CLKDIV_S 0 + +#define UART_AUTOBAUD( i ) (REG_UART_BASE( i ) + 0x18) +#define UART_GLITCH_FILT 0x000000FF +#define UART_GLITCH_FILT_S 8 +#define UART_AUTOBAUD_EN (BIT(0)) + +#define UART_STATUS( i ) (REG_UART_BASE( i ) + 0x1C) +#define UART_TXD (BIT(31)) +#define UART_RTSN (BIT(30)) +#define UART_DTRN (BIT(29)) +#define UART_TXFIFO_CNT 0x000000FF +#define UART_TXFIFO_CNT_S 16 +#define UART_RXD (BIT(15)) +#define UART_CTSN (BIT(14)) +#define UART_DSRN (BIT(13)) +#define UART_RXFIFO_CNT 0x000000FF +#define UART_RXFIFO_CNT_S 0 + +#define UART_CONF0( i ) (REG_UART_BASE( i ) + 0x20) +#define UART_TXFIFO_RST (BIT(18)) +#define UART_RXFIFO_RST (BIT(17)) +#define UART_IRDA_EN (BIT(16)) +#define UART_TX_FLOW_EN (BIT(15)) +#define UART_LOOPBACK (BIT(14)) +#define UART_IRDA_RX_INV (BIT(13)) +#define UART_IRDA_TX_INV (BIT(12)) +#define UART_IRDA_WCTL (BIT(11)) +#define UART_IRDA_TX_EN (BIT(10)) +#define UART_IRDA_DPLX (BIT(9)) +#define UART_TXD_BRK (BIT(8)) +#define UART_SW_DTR (BIT(7)) +#define UART_SW_RTS (BIT(6)) +#define UART_STOP_BIT_NUM 0x00000003 +#define UART_STOP_BIT_NUM_S 4 +#define UART_BIT_NUM 0x00000003 +#define UART_BIT_NUM_S 2 +#define UART_PARITY_EN (BIT(1)) +#define UART_PARITY (BIT(0)) + +#define UART_CONF1( i ) (REG_UART_BASE( i ) + 0x24) +#define UART_RX_TOUT_EN (BIT(31)) +#define UART_RX_TOUT_THRHD 0x0000007F +#define UART_RX_TOUT_THRHD_S 24 +#define UART_RX_FLOW_EN (BIT(23)) +#define UART_RX_FLOW_THRHD 0x0000007F +#define UART_RX_FLOW_THRHD_S 16 +#define UART_TXFIFO_EMPTY_THRHD 0x0000007F +#define UART_TXFIFO_EMPTY_THRHD_S 8 +#define UART_RXFIFO_FULL_THRHD 0x0000007F +#define UART_RXFIFO_FULL_THRHD_S 0 + +#define UART_LOWPULSE( i ) (REG_UART_BASE( i ) + 0x28) +#define UART_LOWPULSE_MIN_CNT 0x000FFFFF +#define UART_LOWPULSE_MIN_CNT_S 0 + +#define UART_HIGHPULSE( i ) (REG_UART_BASE( i ) + 0x2C) +#define UART_HIGHPULSE_MIN_CNT 0x000FFFFF +#define UART_HIGHPULSE_MIN_CNT_S 0 + +#define UART_PULSE_NUM( i ) (REG_UART_BASE( i ) + 0x30) +#define UART_PULSE_NUM_CNT 0x0003FF +#define UART_PULSE_NUM_CNT_S 0 + +#define UART_DATE( i ) (REG_UART_BASE( i ) + 0x78) +#define UART_ID( i ) (REG_UART_BASE( i ) + 0x7C) +#endif // UART_REGISTER_H_INCLUDED diff --git a/hardware/tools/esp8266/sdk/include/user_interface.h b/hardware/tools/esp8266/sdk/include/user_interface.h new file mode 100755 index 000000000..28a9391b9 --- /dev/null +++ b/hardware/tools/esp8266/sdk/include/user_interface.h @@ -0,0 +1,201 @@ +/* + * Copyright (C) 2013 -2014 Espressif System + * + */ + +#ifndef __USER_INTERFACE_H__ +#define __USER_INTERFACE_H__ + +#include "os_type.h" +#ifdef LWIP_OPEN_SRC +#include "lwip/ip_addr.h" +#else +#include "ip_addr.h" +#endif + +#include "queue.h" +#include "user_config.h" +#include "spi_flash.h" + +#ifndef MAC2STR +#define MAC2STR(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5] +#define MACSTR "%02x:%02x:%02x:%02x:%02x:%02x" +#endif + +#define UPGRADE_FW_BIN1 0x00 +#define UPGRADE_FW_BIN2 0x01 + +typedef void (*upgrade_states_check_callback)(void * arg); + +struct upgrade_server_info { + uint8 ip[4]; + uint16 port; + + uint8 upgrade_flag; + + uint8 pre_version[8]; + uint8 upgrade_version[8]; + + uint32 check_times; + uint8 *url; + + upgrade_states_check_callback check_cb; + struct espconn *pespconn; +}; + +bool system_upgrade_start(struct upgrade_server_info *server); +bool system_upgrade_start_ssl(struct upgrade_server_info *server); +uint8 system_upgrade_userbin_check(void); +void system_upgrade_reboot(void); + +void system_restore(void); +void system_restart(void); +void system_deep_sleep(uint32 time_in_us); + +void system_timer_reinit(void); +uint32 system_get_time(void); + +/* user task's prio must be 0/1/2 !!!*/ +enum { + USER_TASK_PRIO_0 = 0, + USER_TASK_PRIO_1, + USER_TASK_PRIO_2, + USER_TASK_PRIO_MAX +}; + +void system_os_task(os_task_t task, uint8 prio, os_event_t *queue, uint8 qlen); +void system_os_post(uint8 prio, os_signal_t sig, os_param_t par); + +void system_print_meminfo(void); +uint32 system_get_free_heap_size(void); + +void system_set_os_print(uint8 onoff); + +uint64 system_mktime(uint32 year, uint32 mon, uint32 day, uint32 hour, uint32 min, uint32 sec); + +uint32 system_get_chip_id(void); + +typedef void (* init_done_cb_t)(void); + +void system_init_done_cb(init_done_cb_t cb); + +#define NULL_MODE 0x00 +#define STATION_MODE 0x01 +#define SOFTAP_MODE 0x02 +#define STATIONAP_MODE 0x03 + +uint8 wifi_get_opmode(void); +bool wifi_set_opmode(uint8 opmode); + +struct bss_info { + STAILQ_ENTRY(bss_info) next; + + u8 bssid[6]; + u8 ssid[32]; + u8 channel; + s8 rssi; + u8 authmode; +}; + +typedef struct _scaninfo { + STAILQ_HEAD(, bss_info) *pbss; + struct espconn *pespconn; + u8 totalpage; + u8 pagenum; + u8 page_sn; + u8 data_cnt; +} scaninfo; + +typedef void (* scan_done_cb_t)(void *arg, STATUS status); + +struct station_config { + uint8 ssid[32]; + uint8 password[64]; +}; + +bool wifi_station_get_config(struct station_config *config); +bool wifi_station_set_config(struct station_config *config); + +bool wifi_station_connect(void); +bool wifi_station_disconnect(void); + +struct scan_config { + uint8 *ssid; + uint8 *bssid; + uint8 channel; +}; + +bool wifi_station_scan(struct scan_config *config, scan_done_cb_t cb); + +uint8 wifi_station_get_auto_connect(void); +bool wifi_station_set_auto_connect(uint8 set); + +enum { + STATION_IDLE = 0, + STATION_CONNECTING, + STATION_WRONG_PASSWORD, + STATION_NO_AP_FOUND, + STATION_CONNECT_FAIL, + STATION_GOT_IP +}; + +uint8 wifi_station_get_connect_status(void); + +typedef enum _auth_mode { + AUTH_OPEN = 0, + AUTH_WEP, + AUTH_WPA_PSK, + AUTH_WPA2_PSK, + AUTH_WPA_WPA2_PSK +} AUTH_MODE; + +struct softap_config { + uint8 ssid[32]; + uint8 password[64]; + uint8 channel; + uint8 authmode; + uint8 ssid_hidden; + uint8 max_connection; +}; + +bool wifi_softap_get_config(struct softap_config *config); +bool wifi_softap_set_config(struct softap_config *config); + +struct station_info { + STAILQ_ENTRY(station_info) next; + + uint8 bssid[6]; + struct ip_addr ip; +}; + +struct station_info * wifi_softap_get_station_info(void); +void wifi_softap_free_station_info(void); + +#define STATION_IF 0x00 +#define SOFTAP_IF 0x01 + +bool wifi_get_ip_info(uint8 if_index, struct ip_info *info); +bool wifi_set_ip_info(uint8 if_index, struct ip_info *info); +bool wifi_get_macaddr(uint8 if_index, uint8 *macaddr); +bool wifi_set_macaddr(uint8 if_index, uint8 *macaddr); + +uint8 wifi_get_channel(void); +bool wifi_set_channel(uint8 channel); + +void wifi_status_led_install(uint8 gpio_id, uint32 gpio_name, uint8 gpio_func); + +/** Get the absolute difference between 2 u32_t values (correcting overflows) + * 'a' is expected to be 'higher' (without overflow) than 'b'. */ +#define ESP_U32_DIFF(a, b) (((a) >= (b)) ? ((a) - (b)) : (((a) + ((b) ^ 0xFFFFFFFF) + 1))) + +void wifi_promiscuous_enable(uint8 promiscuous); + +typedef void (* wifi_promiscuous_cb_t)(uint8 *buf, uint16 len); + +void wifi_set_promiscuous_rx_cb(wifi_promiscuous_cb_t cb); + +uint8 wifi_station_get_current_ap_id(void); +bool wifi_station_ap_change(uint8 current_ap_id); +bool wifi_station_ap_number_set(uint8 ap_number); + +#endif diff --git a/hardware/tools/esp8266/sdk/include/version.h b/hardware/tools/esp8266/sdk/include/version.h new file mode 100755 index 000000000..4d13b458f --- /dev/null +++ b/hardware/tools/esp8266/sdk/include/version.h @@ -0,0 +1,12 @@ +#ifndef __SDK_VERSION_H__ +#define __SDK_VERSION_H__ + +#define SDK_VERSION_MAJOR 0U +#define SDK_VERSION_MINOR 9U +#define SDK_VERSION_REVISION 2U +#define SDK_VERSION_INTERNAL 0U + +#define SDK_VERSION (SDK_VERSION_MAJOR << 16 | SDK_VERSION_MINOR << 8 | SDK_VERSION_REVISION) + +#endif + diff --git a/hardware/tools/esp8266/sdk/ld/eagle.app.v6.ld b/hardware/tools/esp8266/sdk/ld/eagle.app.v6.ld new file mode 100755 index 000000000..69dcad2c8 --- /dev/null +++ b/hardware/tools/esp8266/sdk/ld/eagle.app.v6.ld @@ -0,0 +1,181 @@ +/* This linker script generated from xt-genldscripts.tpp for LSP . */ +/* Linker Script for ld -N */ +MEMORY +{ + dport0_0_seg : org = 0x3FF00000, len = 0x10 + dram0_0_seg : org = 0x3FFE8000, len = 0x14000 + iram1_0_seg : org = 0x40100000, len = 0x8000 + irom0_0_seg : org = 0x40240000, len = 0x32000 +} + +PHDRS +{ + dport0_0_phdr PT_LOAD; + dram0_0_phdr PT_LOAD; + dram0_0_bss_phdr PT_LOAD; + iram1_0_phdr PT_LOAD; + irom0_0_phdr PT_LOAD; +} + + +/* Default entry point: */ +ENTRY(call_user_start) +PROVIDE(_memmap_vecbase_reset = 0x40000000); +/* Various memory-map dependent cache attribute settings: */ +_memmap_cacheattr_wb_base = 0x00000110; +_memmap_cacheattr_wt_base = 0x00000110; +_memmap_cacheattr_bp_base = 0x00000220; +_memmap_cacheattr_unused_mask = 0xFFFFF00F; +_memmap_cacheattr_wb_trapnull = 0x2222211F; +_memmap_cacheattr_wba_trapnull = 0x2222211F; +_memmap_cacheattr_wbna_trapnull = 0x2222211F; +_memmap_cacheattr_wt_trapnull = 0x2222211F; +_memmap_cacheattr_bp_trapnull = 0x2222222F; +_memmap_cacheattr_wb_strict = 0xFFFFF11F; +_memmap_cacheattr_wt_strict = 0xFFFFF11F; +_memmap_cacheattr_bp_strict = 0xFFFFF22F; +_memmap_cacheattr_wb_allvalid = 0x22222112; +_memmap_cacheattr_wt_allvalid = 0x22222112; +_memmap_cacheattr_bp_allvalid = 0x22222222; +PROVIDE(_memmap_cacheattr_reset = _memmap_cacheattr_wb_trapnull); + +SECTIONS +{ + + .dport0.rodata : ALIGN(4) + { + _dport0_rodata_start = ABSOLUTE(.); + *(.dport0.rodata) + *(.dport.rodata) + _dport0_rodata_end = ABSOLUTE(.); + } >dport0_0_seg :dport0_0_phdr + + .dport0.literal : ALIGN(4) + { + _dport0_literal_start = ABSOLUTE(.); + *(.dport0.literal) + *(.dport.literal) + _dport0_literal_end = ABSOLUTE(.); + } >dport0_0_seg :dport0_0_phdr + + .dport0.data : ALIGN(4) + { + _dport0_data_start = ABSOLUTE(.); + *(.dport0.data) + *(.dport.data) + _dport0_data_end = ABSOLUTE(.); + } >dport0_0_seg :dport0_0_phdr + + .data : ALIGN(4) + { + _data_start = ABSOLUTE(.); + *(.data) + *(.data.*) + *(.gnu.linkonce.d.*) + *(.data1) + *(.sdata) + *(.sdata.*) + *(.gnu.linkonce.s.*) + *(.sdata2) + *(.sdata2.*) + *(.gnu.linkonce.s2.*) + *(.jcr) + _data_end = ABSOLUTE(.); + } >dram0_0_seg :dram0_0_phdr + + .rodata : ALIGN(4) + { + _rodata_start = ABSOLUTE(.); + *(.rodata) + *(.rodata.*) + *(.gnu.linkonce.r.*) + *(.rodata1) + __XT_EXCEPTION_TABLE__ = ABSOLUTE(.); + *(.xt_except_table) + *(.gcc_except_table) + *(.gnu.linkonce.e.*) + *(.gnu.version_r) + *(.eh_frame) + /* C++ constructor and destructor tables, properly ordered: */ + KEEP (*crtbegin.o(.ctors)) + KEEP (*(EXCLUDE_FILE (*crtend.o) .ctors)) + KEEP (*(SORT(.ctors.*))) + KEEP (*(.ctors)) + KEEP (*crtbegin.o(.dtors)) + KEEP (*(EXCLUDE_FILE (*crtend.o) .dtors)) + KEEP (*(SORT(.dtors.*))) + KEEP (*(.dtors)) + /* C++ exception handlers table: */ + __XT_EXCEPTION_DESCS__ = ABSOLUTE(.); + *(.xt_except_desc) + *(.gnu.linkonce.h.*) + __XT_EXCEPTION_DESCS_END__ = ABSOLUTE(.); + *(.xt_except_desc_end) + *(.dynamic) + *(.gnu.version_d) + . = ALIGN(4); /* this table MUST be 4-byte aligned */ + _bss_table_start = ABSOLUTE(.); + LONG(_bss_start) + LONG(_bss_end) + _bss_table_end = ABSOLUTE(.); + _rodata_end = ABSOLUTE(.); + } >dram0_0_seg :dram0_0_phdr + + .bss ALIGN(8) (NOLOAD) : ALIGN(4) + { + . = ALIGN (8); + _bss_start = ABSOLUTE(.); + *(.dynsbss) + *(.sbss) + *(.sbss.*) + *(.gnu.linkonce.sb.*) + *(.scommon) + *(.sbss2) + *(.sbss2.*) + *(.gnu.linkonce.sb2.*) + *(.dynbss) + *(.bss) + *(.bss.*) + *(.gnu.linkonce.b.*) + *(COMMON) + . = ALIGN (8); + _bss_end = ABSOLUTE(.); + _heap_start = ABSOLUTE(.); +/* _stack_sentry = ALIGN(0x8); */ + } >dram0_0_seg :dram0_0_bss_phdr +/* __stack = 0x3ffc8000; */ + + .text : ALIGN(4) + { + _stext = .; + _text_start = ABSOLUTE(.); + *(.entry.text) + *(.init.literal) + *(.init) + *(.literal .text .literal.* .text.* .stub .gnu.warning .gnu.linkonce.literal.* .gnu.linkonce.t.*.literal .gnu.linkonce.t.*) + *(.fini.literal) + *(.fini) + *(.gnu.version) + _text_end = ABSOLUTE(.); + _etext = .; + } >iram1_0_seg :iram1_0_phdr + + .lit4 : ALIGN(4) + { + _lit4_start = ABSOLUTE(.); + *(*.lit4) + *(.lit4.*) + *(.gnu.linkonce.lit4.*) + _lit4_end = ABSOLUTE(.); + } >iram1_0_seg :iram1_0_phdr + + .irom0.text : ALIGN(4) + { + _irom0_text_start = ABSOLUTE(.); + *(.irom0.literal .irom.literal .irom.text.literal .irom0.text .irom.text) + _irom0_text_end = ABSOLUTE(.); + } >irom0_0_seg :irom0_0_phdr +} + +/* get ROM code address */ +INCLUDE "../ld/eagle.rom.addr.v6.ld" diff --git a/hardware/tools/esp8266/sdk/ld/eagle.rom.addr.v6.ld b/hardware/tools/esp8266/sdk/ld/eagle.rom.addr.v6.ld new file mode 100755 index 000000000..c1c5405eb --- /dev/null +++ b/hardware/tools/esp8266/sdk/ld/eagle.rom.addr.v6.ld @@ -0,0 +1,343 @@ +PROVIDE ( Cache_Read_Disable = 0x400047f0 ); +PROVIDE ( Cache_Read_Enable = 0x40004678 ); +PROVIDE ( FilePacketSendReqMsgProc = 0x400035a0 ); +PROVIDE ( FlashDwnLdParamCfgMsgProc = 0x4000368c ); +PROVIDE ( FlashDwnLdStartMsgProc = 0x40003538 ); +PROVIDE ( FlashDwnLdStopReqMsgProc = 0x40003658 ); +PROVIDE ( GetUartDevice = 0x40003f4c ); +PROVIDE ( MD5Final = 0x40009900 ); +PROVIDE ( MD5Init = 0x40009818 ); +PROVIDE ( MD5Update = 0x40009834 ); +PROVIDE ( MemDwnLdStartMsgProc = 0x400036c4 ); +PROVIDE ( MemDwnLdStopReqMsgProc = 0x4000377c ); +PROVIDE ( MemPacketSendReqMsgProc = 0x400036f0 ); +PROVIDE ( RcvMsg = 0x40003eac ); +PROVIDE ( SHA1Final = 0x4000b648 ); +PROVIDE ( SHA1Init = 0x4000b584 ); +PROVIDE ( SHA1Transform = 0x4000a364 ); +PROVIDE ( SHA1Update = 0x4000b5a8 ); +PROVIDE ( SPIEraseArea = 0x40004b44 ); +PROVIDE ( SPIEraseBlock = 0x400049b4 ); +PROVIDE ( SPIEraseChip = 0x40004984 ); +PROVIDE ( SPIEraseSector = 0x40004a00 ); +PROVIDE ( SPILock = 0x400048a8 ); +PROVIDE ( SPIParamCfg = 0x40004c2c ); +PROVIDE ( SPIRead = 0x40004b1c ); +PROVIDE ( SPIReadModeCnfig = 0x400048ec ); +PROVIDE ( SPIUnlock = 0x40004878 ); +PROVIDE ( SPIWrite = 0x40004a4c ); +PROVIDE ( SelectSpiFunction = 0x40003f58 ); +PROVIDE ( SendMsg = 0x40003cf4 ); +PROVIDE ( UartConnCheck = 0x40003230 ); +PROVIDE ( UartConnectProc = 0x400037a0 ); +PROVIDE ( UartDwnLdProc = 0x40003368 ); +PROVIDE ( UartGetCmdLn = 0x40003ef4 ); +PROVIDE ( UartRegReadProc = 0x4000381c ); +PROVIDE ( UartRegWriteProc = 0x400037ac ); +PROVIDE ( UartRxString = 0x40003c30 ); +PROVIDE ( Uart_Init = 0x40003a14 ); +PROVIDE ( _DebugExceptionVector = 0x40000010 ); +PROVIDE ( _DoubleExceptionVector = 0x40000070 ); +PROVIDE ( _KernelExceptionVector = 0x40000030 ); +PROVIDE ( _NMIExceptionVector = 0x40000020 ); +PROVIDE ( _ResetHandler = 0x400000a4 ); +PROVIDE ( _ResetVector = 0x40000080 ); +PROVIDE ( _UserExceptionVector = 0x40000050 ); +PROVIDE ( __adddf3 = 0x4000c538 ); +PROVIDE ( __addsf3 = 0x4000c180 ); +PROVIDE ( __divdf3 = 0x4000cb94 ); +PROVIDE ( __divdi3 = 0x4000ce60 ); +PROVIDE ( __divsi3 = 0x4000dc88 ); +PROVIDE ( __extendsfdf2 = 0x4000cdfc ); +PROVIDE ( __fixdfsi = 0x4000ccb8 ); +PROVIDE ( __fixunsdfsi = 0x4000cd00 ); +PROVIDE ( __fixunssfsi = 0x4000c4c4 ); +PROVIDE ( __floatsidf = 0x4000e2f0 ); +PROVIDE ( __floatsisf = 0x4000e2ac ); +PROVIDE ( __floatunsidf = 0x4000e2e8 ); +PROVIDE ( __floatunsisf = 0x4000e2a4 ); +PROVIDE ( __muldf3 = 0x4000c8f0 ); +PROVIDE ( __muldi3 = 0x40000650 ); +PROVIDE ( __mulsf3 = 0x4000c3dc ); +PROVIDE ( __subdf3 = 0x4000c688 ); +PROVIDE ( __subsf3 = 0x4000c268 ); +PROVIDE ( __truncdfsf2 = 0x4000cd5c ); +PROVIDE ( __udivdi3 = 0x4000d310 ); +PROVIDE ( __udivsi3 = 0x4000e21c ); +PROVIDE ( __umoddi3 = 0x4000d770 ); +PROVIDE ( __umodsi3 = 0x4000e268 ); +PROVIDE ( __umulsidi3 = 0x4000dcf0 ); +PROVIDE ( _rom_store = 0x4000e388 ); +PROVIDE ( _rom_store_table = 0x4000e328 ); +PROVIDE ( _start = 0x4000042c ); +PROVIDE ( _xtos_alloca_handler = 0x4000dbe0 ); +PROVIDE ( _xtos_c_wrapper_handler = 0x40000598 ); +PROVIDE ( _xtos_cause3_handler = 0x40000590 ); +PROVIDE ( _xtos_ints_off = 0x4000bda4 ); +PROVIDE ( _xtos_ints_on = 0x4000bd84 ); +PROVIDE ( _xtos_l1int_handler = 0x4000048c ); +PROVIDE ( _xtos_p_none = 0x4000dbf8 ); +PROVIDE ( _xtos_restore_intlevel = 0x4000056c ); +PROVIDE ( _xtos_return_from_exc = 0x4000dc54 ); +PROVIDE ( _xtos_set_exception_handler = 0x40000454 ); +PROVIDE ( _xtos_set_interrupt_handler = 0x4000bd70 ); +PROVIDE ( _xtos_set_interrupt_handler_arg = 0x4000bd28 ); +PROVIDE ( _xtos_set_intlevel = 0x4000dbfc ); +PROVIDE ( _xtos_set_min_intlevel = 0x4000dc18 ); +PROVIDE ( _xtos_set_vpri = 0x40000574 ); +PROVIDE ( _xtos_syscall_handler = 0x4000dbe4 ); +PROVIDE ( _xtos_unhandled_exception = 0x4000dc44 ); +PROVIDE ( _xtos_unhandled_interrupt = 0x4000dc3c ); +PROVIDE ( aes_decrypt = 0x400092d4 ); +PROVIDE ( aes_decrypt_deinit = 0x400092e4 ); +PROVIDE ( aes_decrypt_init = 0x40008ea4 ); +PROVIDE ( aes_unwrap = 0x40009410 ); +PROVIDE ( base64_decode = 0x40009648 ); +PROVIDE ( base64_encode = 0x400094fc ); +PROVIDE ( bzero = 0x4000de84 ); +PROVIDE ( cmd_parse = 0x40000814 ); +PROVIDE ( conv_str_decimal = 0x40000b24 ); +PROVIDE ( conv_str_hex = 0x40000cb8 ); +PROVIDE ( convert_para_str = 0x40000a60 ); +PROVIDE ( dtm_get_intr_mask = 0x400026d0 ); +PROVIDE ( dtm_params_init = 0x4000269c ); +PROVIDE ( dtm_set_intr_mask = 0x400026c8 ); +PROVIDE ( dtm_set_params = 0x400026dc ); +PROVIDE ( eprintf = 0x40001d14 ); +PROVIDE ( eprintf_init_buf = 0x40001cb8 ); +PROVIDE ( eprintf_to_host = 0x40001d48 ); +PROVIDE ( est_get_printf_buf_remain_len = 0x40002494 ); +PROVIDE ( est_reset_printf_buf_len = 0x4000249c ); +PROVIDE ( ets_bzero = 0x40002ae8 ); +PROVIDE ( ets_char2xdigit = 0x40002b74 ); +PROVIDE ( ets_delay_us = 0x40002ecc ); +PROVIDE ( ets_enter_sleep = 0x400027b8 ); +PROVIDE ( ets_external_printf = 0x40002578 ); +PROVIDE ( ets_get_cpu_frequency = 0x40002f0c ); +PROVIDE ( ets_getc = 0x40002bcc ); +PROVIDE ( ets_install_external_printf = 0x40002450 ); +PROVIDE ( ets_install_putc1 = 0x4000242c ); +PROVIDE ( ets_install_putc2 = 0x4000248c ); +PROVIDE ( ets_install_uart_printf = 0x40002438 ); +PROVIDE ( ets_intr_lock = 0x40000f74 ); +PROVIDE ( ets_intr_unlock = 0x40000f80 ); +PROVIDE ( ets_isr_attach = 0x40000f88 ); +PROVIDE ( ets_isr_mask = 0x40000f98 ); +PROVIDE ( ets_isr_unmask = 0x40000fa8 ); +PROVIDE ( ets_memcmp = 0x400018d4 ); +PROVIDE ( ets_memcpy = 0x400018b4 ); +PROVIDE ( ets_memmove = 0x400018c4 ); +PROVIDE ( ets_memset = 0x400018a4 ); +PROVIDE ( ets_post = 0x40000e24 ); +PROVIDE ( ets_printf = 0x400024cc ); +PROVIDE ( ets_putc = 0x40002be8 ); +PROVIDE ( ets_rtc_int_register = 0x40002a40 ); +PROVIDE ( ets_run = 0x40000e04 ); +PROVIDE ( ets_set_idle_cb = 0x40000dc0 ); +PROVIDE ( ets_set_user_start = 0x40000fbc ); +PROVIDE ( ets_str2macaddr = 0x40002af8 ); +PROVIDE ( ets_strcmp = 0x40002aa8 ); +PROVIDE ( ets_strcpy = 0x40002a88 ); +PROVIDE ( ets_strlen = 0x40002ac8 ); +PROVIDE ( ets_strncmp = 0x40002ab8 ); +PROVIDE ( ets_strncpy = 0x40002a98 ); +PROVIDE ( ets_strstr = 0x40002ad8 ); +PROVIDE ( ets_task = 0x40000dd0 ); +PROVIDE ( ets_timer_arm = 0x40002cc4 ); +PROVIDE ( ets_timer_disarm = 0x40002d40 ); +PROVIDE ( ets_timer_done = 0x40002d80 ); +PROVIDE ( ets_timer_handler_isr = 0x40002da8 ); +PROVIDE ( ets_timer_init = 0x40002e68 ); +PROVIDE ( ets_timer_setfn = 0x40002c48 ); +PROVIDE ( ets_uart_printf = 0x40002544 ); +PROVIDE ( ets_update_cpu_frequency = 0x40002f04 ); +PROVIDE ( ets_vprintf = 0x40001f00 ); +PROVIDE ( ets_wdt_disable = 0x400030f0 ); +PROVIDE ( ets_wdt_enable = 0x40002fa0 ); +PROVIDE ( ets_wdt_get_mode = 0x40002f34 ); +PROVIDE ( ets_wdt_init = 0x40003170 ); +PROVIDE ( ets_wdt_restore = 0x40003158 ); +PROVIDE ( ets_write_char = 0x40001da0 ); +PROVIDE ( get_first_seg = 0x4000091c ); +PROVIDE ( gpio_init = 0x40004c50 ); +PROVIDE ( gpio_input_get = 0x40004cf0 ); +PROVIDE ( gpio_intr_ack = 0x40004dcc ); +PROVIDE ( gpio_intr_handler_register = 0x40004e28 ); +PROVIDE ( gpio_intr_pending = 0x40004d88 ); +PROVIDE ( gpio_intr_test = 0x40004efc ); +PROVIDE ( gpio_output_set = 0x40004cd0 ); +PROVIDE ( gpio_pin_intr_state_set = 0x40004d90 ); +PROVIDE ( gpio_pin_wakeup_disable = 0x40004ed4 ); +PROVIDE ( gpio_pin_wakeup_enable = 0x40004e90 ); +PROVIDE ( gpio_register_get = 0x40004d5c ); +PROVIDE ( gpio_register_set = 0x40004d04 ); +PROVIDE ( hmac_md5 = 0x4000a2cc ); +PROVIDE ( hmac_md5_vector = 0x4000a160 ); +PROVIDE ( hmac_sha1 = 0x4000ba28 ); +PROVIDE ( hmac_sha1_vector = 0x4000b8b4 ); +PROVIDE ( lldesc_build_chain = 0x40004f40 ); +PROVIDE ( lldesc_num2link = 0x40005050 ); +PROVIDE ( lldesc_set_owner = 0x4000507c ); +PROVIDE ( main = 0x40000fec ); +PROVIDE ( md5_vector = 0x400097ac ); +PROVIDE ( mem_calloc = 0x40001c2c ); +PROVIDE ( mem_free = 0x400019e0 ); +PROVIDE ( mem_init = 0x40001998 ); +PROVIDE ( mem_malloc = 0x40001b40 ); +PROVIDE ( mem_realloc = 0x40001c6c ); +PROVIDE ( mem_trim = 0x40001a14 ); +PROVIDE ( mem_zalloc = 0x40001c58 ); +PROVIDE ( memcmp = 0x4000dea8 ); +PROVIDE ( memcpy = 0x4000df48 ); +PROVIDE ( memmove = 0x4000e04c ); +PROVIDE ( memset = 0x4000e190 ); +PROVIDE ( multofup = 0x400031c0 ); +PROVIDE ( pbkdf2_sha1 = 0x4000b840 ); +PROVIDE ( phy_get_romfuncs = 0x40006b08 ); +PROVIDE ( rand = 0x40000600 ); +PROVIDE ( rc4_skip = 0x4000dd68 ); +PROVIDE ( recv_packet = 0x40003d08 ); +PROVIDE ( remove_head_space = 0x40000a04 ); +PROVIDE ( rijndaelKeySetupDec = 0x40008dd0 ); +PROVIDE ( rijndaelKeySetupEnc = 0x40009300 ); +PROVIDE ( rom_abs_temp = 0x400060c0 ); +PROVIDE ( rom_ana_inf_gating_en = 0x40006b10 ); +PROVIDE ( rom_cal_tos_v50 = 0x40007a28 ); +PROVIDE ( rom_chip_50_set_channel = 0x40006f84 ); +PROVIDE ( rom_chip_v5_disable_cca = 0x400060d0 ); +PROVIDE ( rom_chip_v5_enable_cca = 0x400060ec ); +PROVIDE ( rom_chip_v5_rx_init = 0x4000711c ); +PROVIDE ( rom_chip_v5_sense_backoff = 0x4000610c ); +PROVIDE ( rom_chip_v5_tx_init = 0x4000718c ); +PROVIDE ( rom_dc_iq_est = 0x4000615c ); +PROVIDE ( rom_en_pwdet = 0x400061b8 ); +PROVIDE ( rom_get_bb_atten = 0x40006238 ); +PROVIDE ( rom_get_corr_power = 0x40006260 ); +PROVIDE ( rom_get_fm_sar_dout = 0x400062dc ); +PROVIDE ( rom_get_noisefloor = 0x40006394 ); +PROVIDE ( rom_get_power_db = 0x400063b0 ); +PROVIDE ( rom_i2c_readReg = 0x40007268 ); +PROVIDE ( rom_i2c_readReg_Mask = 0x4000729c ); +PROVIDE ( rom_i2c_writeReg = 0x400072d8 ); +PROVIDE ( rom_i2c_writeReg_Mask = 0x4000730c ); +PROVIDE ( rom_iq_est_disable = 0x40006400 ); +PROVIDE ( rom_iq_est_enable = 0x40006430 ); +PROVIDE ( rom_linear_to_db = 0x40006484 ); +PROVIDE ( rom_mhz2ieee = 0x400065a4 ); +PROVIDE ( rom_pbus_dco___SA2 = 0x40007bf0 ); +PROVIDE ( rom_pbus_debugmode = 0x4000737c ); +PROVIDE ( rom_pbus_enter_debugmode = 0x40007410 ); +PROVIDE ( rom_pbus_exit_debugmode = 0x40007448 ); +PROVIDE ( rom_pbus_force_test = 0x4000747c ); +PROVIDE ( rom_pbus_rd = 0x400074d8 ); +PROVIDE ( rom_pbus_set_rxgain = 0x4000754c ); +PROVIDE ( rom_pbus_set_txgain = 0x40007610 ); +PROVIDE ( rom_pbus_workmode = 0x40007648 ); +PROVIDE ( rom_pbus_xpd_rx_off = 0x40007688 ); +PROVIDE ( rom_pbus_xpd_rx_on = 0x400076cc ); +PROVIDE ( rom_pbus_xpd_tx_off = 0x400076fc ); +PROVIDE ( rom_pbus_xpd_tx_on = 0x40007740 ); +PROVIDE ( rom_pbus_xpd_tx_on__low_gain = 0x400077a0 ); +PROVIDE ( rom_phy_reset_req = 0x40007804 ); +PROVIDE ( rom_restart_cal = 0x4000781c ); +PROVIDE ( rom_rfcal_pwrctrl = 0x40007eb4 ); +PROVIDE ( rom_rfcal_rxiq = 0x4000804c ); +PROVIDE ( rom_rfcal_rxiq_set_reg = 0x40008264 ); +PROVIDE ( rom_rfcal_txcap = 0x40008388 ); +PROVIDE ( rom_rfcal_txiq = 0x40008610 ); +PROVIDE ( rom_rfcal_txiq_cover = 0x400088b8 ); +PROVIDE ( rom_rfcal_txiq_set_reg = 0x40008a70 ); +PROVIDE ( rom_rfpll_reset = 0x40007868 ); +PROVIDE ( rom_rfpll_set_freq = 0x40007968 ); +PROVIDE ( rom_rxiq_cover_mg_mp = 0x40008b6c ); +PROVIDE ( rom_rxiq_get_mis = 0x40006628 ); +PROVIDE ( rom_sar_init = 0x40006738 ); +PROVIDE ( rom_set_ana_inf_tx_scale = 0x4000678c ); +PROVIDE ( rom_set_channel_freq = 0x40006c50 ); +PROVIDE ( rom_set_loopback_gain = 0x400067c8 ); +PROVIDE ( rom_set_noise_floor = 0x40006830 ); +PROVIDE ( rom_set_rxclk_en = 0x40006550 ); +PROVIDE ( rom_set_txbb_atten = 0x40008c6c ); +PROVIDE ( rom_set_txclk_en = 0x4000650c ); +PROVIDE ( rom_set_txiq_cal = 0x40008d34 ); +PROVIDE ( rom_start_noisefloor = 0x40006874 ); +PROVIDE ( rom_start_tx_tone = 0x400068b4 ); +PROVIDE ( rom_stop_tx_tone = 0x4000698c ); +PROVIDE ( rom_tx_mac_disable = 0x40006a98 ); +PROVIDE ( rom_tx_mac_enable = 0x40006ad4 ); +PROVIDE ( rom_txtone_linear_pwr = 0x40006a1c ); +PROVIDE ( rom_write_rfpll_sdm = 0x400078dc ); +PROVIDE ( roundup2 = 0x400031b4 ); +PROVIDE ( rtc_enter_sleep = 0x40002870 ); +PROVIDE ( rtc_get_reset_reason = 0x400025e0 ); +PROVIDE ( rtc_intr_handler = 0x400029ec ); +PROVIDE ( rtc_set_sleep_mode = 0x40002668 ); +PROVIDE ( save_rxbcn_mactime = 0x400027a4 ); +PROVIDE ( save_tsf_us = 0x400027ac ); +PROVIDE ( send_packet = 0x40003c80 ); +PROVIDE ( sha1_prf = 0x4000ba48 ); +PROVIDE ( sha1_vector = 0x4000a2ec ); +PROVIDE ( sip_alloc_to_host_evt = 0x40005180 ); +PROVIDE ( sip_get_ptr = 0x400058a8 ); +PROVIDE ( sip_get_state = 0x40005668 ); +PROVIDE ( sip_init_attach = 0x4000567c ); +PROVIDE ( sip_install_rx_ctrl_cb = 0x4000544c ); +PROVIDE ( sip_install_rx_data_cb = 0x4000545c ); +PROVIDE ( sip_post = 0x400050fc ); +PROVIDE ( sip_post_init = 0x400056c4 ); +PROVIDE ( sip_reclaim_from_host_cmd = 0x4000534c ); +PROVIDE ( sip_reclaim_tx_data_pkt = 0x400052c0 ); +PROVIDE ( sip_send = 0x40005808 ); +PROVIDE ( sip_to_host_chain_append = 0x40005864 ); +PROVIDE ( sip_to_host_evt_send_done = 0x40005234 ); +PROVIDE ( slc_add_credits = 0x400060ac ); +PROVIDE ( slc_enable = 0x40005d90 ); +PROVIDE ( slc_from_host_chain_fetch = 0x40005f24 ); +PROVIDE ( slc_from_host_chain_recycle = 0x40005e94 ); +PROVIDE ( slc_init_attach = 0x40005c50 ); +PROVIDE ( slc_init_credit = 0x4000608c ); +PROVIDE ( slc_pause_from_host = 0x40006014 ); +PROVIDE ( slc_reattach = 0x40005c1c ); +PROVIDE ( slc_resume_from_host = 0x4000603c ); +PROVIDE ( slc_select_tohost_gpio = 0x40005dc0 ); +PROVIDE ( slc_select_tohost_gpio_mode = 0x40005db8 ); +PROVIDE ( slc_send_to_host_chain = 0x40005de4 ); +PROVIDE ( slc_set_host_io_max_window = 0x40006068 ); +PROVIDE ( slc_to_host_chain_recycle = 0x40005f10 ); +PROVIDE ( software_reset = 0x4000264c ); +PROVIDE ( spi_flash_attach = 0x40004644 ); +PROVIDE ( srand = 0x400005f0 ); +PROVIDE ( strcmp = 0x4000bdc8 ); +PROVIDE ( strcpy = 0x4000bec8 ); +PROVIDE ( strlen = 0x4000bf4c ); +PROVIDE ( strncmp = 0x4000bfa8 ); +PROVIDE ( strncpy = 0x4000c0a0 ); +PROVIDE ( strstr = 0x4000e1e0 ); +PROVIDE ( timer_insert = 0x40002c64 ); +PROVIDE ( uartAttach = 0x4000383c ); +PROVIDE ( uart_baudrate_detect = 0x40003924 ); +PROVIDE ( uart_buff_switch = 0x400038a4 ); +PROVIDE ( uart_div_modify = 0x400039d8 ); +PROVIDE ( uart_rx_intr_handler = 0x40003bbc ); +PROVIDE ( uart_rx_one_char = 0x40003b8c ); +PROVIDE ( uart_rx_one_char_block = 0x40003b64 ); +PROVIDE ( uart_rx_readbuff = 0x40003ec8 ); +PROVIDE ( uart_tx_one_char = 0x40003b30 ); +PROVIDE ( wepkey_128 = 0x4000bc40 ); +PROVIDE ( wepkey_64 = 0x4000bb3c ); +PROVIDE ( xthal_bcopy = 0x40000688 ); +PROVIDE ( xthal_copy123 = 0x4000074c ); +PROVIDE ( xthal_get_ccompare = 0x4000dd4c ); +PROVIDE ( xthal_get_ccount = 0x4000dd38 ); +PROVIDE ( xthal_get_interrupt = 0x4000dd58 ); +PROVIDE ( xthal_get_intread = 0x4000dd58 ); +PROVIDE ( xthal_memcpy = 0x400006c4 ); +PROVIDE ( xthal_set_ccompare = 0x4000dd40 ); +PROVIDE ( xthal_set_intclear = 0x4000dd60 ); +PROVIDE ( xthal_spill_registers_into_stack_nw = 0x4000e320 ); +PROVIDE ( xthal_window_spill = 0x4000e324 ); +PROVIDE ( xthal_window_spill_nw = 0x4000e320 ); + +PROVIDE ( Te0 = 0x3fffccf0 ); +PROVIDE ( UartDev = 0x3fffde10 ); +PROVIDE ( flashchip = 0x3fffc714); diff --git a/hardware/tools/esp8266/sdk/lib/libhal.a b/hardware/tools/esp8266/sdk/lib/libhal.a new file mode 100644 index 0000000000000000000000000000000000000000..b7a43bdfffc7cb133eca0b5aeaf9b2ec421d613a GIT binary patch literal 349408 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�X-dHH1SThn_%3VS{ZpGGYGu|jSHnGpQO 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 QslLa;yDYrd!V?z$8&E_!@&Et; literal 0 HcmV?d00001 diff --git a/hardware/tools/esp8266/sdk/lib/liblwip.a b/hardware/tools/esp8266/sdk/lib/liblwip.a new file mode 100755 index 0000000000000000000000000000000000000000..887d7c4b16b73434620ad61d656511b8c7da3385 GIT binary patch literal 230324 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≈4NS-5kf}#~{8=jjQGX&fytQJT7wZQd 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 literal 0 HcmV?d00001 diff --git a/hardware/tools/esp8266/sdk/lib/libmain.a b/hardware/tools/esp8266/sdk/lib/libmain.a new file mode 100755 index 0000000000000000000000000000000000000000..93aec3a47f4a44c4d89ae97e69d91f6ec60984ce GIT binary patch literal 69124 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

&s3T%I3sPK^3^RdQT+2$0 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 c&bSg*FMdpdch%M2jYS=R%?(2|K|At2IPK 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:zWMO*k2usKOJc&b2 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 literal 0 HcmV?d00001 diff --git a/hardware/tools/esp8266/sdk/lib/libssl.a b/hardware/tools/esp8266/sdk/lib/libssl.a new file mode 100755 index 0000000000000000000000000000000000000000..f1a299e90e07292b596db54b04cc2a2c7a56e648 GIT binary patch literal 159214 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 literal 0 HcmV?d00001 diff --git a/hardware/tools/esp8266/sdk/lib/libwpa.a b/hardware/tools/esp8266/sdk/lib/libwpa.a new file mode 100755 index 0000000000000000000000000000000000000000..0f593c6c087b6891af060e62c07044ab1a40bbbe GIT binary patch literal 124308 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 Y=#^$NBYNy$i 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¬zJ=$)Yq}cSo$bK`GK1^|e;&F=06;D@OuXv&2Wr|lTUZ>df zUr2gPKZ5WMWwTfDA;s)Vu*Y~tF$aQK-BsLQak}Dc#Usdgme6r%Io~>)Gdnsh`{#WN zHYex0oG<(7Dtdlr)VLzY{!v6+j^{4;k6j)A$KqIr87b3~;z48A2E4-p?}hil$HM1) z7-{f2RbFqIHzqoXR~2e{^OKva9n4aW>A!|Q7~`fSo|=0)(sDX7|3OTV+?;soUWmcO zQ!6nQR?mkoN!)ZY5^VEq{CUU5K@VU8v)05@-TTS8@OklH(%bFP@@~WpHZSRDzLwi# zcOK8_5|0D#h4;b7!vCM8RrbSu=6v*d>6PT6sGz6ATsuFd)N6VojpBYyV)Bz98-8ca}?SxXW)?SUFTm5QQO{i;oMc;L{Bi$ z8GKl#mh+rRsO*=WcqBV{_y+INT+b6pm$`lLq1HcPV{CXuq~@yfN`JM#_NwET?5#893=xH?(AzkzR_4Q{KRQ7v6{>a104ou#%aK0>GS<9uSV8A!p{)g`*3P|Vvkjc zam_zYhT_3hT#=J;8LyxDM)BD~PA_Gz-~ER%m+789uifg6%i`6;-0vQox!<23I0Pqs z=OCW+gsV=gs~7Q~I(4SsmwF!gDz9BphUbZ^uXcT7O0jWQ^rV-U)?9VPZRYAtD!u)O ze{nregzjcMH-0*vNG#(CO?u+$Df+m&WY#I%@Mj&ml`fuVoLKFVy#=iHX&%fgt7F*==BbS|~EH?6&9=IW%ZnEcr2 z=Z(9k%$6CvqVKds%f#qdTR)PJ36JWHCnM$ZjNnxnt$~bH=^4ka&3QLc_->?ZU!>%w zMN9F9=sTFDFY#32=}6H>5&Z7_FjDw-r04_w?mYX+BSK`K<5D`CPgh>;t-K;!dHKG| zE00xPm0Nk)_R6$iW&b@rvSRb&PR1UN!%Tr@ZqU=6{a)DYsuOHrJVnR5532z>kR$dpn1D{`Pf__{baVOnc#9qci-O`PX2dh=R$? zr&<(?DZH^@X2;BT%?dM9XfV(}H*i@vaCt)@fUho$+vyDiF?-z}#=1R_wl8qyvA|WQ z16Sku;0;_cC>bRo+q$$%>Fj9eOiFmZwiEN*2i##(oXWEiOqh&l%*U-WJ24qEF0Gk~ zTt4EE5lqc!y(D8_O2)Ci;e8SJ53bjI&>@8R*VEwLvcyvv!9E$SsTun&$vDy;B%4XKcA7qr=^y@8_9Vm65f8H;5ze- zjF_yL#8We;#pYnz@$->Or^T0^isZZ%+4)}NUhv-{IVU4K--*lzzZJ=OGqUqkq{p<~ zr6(gfZ$x&UWZrPky7x8w*9JEZk-L{vg*~ld#~s-a_J+eTV}nH)s2MkNTAwR!TNRFp zuEeUbL3iM#pB8&eOT@-l55uZ(%oVp~#iH=foZQ15_;K_NjJ{PzuVTVVtQs3cOi|P^ zc|5n=ddnzYx7$aRWDU!XhB?{8JQK!_F$L&NH;wNO2a9;yEn{!F_4ZplCF95XZ>gL$ zLtl3??=SpyH2#Zy3)@zW{`o!Zf267MQjrJhBtL9G$mRa1xT0F@VS6u{m`uHu`Gsv; z)DIw}&NinsgcS%w28RI9=wxEN9e5}_)9@pBI@*x!wm+c=M|}glO@9X% zQJ8IyBc!7Z*{1(Jig47)J>Z$1kKpO3lWqF@${z&kWSfRdm2R(vlZkh;pd&D87^iH= z=yEgrs#H4J#>w|d=(sO?T^VN`^m)*DPX4TH$hfQ~PQG(V$8E_RF3aO$9}2r8$=P7` zw~&j$>=q<1P&(fO`Kst_^EOxMWUlA73zSZ_dW+J@HvXkbCtIEGY0zBnr# z8G7lMHd`ifTR(Kh&u#gh1|4n4_TC(&bTXfbOwU-QldWE=bh6cNS3241eBXnP`>g=8 zTx8mogKq^hZG6{)jyB|R2$_a!83`P9axp^cbChn&T*lc9eHhj=PPQ-8aXLsc?@j7# zU#4T6WS&ySxmW3A>a^dlbh5Q)+cX{HC$o8j_HS5S*xLV1>0}%KJ4z>8`}dVjw)%%k zx6c_KdnPU@hTfPo+`x+q$73XO6CPuM(#baej8Qt-75m$iPPTfb(#ckzrF62@7btz9 zFw;y9U|&3Mk0~3nEzdVAeioc8X*&S6=j0HWj@N?h2Q$v|Ru{H$Cga4|c!FRXPX?Gy z0>eI*{X^z0nAKQWg|M+98rE2sl;2c>S2yir|^PTzI<4xR9fwXntwO^|wjrH7dqu!;afq z$9U`e-06nQ#$v!0O?7C(MI=*4oMC}+KpItUS-V^qk0X>IMpnRVo&c?^k zo;$7@fePIzh}@p%k?}EZmM=QK5DMYJHWI8;h^5bVG3E+?yzbNUFyW#o7jsdppPqL~ zr-U?LnxBYqVHTZgPs6;~)N7}IypO5hz|=Z(8q6lsqA_qvBu=tpb}5n0 z!E{J7FH+{+gXe^aQ#P!>2NNJsjLz%xY1Pw+^KAQeSl6-Rw#>K&xe5E@lv+Jiu^9&; zHm=g+6|=tBy)CW}$4$}ke<>N+%;Zxt?=)UxGVk+A!ptN5Z%Mrl;iJO!2s?x~AUrO- z5h3#o?YAKONO&v4SZLI@f%$)r%>RJ=k4H{}pCIfmIp&3NlHU{l5aE|_ji~cl zS7VHe@8!tn^pgmVy< z3vLFveuUo;rp=?mKSX#=_yR)KQ5Zk( zo3Jp;J9_H8Zzc-QMEIcaj}RUe=Kb-O@Oud9xh?Mx&V@&2JIN?v-V>$5Z0j)N6J;#< z649xV?fCA07oF`J|DpIlg@1?eDaFqTv)$vQ@H+_kyk~mYcJZz-|F5$wq22?bPxw`Y zR|~WK;TmDi-^4MAw5M+7a{{ydBv*9CIZBvqEH?|6ARI5uwvHNMwqwi|ZbUd&>0IW% z*behA!YsGGFU+=@2ZY()!m*09C*vEMhF?a=W2XKB!aoS}xL*@y`k5xXFCWSXJ2pQc zWe7F0y)OBpvn{1S@fhLnBP>(=4aN5hv%Tdf!kZBORG94~KNIf2@v<$3X?q6Yc44-e zye!Q2kfXw{BYaiqT;{fHx8XQMGUJTJGMQ~VTt{AjaDXt|Qp|iC(8(du+0JvFFw6U! zh1nKl+JK-{f_V&#vkqacFpq=jrp|qGe`Id=nDCDgwhR9^Lbl!5cQH4JPK|8e#auy~ zWE>RSuf>KM+0OOywCHT}Sq*RJIO!6d8rjZqa#VD-+q|OqFN)dj<1oX+y(v01vVB+h zwCIe-FXb@Helwp3j-6$HhUhHs2MV){4+*neuYkAv`kCm|$aY`bL}#1Kba;D=J4L5P zw#QhbZ1#x_HL|s-Q#QxMh8o%0nDLct%z%4KY^af~O(WQ*|0A)XMz-niCC?zX9W~Kj z;!F{p8rjCVP}y81Hq^-0rdinx78`10YqMC{3>O<}WNWjGHkiMc?rUO0jcn&!X#(5# z%O4dRYGnI<`9j*ras5basFCfySa;`r!S=3S2(yjrmx_NaydNR!_OxeP*2}_dn=YL(K73=mf22d*{?WLakk<-#RZCs6_+S3 zR}Adl7wgk@zd8-+O4s{kJ;U1TeN9k$g<{srt$mZ?#fn!bUaNS$;w_3h6n7~;p!ikA zrxc%89FJ>a)5dFMne}_iA;o!$M=CB+Y~I_zGM%Xx2{$U6X2r`DuTlKC;*E;UdmC7$ z+okmVijOFMQ}J2FtRvZDOj2y#+khP%>qypSnBoG(=DiKEH}7o-Pggeeip_f)VzW%? zs}-+PY~I@td-L9g@D63edXY`1d2d5(jw}6)V*aPH_U63}u{ZB+2&XHXY{lli4Y4ur zZ3vt9HiRpby?Jj#bo1VZ@M2}d|8h1x=DiKEG4E{%oA)+^JCwb7Z$otR-i9#iPBu=~ zmn@t2HpIrfw;`O0=eo7=D-J2nQ*7SbkZsL-8^Y$j4Po=%hH#_WwpsCV#cZ3hX)y0? z$hPLa4Po=%hOl{WLwLX1_K0HEVQidd75n%clx^a{mwicP&j>=!G2h2ph}&3hYS&$@(7PlsaGEv(M^gJsqYET2+*UNQgATO0m| zx6J?EmP3m36pvJF-rJCLPF8x2;zq^IikB;1qxf;f=DiJxe;ak&&vb0|n?9rJo|(~M z)BevLH+@}hp5M67A2+=pVP;R6Xl=%)vpJv){tJ#Kwkm> zZ+7-X3=%uJE#;p1I6iB~dNfbU=h?AM@8bR1lgU_Z`U=I48XfEAqYXuW?0(r6h+?DL zEdsGlX`RK%5G-@uP?Q0T(>lBEb_g~NT(=F+7TU3gis|G!{;yzDhCNoGXAa_dT;lKJ)+R*tw8-&)^ZIhV zvCX$7mkjln;SjLn+qh#a-upmrSWl?(I#oN**G`X%#a78J&qwZkpx52)Pd2XdI;(b{ ze`K+FZ1PN`;GK)ggusc?gN3_u4*T|aPsW({VMay=`X5YwVo3dnKCbt#hmNf~+$%A` z@w)ibqVxI+H_v&tZxOJo@6tY=-wqu-ba?)C@2|L`JbCvuVb>Wva?EvDNqtYu6*s*& zY$ry;zrNyhmYbhgoV?_X$V00_ArYzhm?t@76yH|Cuac_f`8+Kd6i5ZL2tJBlmfpI-N)qhFqwwMxw_ZBjq zx@O_cI&XCI4S6;5sq_ihjO*&I&F4X3n*`)2e@sLpuV9e{M_BLS)H;Y&7$`=wRq zhA*uOJ87+`j-=f_{1 zVv6t{*nrL9lwuTq^!h&*Qx+_$3XabAB@}vtw}*qHs{L+5 zuy~-8l`!fZ^Nsd|QLjhh3(d9pf|V`Y)Bmh#{Ug=1_#kD4fe$_xPY^yV=%_oH(U1i` zYg+#Qr@ixmt*g54_`5I8AKNb-_Ml`mWY-VJyig~#Ux64(Cfj7GX_AqIu!a$8KR-V^ zuk}Cd7m`q>ItD^2vMOk_Woonqi)j?K1$C$zD{CEAO^F(`Kc!QUC<`ou{sCcVVW6eF zeLwe}pL2Lb1f()e6+h|s&iDMz@BZ#N=bn4+xxaVLJz|KoP;3)J?cwO#;@EcS@ZjLs zbz%q|FoT{c@f~6aIha8S`j3hsa>v z?-1qziTx#r-Dgdudmmd}p~ zpD!6YIN~65z(kS%k$}}(9-#=GK8J%$jA<*AV*aFr&;eVy4tR2KTIo~b?|E{tp&ouw7;%lk>YibZR)5oqOmjBAPiC-Wz*dX=5ou8JX)W< z8CbVLGa-%3qeuH&-aEESXSHNTRu1NE`|mN2Nbhv-F*)hkG1w^TWHd!1OWP`epT8OP zwT+UIKYQ;Wf5T!sMli8k_VE20Sz1v7-yYw#L=Su1Mx1gzJnj6y$b2{59$PePVEn!rL6?(fD0@7TFqA;S@HNa$g~L_nJs@u)@z0@pe@Z9L$n5rtxOkb!HRoc;s(I)yO! z4uwM=W^S{|cX{}W4l|Vbl83+TVbVC3>vh~=hB&avU-vLW8~YCOGGTO(f$clUtxnFc zF_sX3kqCF zzhs!c#jvkKb2K^68^etr=KeQ1_psqE4{!ExkB0|6ywk(R3=j9ozSq)k<#~mC~$D8G@)%w^?y6S=KoIOpOYMREA{kK-howfRb z$YEoO?;*Tlj=tov^H6bP^^H&7b!7LkXC6;3_}5f&RjNAp$WXB(co~;x@U!xB>p!|Y z(bd`6xTJPfcJ5WP1wPp1#ELgUfR1bbeoF@Sh~54<1yi zKwIu7$#g!SRs27QFX+f@>~BuDK2gpNHKlG_l}z3s<^2~e4~~(1c=xfp7Tg$pP^ABg zxvf7e?|HS{v^d$n^+&Bo%6nd66-7*|k`2Eu%W<3OtPV2C_)8+EJhi43huMSE(mYaE z9Xy_Fc%!^NmFbLKyA7|&C${O}^u)Tl4XeZWn-+)b-exB94=4Xk&ege1;rUH1=QZ`5 z+tfa{X+yGqbbczWuVYNBV6mGxRUiD4=$ikD^ZKVrc~v{_-7{G~(_8;?b;qYVH&sn0 z?>*63H6d4RrgNe{%p{9J?^JF2u?s&tP_rZcXo@-5q5|Z~<^KBl+5Q_kuSqPN$@YI{ z-mgzpM5Lj$Gb|hvh0*Uj|449G_DQrZ24h(+ys;w zedXkE1K&)-^B&c|-fQf_(6<|9+%wSPgsrcaH@;EMy-~hV7hCl|Qyrv|$$KYis?vQu z$-bOE1`}WFhF8j|kH^=`Y}aT*>tQWsDfERqiluGg((&d{TRuxR7%uIrN%U>YkB0fd zqBhzNwN3X}X~l{adf&NVOQ|qCo(r$k#@E`ZdMy0o!q~WW&<@*Hw5(_iFAu}nPUHhu z=x>`Vlr~5I{VOruIcsz1#d{PIKd6xR0@e!a*AiuE<2LI}Me6NkKGOp1SB%$w?z znD;aYJ&5z6Pxxsu`ge*sFZy2-a}4;9*j#Z>3q#le^L~!b^I`}&c%B&fiyr=^Focek zl{|1i;s%=(pR2M#=vY0V!+mP*Sl$sJbgYih*(Q0jWZ1de(*g6!h5WBPxz#JjGAHp5 zoDT1j5caLk(fO(5_&c!knx_M{@^Wn;jT(1fzjgXcv+Im zY*pN@rQmFy+C7Z?KIM=3XXKCj-SW3l7<*YU^pG;ZJ!FI)={+t~5YcneTVoN0R*s@D z_Klc7c{(5E=cQoBpv%0yE<4CeyGfWl7%f)E#d{#-pnk0!dxd>_%-`ev!^qNZmB6>R zSN71u9`~);Bd#LOQoAnBU9+)M=fbXcn#56cBGVGoOK$n2zoZZJ?d{XaeqfnWng4XO`NlwqBF0_R;7D1XZ9|Ng=b!aO$krY9Mzy-4$7^|FiXVgV~vQzM&Pr> z+{51&*Qiujg__;5vhvLcRem1o9Eh2-a(73u$=xIGt0 zKU$HFAAx5AZHWh;Ocl z4_CxLuQ<;Uo*m>5|CkZy`>Nvh+#r3bBK^UNcw(Ttm`{{GR~${`^Q`wSj3!1$uNu}k zc5rZQVOOG<@0PE)TT8bSH*FXhE3FwT6cVEmTrZW8e6%3F_vXUbh%HUekLs{Oq0rWn zZEfuy*!)1}$u;O3oI zs``6#DhGWaKIaK{ZO#8oyTyM9Efj;%{jkH03V+XG#+8dbd9=O+>7*~PS z{vra?=tL(avwd?J!k{g}Shp+pgx{5r)b15^@&(VcJ@8{c&p+s`=6IZrtJJ%x;! zIhK6Qc=9(LChr%kEa*_C4u>i00f+xgVbnKChx&NK$zN8u3fp4p>}rRp%WEB`j)xqk z?r(NDrSOXmbA29k7+X9S37;0zr+~S((cbn7dAu!ga@s|M!?c$+hiMo5*UGW9sYN=> z){I``%8m?dYepF(p?{}B+N7=9qwhzK3~cN6LSfUnSr{E;VAJ_?C;ytlMzQIC*~yWC zO`oQ3`*r=L(?JHd{kodb;ev|3CFZ=yz_zyX@0|Q;g)QRX9Q}wM7o(31%)Vg|ddQzw z2!m-mKX>?$!q>$CH?gQj*Bc#VVB6O!6t;DfpKvU9n zb;g9Tj|^O!j^&NQ!38niEsPE_aIKU7wUd)K{oY;LaP_cR1=R9QJKq;o0f(@MaJ9czDpmJ3V}xhxdE z;QyV9dFMwOCexEowpQ2uWd7Q@V+Rl4JeFBhJ?|IEqb-^ZU6*+5vHI#@!`{+{{iUh- z6H}cZ(*6S3&fn3Da!uf!*xNDLS-0*oeP$EE&H$;A4(%TuX2v1@+c!Xpba z0ecXbFP&WIABpQ)iygZ*R_Cs2SQcDXm&#`EO~|_+&3A9B>uT82x-hw|BNOc0nCzXr z{nheT-<#g2}ZH$9o&@|_Lylj%Ln=jfc~I-gyGCB=8;4|kRRfkXVa%^`k^8VcA{m&QV@muPF@!GoEHQEhfD0YQIR&9(=LuwgLh;MQ*ndO}q4Q{j zbhAqb{JUaw{#lHR2K)amhR~-&h0q664)mWAL(vB{6`K4wLJ{)g3X@{=pA|#cd=F0C zckn=sW3=260Kj>h>b4v}bxPN~L1cRtrA#XN!urv;39?O5AUGmkLGU22qw;#J)YY}28$B-_U@Ar^st97&+JwDOP4BP zhZ$37_6TXdMvGPWP(u7qHDc^hF7j&EOfYeU>iJ6mM`q9BrwjkT%;~heQ7+ns5plVn z6BA;(73OGKx20%Q541PBl=H--uT^MW2JwR8bQ{zgao$mni>YJcz7MTps^<8RK9wkk zTX*CqO5jk71+n96NNcO{W$9n&V%{8RI%a5asDR5!PP3B!#Fj_O^at>j6>@Tu;T?;- zXEGv(7Y?%`CgM4)j0s1DuNQ+qtMCGcDgSzht*Z`b7@}*%=tJOIC#UQ-kFrk~9b{me zN69&m)9!B(o6qJRCr1Xh?}9z(;Jm}$_9=^@P`#pTX!}ojmVGmDx_^5}EdH95fXFPn;!~YA=u$Ykm literal 0 HcmV?d00001 diff --git a/hardware/tools/esp8266/sdk/version b/hardware/tools/esp8266/sdk/version new file mode 100644 index 000000000..f76f91317 --- /dev/null +++ b/hardware/tools/esp8266/sdk/version @@ -0,0 +1 @@ +0.9.2 \ No newline at end of file