Merge branch 'ficeto-esp8266' into esp8266

* ficeto-esp8266: (28 commits)
  fix uart receive
  add method to check for clients without referencing them
  move discard_cb to unref
  add close and abort methods and enable disconnect callback
  removing timer aliases
  Add option to select SPI speed at SD::begin
  add pwm freq adjustment
  fix PWM and Timer1
  plaintext POST fixes and rework of the SD example
  fix binary file http upload
  some speed optimizations
  fix SPI run on system clock
  add esp8266_tcp_active_close.png image
  * miss to add the new files
  rework Adafruit_ILI9341 complete now uses the new SPI implementation tested with example graphicstest_esp8266
  increase SD Card SPI Speed
  fix SPI clock for SD library
  fix huge leak
  add proper POST support and more methods
  use a function to calculate best match clock register for SPI
  ...

Author: igrr

README.md

@@ -132,7 +132,8 @@ else they default to pins 4(SDA) and 5(SCL).
 
 #### SPI ####
 
-SPI library supports the entire Arduino SPI API including transactions, including setting phase and polarity.
+SPI library supports the entire Arduino SPI API including transactions, including setting phase (CPHA).
+Setting the Clock polarity (CPOL) is not supported, yet (SPI_MODE2 and SPI_MODE3 not working).
 
 #### ESP-specific APIs ####
 

docs/esp8266_tcp_active_close.png

@@ -124,8 +124,17 @@ void timer1_write(uint32_t ticks); //maximum ticks 8388607
 void ets_intr_lock();
 void ets_intr_unlock();
 
-#define interrupts() ets_intr_unlock();
-#define noInterrupts() ets_intr_lock();
+// level (0-15), 
+// level 15 will disable ALL interrupts, 
+// level 0 will disable most software interrupts
+//
+#define xt_disable_interrupts(state, level) __asm__ __volatile__("rsil %0," __STRINGIFY(level) "; esync; isync; dsync" : "=a" (state))
+#define xt_enable_interrupts(state)  __asm__ __volatile__("wsr %0,ps; esync" :: "a" (state) : "memory")
+
+extern uint32_t interruptsState;
+
+#define interrupts() xt_enable_interrupts(interruptsState)
+#define noInterrupts() xt_disable_interrupts(interruptsState, 15)
 
 #define clockCyclesPerMicrosecond() ( F_CPU / 1000000L )
 #define clockCyclesToMicroseconds(a) ( (a) / clockCyclesPerMicrosecond() )
@@ -163,6 +172,7 @@ int digitalRead(uint8_t);
 int analogRead(uint8_t);
 void analogReference(uint8_t mode);
 void analogWrite(uint8_t, int);
+void analogWriteFreq(uint32_t freq);
 
 unsigned long millis(void);
 unsigned long micros(void);

hardware/esp8266com/esp8266/cores/esp8266/Arduino.h

@@ -227,6 +227,13 @@ FlashMode_t EspClass::getFlashChipMode(void)
  */
 uint32_t EspClass::getFlashChipSizeByChipId(void) {
     uint32_t chipId = getFlashChipId();
+    /**
+     * Chip ID
+     * 00 - always 00 (Chip ID use only 3 byte)
+     * 17 - ? looks like 2^xx is size in Byte ?     //todo: find docu to this
+     * 40 - ? may be Speed ?                        //todo: find docu to this
+     * C8 - manufacturer ID
+     */
     switch(chipId) {
 
         // GigaDevice

hardware/esp8266com/esp8266/cores/esp8266/Esp.cpp

@@ -95,8 +95,16 @@ class EspClass {
         FlashMode_t getFlashChipMode(void);
         uint32_t getFlashChipSizeByChipId(void);
 
+        inline uint32_t getCycleCount(void);
 };
 
+uint32_t EspClass::getCycleCount(void)
+{
+    uint32_t ccount;
+    __asm__ __volatile__("rsr %0,ccount":"=a" (ccount));
+    return ccount;
+}
+
 extern EspClass ESP;
 
 #endif //ESP_H

hardware/esp8266com/esp8266/cores/esp8266/Esp.h

@@ -118,50 +118,29 @@ int uart_get_debug();
 void ICACHE_RAM_ATTR uart_interrupt_handler(uart_t* uart) {
 
     // -------------- UART 0 --------------
-    uint32_t status = U0IS;
     if(Serial.isRxEnabled()) {
-        if(status & (1 << UIFF)) {
-            while(true) {
-                int rx_count = (U0S >> USTXC) & 0xff;
-                if(!rx_count)
-                    break;
-
-                while(rx_count--) {
-                    char c = U0F & 0xff;
-                    Serial._rx_complete_irq(c);
-                }
-            }
+        while(U0IS & (1 << UIFF)) {
+            Serial._rx_complete_irq((char)(U0F & 0xff));
             U0IC = (1 << UIFF);
         }
     }
     if(Serial.isTxEnabled()) {
-        if(status & (1 << UIFE)) {
+        if(U0IS & (1 << UIFE)) {
             U0IC = (1 << UIFE);
             Serial._tx_empty_irq();
         }
     }
 
     // -------------- UART 1 --------------
 
-    status = U1IS;
     if(Serial1.isRxEnabled()) {
-        if(status & (1 << UIFF)) {
-            while(true) {
-                int rx_count = (U1S >> USTXC) & 0xff;
-                if(!rx_count)
-                    break;
-
-                while(rx_count--) {
-                    char c = U1F & 0xff;
-                    Serial1._rx_complete_irq(c);
-                }
-            }
+        while(U1IS & (1 << UIFF)) {
+            Serial1._rx_complete_irq((char)(U1F & 0xff));
             U1IC = (1 << UIFF);
         }
     }
     if(Serial1.isTxEnabled()) {
-        status = U1IS;
-        if(status & (1 << UIFE)) {
+        if(U1IS & (1 << UIFE)) {
             U1IC = (1 << UIFE);
             Serial1._tx_empty_irq();
         }

hardware/esp8266com/esp8266/cores/esp8266/HardwareSerial.cpp

@@ -30,6 +30,10 @@ void timer1_isr_handler(void *para){
     if(timer1_user_cb) timer1_user_cb();
 }
 
+void timer1_isr_init(){
+    ETS_FRC_TIMER1_INTR_ATTACH(timer1_isr_handler, NULL);
+}
+
 void timer1_attachInterrupt(void (*userFunc)(void)) {
     timer1_user_cb = userFunc;
     ETS_FRC1_INTR_ENABLE();
@@ -55,7 +59,3 @@ void timer1_disable(){
     T1C = 0;
     T1I = 0;
 }
-
-void timer1_isr_init(){
-    ETS_FRC_TIMER1_INTR_ATTACH(timer1_isr_handler, NULL);
-}

hardware/esp8266com/esp8266/cores/esp8266/core_esp8266_timer.c

@@ -75,6 +75,7 @@ void delayMicroseconds(unsigned int us) {
 
 void init() {
     initPins();
+    timer1_isr_init();
     os_timer_setfn(&micros_overflow_timer, (os_timer_func_t*) &micros_overflow_tick, 0);
     os_timer_arm(&micros_overflow_timer, 60000, REPEAT);
 }

hardware/esp8266com/esp8266/cores/esp8266/core_esp8266_wiring.c

@@ -139,6 +139,9 @@ extern void __detachInterrupt(uint8_t pin) {
   }
 }
 
+// stored state for the noInterrupts/interrupts methods
+uint32_t interruptsState = 0;
+
 void initPins() {
   //Disable UART interrupts
   system_set_os_print(0);

hardware/esp8266com/esp8266/cores/esp8266/core_esp8266_wiring_digital.c

@@ -139,4 +139,10 @@ extern void __analogWrite(uint8_t pin, int value) {
 	}
 }
 
+extern void __analogWriteFreq(uint32_t freq){
+  pwm_freq = freq;
+  prep_pwm_steps();
+}
+
 extern void analogWrite(uint8_t pin, int val) __attribute__ ((weak, alias("__analogWrite")));
+extern void analogWriteFreq(uint32_t freq) __attribute__ ((weak, alias("__analogWriteFreq")));