arduino/esp8266
1
0
Fork 0
mirror of https://github.com/esp8266/Arduino.git synced 2025-04-29 12:16:48 +03:00
Code

Merge pull request #12 from esp8266/esp8266

Browse Source 
pull latest changes
This commit is contained in:
ficeto 2015-05-06 11:47:26 +03:00
commit 5daf774c5b
6 changed files with 93 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
boards.txt
View File

@ -57,12 +57,12 @@ generic.menu.FlashSize.4M=4M
generic.menu.FlashSize.4M.build.flash_size=4M
##############################################################
nodemcu.name=NODEMCU ESP8266 Module (v0.9)
nodemcu.name=NodeMCU (ESP8266 ESP-12 Module)
nodemcu.upload.tool=esptool
nodemcu.upload.speed=115200
nodemcu.upload.resetmethod=ck
nodemcu.upload.maximum_size=524288
nodemcu.upload.maximum_size=4194304
nodemcu.upload.wait_for_upload_port=true
nodemcu.serial.disableDTR=true
nodemcu.serial.disableRTS=true
@ -73,7 +73,7 @@ nodemcu.build.board=ESP8266_ESP12
nodemcu.build.core=esp8266
nodemcu.build.variant=nodemcu
nodemcu.build.flash_mode=qio
nodemcu.build.flash_size=512K
nodemcu.build.flash_size=4M
nodemcu.build.flash_freq=40
nodemcu.menu.CpuFrequency.80=80 MHz
@ -101,14 +101,6 @@ nodemcu.menu.UploadSpeed.512000.upload.speed=512000
nodemcu.menu.UploadSpeed.921600=921600
nodemcu.menu.UploadSpeed.921600.upload.speed=921600
nodemcu.menu.FlashSize.512K=512K
nodemcu.menu.FlashSize.512K.build.flash_size=512K
nodemcu.menu.FlashSize.256K=256K
nodemcu.menu.FlashSize.256K.build.flash_size=256K
nodemcu.menu.FlashSize.1M=1M
nodemcu.menu.FlashSize.1M.build.flash_size=1M
nodemcu.menu.FlashSize.2M=2M
nodemcu.menu.FlashSize.2M.build.flash_size=2M
nodemcu.menu.FlashSize.4M=4M
nodemcu.menu.FlashSize.4M.build.flash_size=4M

12
cores/esp8266/Esp.cpp
View File

@ -223,10 +223,13 @@ FlashMode_t EspClass::getFlashChipMode(void)
* Infos from
* http://www.wlxmall.com/images/stock_item/att/A1010004.pdf
* http://www.gigadevice.com/product-series/5.html?locale=en_US
* http://www.elinux.org/images/f/f5/Winbond-w25q32.pdf
*/
uint32_t EspClass::getFlashChipSizeByChipId(void) {
uint32_t chipId = getFlashChipId();
switch(chipId) {
// GigaDevice
case 0x1740C8: // GD25Q64B
return (8_MB);
case 0x1640C8: // GD25Q32B
@ -243,6 +246,15 @@ uint32_t EspClass::getFlashChipSizeByChipId(void) {
return (128_kB);
case 0x1040C8: // GD25Q12
return (64_kB);
// Winbond
case 0x1640EF: // W25Q32
return (4_MB);
case 0x1540EF: // W25Q16
return (2_MB);
case 0x1440EF: // W25Q80
return (1_MB);
default:
return 0;
}

116
cores/esp8266/HardwareSerial.cpp
View File

@ -41,6 +41,20 @@ extern "C" {
#define UART_TX_FIFO_SIZE 0x80
struct uart_ {
int uart_nr;
int baud_rate;
bool rxEnabled;
bool txEnabled;
uint8_t rxPin;
uint8_t txPin;
};
static const int UART0 = 0;
static const int UART1 = 1;
static const int UART_NO = -1;
/**
* UART GPIOs
*
@ -86,7 +100,7 @@ void uart_disarm_tx_interrupt(uart_t* uart);
void uart_set_baudrate(uart_t* uart, int baud_rate);
int uart_get_baudrate(uart_t* uart);
uart_t* uart_init(UARTnr_t uart_nr, int baudrate, byte config);
uart_t* uart_init(int uart_nr, int baudrate, byte config);
void uart_uninit(uart_t* uart);
void uart_swap(uart_t* uart);
@ -94,8 +108,8 @@ void uart_ignore_char(char c);
void uart0_write_char(char c);
void uart1_write_char(char c);
void uart_set_debug(UARTnr_t uart_nr);
UARTnr_t uart_get_debug();
void uart_set_debug(int uart_nr);
int uart_get_debug();
// ####################################################################################################
// ####################################################################################################
@ -108,12 +122,12 @@ void ICACHE_RAM_ATTR uart_interrupt_handler(uart_t* uart) {
if(Serial.isRxEnabled()) {
if(status & (1 << UIFF)) {
while(true) {
int rx_count = (U0S >> USTXC) & 0xFF;
int rx_count = (U0S >> USTXC) & 0xff;
if(!rx_count)
break;
while(rx_count--) {
char c = U0F & 0xFF;
char c = U0F & 0xff;
Serial._rx_complete_irq(c);
}
}
@ -133,12 +147,12 @@ void ICACHE_RAM_ATTR uart_interrupt_handler(uart_t* uart) {
if(Serial1.isRxEnabled()) {
if(status & (1 << UIFF)) {
while(true) {
int rx_count = (U1S >> USTXC) & 0xFF;
int rx_count = (U1S >> USTXC) & 0xff;
if(!rx_count)
break;
while(rx_count--) {
char c = U1F & 0xFF;
char c = U1F & 0xff;
Serial1._rx_complete_irq(c);
}
}
@ -156,28 +170,28 @@ void ICACHE_RAM_ATTR uart_interrupt_handler(uart_t* uart) {
// ####################################################################################################
void ICACHE_FLASH_ATTR uart_wait_for_tx_fifo(uart_t* uart, size_t size_needed) {
void uart_wait_for_tx_fifo(uart_t* uart, size_t size_needed) {
if(uart == 0)
return;
if(uart->txEnabled) {
while(true) {
size_t tx_count = (USS(uart->uart_nr) >> USTXC) & 0xFF;
size_t tx_count = (USS(uart->uart_nr) >> USTXC) & 0xff;
if(tx_count <= (UART_TX_FIFO_SIZE - size_needed))
break;
}
}
}
size_t ICACHE_FLASH_ATTR uart_get_tx_fifo_room(uart_t* uart) {
size_t uart_get_tx_fifo_room(uart_t* uart) {
if(uart == 0)
return 0;
if(uart->txEnabled) {
return UART_TX_FIFO_SIZE - ((USS(uart->uart_nr) >> USTXC) & 0xFF);
return UART_TX_FIFO_SIZE - ((USS(uart->uart_nr) >> USTXC) & 0xff);
}
return 0;
}
void ICACHE_FLASH_ATTR uart_wait_for_transmit(uart_t* uart) {
void uart_wait_for_transmit(uart_t* uart) {
if(uart == 0)
return;
if(uart->txEnabled) {
@ -185,7 +199,7 @@ void ICACHE_FLASH_ATTR uart_wait_for_transmit(uart_t* uart) {
}
}
void ICACHE_FLASH_ATTR uart_transmit_char(uart_t* uart, char c) {
void uart_transmit_char(uart_t* uart, char c) {
if(uart == 0)
return;
if(uart->txEnabled) {
@ -193,7 +207,7 @@ void ICACHE_FLASH_ATTR uart_transmit_char(uart_t* uart, char c) {
}
}
void ICACHE_FLASH_ATTR uart_transmit(uart_t* uart, const char* buf, size_t size) {
void uart_transmit(uart_t* uart, const char* buf, size_t size) {
if(uart == 0)
return;
if(uart->txEnabled) {
@ -208,7 +222,7 @@ void ICACHE_FLASH_ATTR uart_transmit(uart_t* uart, const char* buf, size_t size)
}
}
void ICACHE_FLASH_ATTR uart_flush(uart_t* uart) {
void uart_flush(uart_t* uart) {
uint32_t tmp = 0x00000000;
if(uart == 0)
@ -226,7 +240,7 @@ void ICACHE_FLASH_ATTR uart_flush(uart_t* uart) {
USC0(uart->uart_nr) &= ~(tmp);
}
void ICACHE_FLASH_ATTR uart_interrupt_enable(uart_t* uart) {
void uart_interrupt_enable(uart_t* uart) {
if(uart == 0)
return;
USIC(uart->uart_nr) = 0x1ff;
@ -237,7 +251,7 @@ void ICACHE_FLASH_ATTR uart_interrupt_enable(uart_t* uart) {
ETS_UART_INTR_ENABLE();
}
void ICACHE_FLASH_ATTR uart_interrupt_disable(uart_t* uart) {
void uart_interrupt_disable(uart_t* uart) {
if(uart == 0)
return;
if(uart->rxEnabled) {
@ -249,7 +263,7 @@ void ICACHE_FLASH_ATTR uart_interrupt_disable(uart_t* uart) {
//ETS_UART_INTR_DISABLE(); // never disable irq complete may its needed by the other Serial Interface!
}
void ICACHE_FLASH_ATTR uart_arm_tx_interrupt(uart_t* uart) {
void uart_arm_tx_interrupt(uart_t* uart) {
if(uart == 0)
return;
if(uart->txEnabled) {
@ -257,7 +271,7 @@ void ICACHE_FLASH_ATTR uart_arm_tx_interrupt(uart_t* uart) {
}
}
void ICACHE_FLASH_ATTR uart_disarm_tx_interrupt(uart_t* uart) {
void uart_disarm_tx_interrupt(uart_t* uart) {
if(uart == 0)
return;
if(uart->txEnabled) {
@ -265,20 +279,20 @@ void ICACHE_FLASH_ATTR uart_disarm_tx_interrupt(uart_t* uart) {
}
}
void ICACHE_FLASH_ATTR uart_set_baudrate(uart_t* uart, int baud_rate) {
void uart_set_baudrate(uart_t* uart, int baud_rate) {
if(uart == 0)
return;
uart->baud_rate = baud_rate;
USD(uart->uart_nr) = (80000000UL / uart->baud_rate);
}
int ICACHE_FLASH_ATTR uart_get_baudrate(uart_t* uart) {
int uart_get_baudrate(uart_t* uart) {
if(uart == 0)
return 0;
return uart->baud_rate;
}
uart_t* ICACHE_FLASH_ATTR uart_init(UARTnr_t uart_nr, int baudrate, byte config) {
uart_t* uart_init(int uart_nr, int baudrate, byte config) {
uint32_t conf1 = 0x00000000;
uart_t* uart = (uart_t*) os_malloc(sizeof(uart_t));
@ -329,7 +343,7 @@ uart_t* ICACHE_FLASH_ATTR uart_init(UARTnr_t uart_nr, int baudrate, byte config)
return uart;
}
void ICACHE_FLASH_ATTR uart_uninit(uart_t* uart) {
void uart_uninit(uart_t* uart) {
if(uart == 0)
return;
uart_interrupt_disable(uart);
@ -358,7 +372,7 @@ void ICACHE_FLASH_ATTR uart_uninit(uart_t* uart) {
os_free(uart);
}
void ICACHE_FLASH_ATTR uart_swap(uart_t* uart) {
void uart_swap(uart_t* uart) {
if(uart == 0)
return;
switch(uart->uart_nr) {
@ -394,10 +408,10 @@ void ICACHE_FLASH_ATTR uart_swap(uart_t* uart) {
// ####################################################################################################
// ####################################################################################################
void ICACHE_FLASH_ATTR uart_ignore_char(char c) {
void uart_ignore_char(char c) {
}
void ICACHE_FLASH_ATTR uart0_write_char(char c) {
void uart0_write_char(char c) {
if(&Serial != NULL && Serial.isTxEnabled()) {
if(c == '\n') {
Serial.write('\r');
@ -411,7 +425,7 @@ void ICACHE_FLASH_ATTR uart0_write_char(char c) {
}
}
void ICACHE_FLASH_ATTR uart1_write_char(char c) {
void uart1_write_char(char c) {
if(&Serial1 != NULL && Serial1.isTxEnabled()) {
if(c == '\n') {
Serial1.write('\r');
@ -425,8 +439,9 @@ void ICACHE_FLASH_ATTR uart1_write_char(char c) {
}
}
static UARTnr_t s_uart_debug_nr = UART0;
void ICACHE_FLASH_ATTR uart_set_debug(UARTnr_t uart_nr) {
static int s_uart_debug_nr = UART0;
void uart_set_debug(int uart_nr) {
s_uart_debug_nr = uart_nr;
switch(s_uart_debug_nr) {
case UART0:
@ -445,7 +460,7 @@ void ICACHE_FLASH_ATTR uart_set_debug(UARTnr_t uart_nr) {
}
}
UARTnr_t ICACHE_FLASH_ATTR uart_get_debug() {
int uart_get_debug() {
return s_uart_debug_nr;
}
@ -453,12 +468,11 @@ UARTnr_t ICACHE_FLASH_ATTR uart_get_debug() {
// ####################################################################################################
// ####################################################################################################
ICACHE_FLASH_ATTR HardwareSerial::HardwareSerial(UARTnr_t uart_nr) :
_uart(0), _tx_buffer(0), _rx_buffer(0), _written(false) {
_uart_nr = uart_nr;
HardwareSerial::HardwareSerial(int uart_nr) :
_uart_nr(uart_nr), _uart(0), _tx_buffer(0), _rx_buffer(0), _written(false) {
}
void ICACHE_FLASH_ATTR HardwareSerial::begin(unsigned long baud, byte config) {
void HardwareSerial::begin(unsigned long baud, byte config) {
// disable debug for this interface
if(uart_get_debug() == _uart_nr) {
@ -472,16 +486,18 @@ void ICACHE_FLASH_ATTR HardwareSerial::begin(unsigned long baud, byte config) {
}
if(_uart->rxEnabled) {
_rx_buffer = new cbuf(SERIAL_RX_BUFFER_SIZE);
if (!_rx_buffer)
_rx_buffer = new cbuf(SERIAL_RX_BUFFER_SIZE);
}
if(_uart->txEnabled) {
_tx_buffer = new cbuf(SERIAL_TX_BUFFER_SIZE);
if (!_tx_buffer)
_tx_buffer = new cbuf(SERIAL_TX_BUFFER_SIZE);
}
_written = false;
delay(1);
}
void ICACHE_FLASH_ATTR HardwareSerial::end() {
void HardwareSerial::end() {
if(uart_get_debug() == _uart_nr) {
uart_set_debug(UART_NO);
}
@ -493,13 +509,13 @@ void ICACHE_FLASH_ATTR HardwareSerial::end() {
_tx_buffer = 0;
}
void ICACHE_FLASH_ATTR HardwareSerial::swap() {
void HardwareSerial::swap() {
if(_uart == 0)
return;
uart_swap(_uart);
}
void ICACHE_FLASH_ATTR HardwareSerial::setDebugOutput(bool en) {
void HardwareSerial::setDebugOutput(bool en) {
if(_uart == 0)
return;
if(en) {
@ -512,19 +528,19 @@ void ICACHE_FLASH_ATTR HardwareSerial::setDebugOutput(bool en) {
}
}
bool ICACHE_FLASH_ATTR HardwareSerial::isTxEnabled(void) {
bool HardwareSerial::isTxEnabled(void) {
if(_uart == 0)
return false;
return _uart->txEnabled;
}
bool ICACHE_FLASH_ATTR HardwareSerial::isRxEnabled(void) {
bool HardwareSerial::isRxEnabled(void) {
if(_uart == 0)
return false;
return _uart->rxEnabled;
}
int ICACHE_FLASH_ATTR HardwareSerial::available(void) {
int HardwareSerial::available(void) {
if(_uart == 0)
return 0;
if(_uart->rxEnabled) {
@ -534,7 +550,7 @@ int ICACHE_FLASH_ATTR HardwareSerial::available(void) {
}
}
int ICACHE_FLASH_ATTR HardwareSerial::peek(void) {
int HardwareSerial::peek(void) {
if(_uart == 0)
return -1;
if(_uart->rxEnabled) {
@ -544,7 +560,7 @@ int ICACHE_FLASH_ATTR HardwareSerial::peek(void) {
}
}
int ICACHE_FLASH_ATTR HardwareSerial::read(void) {
int HardwareSerial::read(void) {
if(_uart == 0)
return -1;
if(_uart->rxEnabled) {
@ -554,7 +570,7 @@ int ICACHE_FLASH_ATTR HardwareSerial::read(void) {
}
}
int ICACHE_FLASH_ATTR HardwareSerial::availableForWrite(void) {
int HardwareSerial::availableForWrite(void) {
if(_uart == 0)
return 0;
if(_uart->txEnabled) {
@ -564,7 +580,7 @@ int ICACHE_FLASH_ATTR HardwareSerial::availableForWrite(void) {
}
}
void ICACHE_FLASH_ATTR HardwareSerial::flush() {
void HardwareSerial::flush() {
if(_uart == 0)
return;
if(!_uart->txEnabled)
@ -578,7 +594,7 @@ void ICACHE_FLASH_ATTR HardwareSerial::flush() {
_written = false;
}
size_t ICACHE_FLASH_ATTR HardwareSerial::write(uint8_t c) {
size_t HardwareSerial::write(uint8_t c) {
if(_uart == 0 || !_uart->txEnabled)
return 0;
_written = true;
@ -599,17 +615,17 @@ size_t ICACHE_FLASH_ATTR HardwareSerial::write(uint8_t c) {
return 1;
}
ICACHE_FLASH_ATTR HardwareSerial::operator bool() const {
HardwareSerial::operator bool() const {
return _uart != 0;
}
void ICACHE_FLASH_ATTR HardwareSerial::_rx_complete_irq(char c) {
void HardwareSerial::_rx_complete_irq(char c) {
if(_rx_buffer) {
_rx_buffer->write(c);
}
}
void ICACHE_FLASH_ATTR HardwareSerial::_tx_empty_irq(void) {
void HardwareSerial::_tx_empty_irq(void) {
if(_uart == 0)
return;
if(_tx_buffer == 0)

20
cores/esp8266/HardwareSerial.h
View File

@ -62,29 +62,19 @@
class cbuf;
typedef enum {
UART0 = 0, UART1 = 1, UART_NO = 0xFF
} UARTnr_t;
typedef struct {
UARTnr_t uart_nr;
int baud_rate;
bool rxEnabled;
bool txEnabled;
uint8_t rxPin;
uint8_t txPin;
} uart_t;
struct uart_;
typedef struct uart_ uart_t;
class HardwareSerial: public Stream {
public:
HardwareSerial(UARTnr_t uart_nr);
HardwareSerial(int uart_nr);
void begin(unsigned long baud) {
begin(baud, SERIAL_8N1);
}
void begin(unsigned long, uint8_t);
void end();
void swap(); //use GPIO13 and GPIO15 as RX and TX
void swap(); //toggle between use of GPIO13/GPIO15 or GPIO3/GPIO1 as RX and TX
int available(void) override;
int peek(void) override;
int read(void) override;
@ -116,7 +106,7 @@ class HardwareSerial: public Stream {
void _tx_empty_irq(void);
protected:
UARTnr_t _uart_nr;
int _uart_nr;
uart_t* _uart;
cbuf* _tx_buffer;
cbuf* _rx_buffer;

2
libraries/ESP8266WebServer/examples/HelloServer/HelloServer.ino
View File

@ -19,7 +19,7 @@ void handleRoot() {
void handleNotFound(){
digitalWrite(led, 1);
String message += "File Not Found\n\n";
String message = "File Not Found\n\n";
message += "URI: ";
message += server.uri();
message += "\nMethod: ";

8
libraries/Wire/Wire.cpp
View File

@ -45,6 +45,9 @@ uint8_t TwoWire::transmitting = 0;
void (*TwoWire::user_onRequest)(void);
void (*TwoWire::user_onReceive)(int);
static int default_sda_pin = SDA;
static int default_scl_pin = SCL;
// Constructors ////////////////////////////////////////////////////////////////
TwoWire::TwoWire(){}
@ -57,11 +60,12 @@ void TwoWire::begin(int sda, int scl){
}
void TwoWire::pins(int sda, int scl){
twi_init(sda, scl);
default_sda_pin = sda;
default_scl_pin = scl;
}
void TwoWire::begin(void){
begin(SDA, SCL);
begin(default_sda_pin, default_scl_pin);
}
void TwoWire::begin(uint8_t address){