diff --git a/changes.md b/changes.md new file mode 100644 index 000000000..25c27a12f --- /dev/null +++ b/changes.md @@ -0,0 +1,21 @@ + + +# Current version + +- Add 32-bit Linux toolchain +- Better connection handling in ESP8266WebServer. + The server now sends Content-Length and Connection: close headers, + then waits for the client to disconnect. By not closing the connection + actively, server avoids TIME_WAIT TCP state, and the TCP stack is able to + release the memory immediately, without waiting for 2xMSL period. + If the client doesn't disconnect in 2000ms, the server closes the connection + actively. +- Add Hash library, which has a function to calculate SHA1 hash. + +--- + +# 1.6.4-g545ffde +19 May, 2015 + +- Initial release of board manager package + diff --git a/libraries/EEPROM/EEPROM.cpp b/libraries/EEPROM/EEPROM.cpp index 2d8b23db9..dfd968a4a 100644 --- a/libraries/EEPROM/EEPROM.cpp +++ b/libraries/EEPROM/EEPROM.cpp @@ -28,95 +28,91 @@ #include "os_type.h" #include "osapi.h" #include "spi_flash.h" -extern uint32_t _SPIFFS_end; } -#define CONFIG_START_SECTOR (((uint32_t)_SPIFFS_end - 0x40200000) / 4096) -#define CONFIG_SECTOR (CONFIG_START_SECTOR + 0) -#define CONFIG_ADDR (SPI_FLASH_SEC_SIZE * CONFIG_SECTOR) - -EEPROMClass::EEPROMClass() -: _data(0), _size(0), _dirty(false) +EEPROMClass::EEPROMClass(uint32_t sector) +: _sector(sector) +, _data(0) +, _size(0) +, _dirty(false) { } -void EEPROMClass::begin(size_t size) -{ - if (size <= 0) - return; - if (size > SPI_FLASH_SEC_SIZE) - size = SPI_FLASH_SEC_SIZE; +void EEPROMClass::begin(size_t size) { + if (size <= 0) + return; + if (size > SPI_FLASH_SEC_SIZE) + size = SPI_FLASH_SEC_SIZE; - _data = new uint8_t[size]; - _size = size; + if (_data) { + delete[] _data; + } - noInterrupts(); - spi_flash_read(CONFIG_ADDR, reinterpret_cast(_data), _size); - interrupts(); + _data = new uint8_t[size]; + _size = size; + + noInterrupts(); + spi_flash_read(_sector * SPI_FLASH_SEC_SIZE, reinterpret_cast(_data), _size); + interrupts(); } -void EEPROMClass::end() -{ - if (!_size) - return; +void EEPROMClass::end() { + if (!_size) + return; - commit(); - if(_data) { - delete[] _data; + commit(); + if(_data) { + delete[] _data; + } + _data = 0; + _size = 0; +} + + +uint8_t EEPROMClass::read(int address) { + if (address < 0 || (size_t)address >= _size) + return 0; + if(!_data) + return 0; + + return _data[address]; +} + +void EEPROMClass::write(int address, uint8_t value) { + if (address < 0 || (size_t)address >= _size) + return; + if(!_data) + return; + + _data[address] = value; + _dirty = true; +} + +bool EEPROMClass::commit() { + bool ret = false; + if (!_size) + return false; + if(!_dirty) + return true; + if(!_data) + return false; + + noInterrupts(); + if(spi_flash_erase_sector(_sector) == SPI_FLASH_RESULT_OK) { + if(spi_flash_write(_sector * SPI_FLASH_SEC_SIZE, reinterpret_cast(_data), _size) == SPI_FLASH_RESULT_OK) { + _dirty = false; + ret = true; } - _data = 0; - _size = 0; + } + interrupts(); + + return ret; } - -uint8_t EEPROMClass::read(int address) -{ - if (address < 0 || (size_t)address >= _size) - return 0; - if(!_data) - return 0; - - return _data[address]; +uint8_t * EEPROMClass::getDataPtr() { + _dirty = true; + return &_data[0]; } -void EEPROMClass::write(int address, uint8_t value) -{ - if (address < 0 || (size_t)address >= _size) - return; - if(!_data) - return; - - _data[address] = value; - _dirty = true; -} - -bool EEPROMClass::commit() -{ - bool ret = false; - if (!_size) - return false; - if(!_dirty) - return true; - if(!_data) - return false; - - noInterrupts(); - if(spi_flash_erase_sector(CONFIG_SECTOR) == SPI_FLASH_RESULT_OK) { - if(spi_flash_write(CONFIG_ADDR, reinterpret_cast(_data), _size) == SPI_FLASH_RESULT_OK) { - _dirty = false; - ret = true; - } - } - interrupts(); - - return ret; -} - -uint8_t * EEPROMClass::getDataPtr() -{ - _dirty = true; - return &_data[0]; -} - - -EEPROMClass EEPROM; +extern "C" uint32_t _SPIFFS_end; +EEPROMClass EEPROM((((uint32_t)&_SPIFFS_end - 0x40200000) / SPI_FLASH_SEC_SIZE)); diff --git a/libraries/EEPROM/EEPROM.h b/libraries/EEPROM/EEPROM.h index 97dd4c26a..ef7ac454d 100644 --- a/libraries/EEPROM/EEPROM.h +++ b/libraries/EEPROM/EEPROM.h @@ -26,43 +26,42 @@ #include #include -class EEPROMClass -{ - public: - EEPROMClass(); - void begin(size_t size); - uint8_t read(int address); - void write(int address, uint8_t val); - bool commit(); - void end(); +class EEPROMClass { +public: + EEPROMClass(uint32_t sector); - uint8_t * getDataPtr(); + void begin(size_t size); + uint8_t read(int address); + void write(int address, uint8_t val); + bool commit(); + void end(); - template T &get(int address, T &t) - { - if (address < 0 || address + sizeof(T) > _size) - return t; + uint8_t * getDataPtr(); - uint8_t *ptr = (uint8_t*) &t; - memcpy(ptr, _data + address, sizeof(T)); - return t; - } + template + T &get(int address, T &t) { + if (address < 0 || address + sizeof(T) > _size) + return t; - template const T &put(int address, const T &t) - { - if (address < 0 || address + sizeof(T) > _size) - return t; + memcpy((uint8_t*) &t, _data + address, sizeof(T)); + return t; + } - const uint8_t *ptr = (const uint8_t*) &t; - memcpy(_data + address, ptr, sizeof(T)); - _dirty = true; - return t; - } + template + const T &put(int address, const T &t) { + if (address < 0 || address + sizeof(T) > _size) + return t; - protected: - uint8_t* _data; - size_t _size; - bool _dirty; + memcpy(_data + address, (const uint8_t*) &t, sizeof(T)); + _dirty = true; + return t; + } + +protected: + uint32_t _sector; + uint8_t* _data; + size_t _size; + bool _dirty; }; extern EEPROMClass EEPROM; diff --git a/libraries/EEPROM/examples/eeprom_write/eeprom_write.ino b/libraries/EEPROM/examples/eeprom_write/eeprom_write.ino index 3f1af8e41..b41a5ca32 100644 --- a/libraries/EEPROM/examples/eeprom_write/eeprom_write.ino +++ b/libraries/EEPROM/examples/eeprom_write/eeprom_write.ino @@ -22,7 +22,7 @@ void loop() // need to divide by 4 because analog inputs range from // 0 to 1023 and each byte of the EEPROM can only hold a // value from 0 to 255. - int val = analogRead(0) / 4; + int val = analogRead(A0) / 4; // write the value to the appropriate byte of the EEPROM. // these values will remain there when the board is