docs: Bump version to 1.7.

When lwIP creates a incoming connection socket of a listen socket, it
sets its recv callback to one which discards incoming data. We set
proper callback only in accept() call, when we allocate Python-level
socket where we can queue incoming data. So, in lwIP accept callback
be sure to set recv callback to one which tells lwIP to not discard
incoming data.

.travis.yml

@@ -1,22 +1,31 @@
+sudo: required
+dist: trusty
 language: c
 compiler:
   - gcc
 
 before_script:
-  - sudo add-apt-repository -y ppa:fkrull/deadsnakes
-  - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
+# Extra CPython versions
+#  - sudo add-apt-repository -y ppa:fkrull/deadsnakes
+# Extra gcc versions
+#  - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
   - sudo add-apt-repository -y ppa:terry.guo/gcc-arm-embedded
-  - sudo apt-get update -qq
-  - sudo apt-get install -y python3.4 python3 gcc-4.7 gcc-multilib gcc-arm-none-eabi qemu-system mingw32
+  - sudo dpkg --add-architecture i386
+  - sudo apt-get update -qq || true
+  - sudo apt-get install -y python3 gcc-multilib gcc-arm-none-eabi pkg-config libffi-dev libffi-dev:i386 qemu-system mingw32
   # For teensy build
   - sudo apt-get install realpath
   # For coverage testing
   - sudo pip install cpp-coveralls
+  - gcc --version
+  - arm-none-eabi-gcc --version
+  - python3 --version
 
 script:
   - make -C minimal test
-  - make -C unix deplibs CC=gcc-4.7
-  - make -C unix CC=gcc-4.7
+  - make -C unix deplibs
+  - make -C unix
+  - make -C unix nanbox
   - make -C bare-arm
   - make -C qemu-arm test
   - make -C stmhal
@@ -32,12 +41,12 @@ script:
   #- (cd tests && MICROPY_CPYTHON3=python3.4 ./run-tests --emit native)
 
   # run tests with coverage info
-  - make -C unix CC=gcc-4.7 coverage
+  - make -C unix coverage
   - (cd tests && MICROPY_CPYTHON3=python3.4 MICROPY_MICROPYTHON=../unix/micropython_coverage ./run-tests)
   - (cd tests && MICROPY_CPYTHON3=python3.4 MICROPY_MICROPYTHON=../unix/micropython_coverage ./run-tests --emit native)
 
 after_success:
-  - (cd unix && coveralls --root .. --build-root . --gcov $(which gcov-4.7) --gcov-options '\-o build-coverage/' --include py --include extmod)
+  - (cd unix && coveralls --root .. --build-root . --gcov $(which gcov) --gcov-options '\-o build-coverage/' --include py --include extmod)
 
 after_failure:
   - (cd tests && for exp in *.exp; do testbase=$(basename $exp .exp); echo -e "\nFAILURE $testbase"; diff -u $testbase.exp $testbase.out; done)

README.md

@@ -16,6 +16,7 @@ The MicroPython project
 
 This is the MicroPython project, which aims to put an implementation
 of Python 3.x on microcontrollers and small embedded systems.
+You can find the official website at [micropython.org](http://www.micropython.org).
 
 WARNING: this project is in beta stage and is subject to changes of the
 code-base, including project-wide name changes and API changes.
@@ -129,7 +130,7 @@ The STM version
 
 The "stmhal" port requires an ARM compiler, arm-none-eabi-gcc, and associated
 bin-utils.  For those using Arch Linux, you need arm-none-eabi-binutils and
-arm-none-eabi-gcc packages from the AUR.  Otherwise, try here:
+arm-none-eabi-gcc packages.  Otherwise, try here:
 https://launchpad.net/gcc-arm-embedded
 
 To build:
@@ -145,9 +146,7 @@ Then to flash the code via USB DFU to your device:
 
     $ make deploy
 
-You will need the dfu-util program, on Arch Linux it's dfu-util-git in the
-AUR.  If the above does not work it may be because you don't have the
-correct permissions.  Try then:
-
-    $ sudo dfu-util -a 0 -d 0483:df11 -D build-PYBV10/firmware.dfu
-
+This will use the included `tools/pydfu.py` script.  If flashing the firmware
+does not work it may be because you don't have the correct permissions, and
+need to use `sudo make deploy`.
+See the README.md file in the stmhal/ directory for further details.

bare-arm/main.c

@@ -45,7 +45,7 @@ mp_import_stat_t mp_import_stat(const char *path) {
     return MP_IMPORT_STAT_NO_EXIST;
 }
 
-mp_obj_t mp_builtin_open(uint n_args, const mp_obj_t *args, mp_map_t *kwargs) {
+mp_obj_t mp_builtin_open(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
     return mp_const_none;
 }
 MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_open_obj, 1, mp_builtin_open);

cc3200/Makefile

@@ -17,7 +17,7 @@ include ../py/mkenv.mk
 CROSS_COMPILE ?= arm-none-eabi-
 
 CFLAGS_CORTEX_M4 = -mthumb -mtune=cortex-m4 -march=armv7e-m -mabi=aapcs -mcpu=cortex-m4 -msoft-float -mfloat-abi=soft -fsingle-precision-constant -Wdouble-promotion
-CFLAGS = -Wall -Wpointer-arith -Werror -ansi -std=gnu99 -nostdlib $(CFLAGS_CORTEX_M4)
+CFLAGS = -Wall -Wpointer-arith -Werror -ansi -std=gnu99 -nostdlib $(CFLAGS_CORTEX_M4) -Os
 CFLAGS += -g -ffunction-sections -fdata-sections -fno-common -fsigned-char -mno-unaligned-access
 CFLAGS += -Iboards/$(BOARD)
 

cc3200/application.lds

@@ -24,7 +24,7 @@
  * THE SOFTWARE.
  */
 
-__stack_size__    = 3K;       /* interrupts are handled within this stack */
+__stack_size__    = 2K;       /* interrupts are handled within this stack */
 __min_heap_size__ = 8K;
 
 MEMORY

cc3200/application.mk

@@ -157,7 +157,7 @@ APP_LIB_SRC_C = $(addprefix lib/,\
 	
 APP_STM_SRC_C = $(addprefix stmhal/,\
 	bufhelper.c \
-	file.c \
+	builtin_open.c \
 	import.c \
 	input.c \
 	irq.c \
@@ -183,31 +183,10 @@ $(BUILD)/drivers/cc3100/src/driver.o: CFLAGS += -fno-strict-aliasing
 
 # Check if we would like to debug the port code
 ifeq ($(BTYPE), release)
-# Optimize everything and define the NDEBUG flag
-CFLAGS += -Os -DNDEBUG
+CFLAGS += -DNDEBUG
 else
 ifeq ($(BTYPE), debug)
-# Define the DEBUG flag
-CFLAGS += -DDEBUG=DEBUG
-# Optimize the stable sources only
-$(BUILD)/extmod/%.o: CFLAGS += -Os
-$(BUILD)/lib/%.o: CFLAGS += -Os
-$(BUILD)/fatfs/src/%.o: CFLAGS += -Os
-$(BUILD)/FreeRTOS/Source/%.o: CFLAGS += -Os
-$(BUILD)/ftp/%.o: CFLAGS += -Os
-$(BUILD)/hal/%.o: CFLAGS += -Os
-$(BUILD)/misc/%.o: CFLAGS += -Os
-$(BUILD)/mods/%.o: CFLAGS += -Os
-$(BUILD)/py/%.o: CFLAGS += -Os
-$(BUILD)/simplelink/%.o: CFLAGS += -Os
-$(BUILD)/drivers/cc3100/%.o: CFLAGS += -Os
-$(BUILD)/stmhal/%.o: CFLAGS += -Os
-$(BUILD)/telnet/%.o: CFLAGS += -Os
-$(BUILD)/util/%.o: CFLAGS += -Os
-$(BUILD)/pins.o: CFLAGS += -Os
-$(BUILD)/main.o: CFLAGS += -Os
-$(BUILD)/mptask.o: CFLAGS += -Os
-$(BUILD)/servertask.o: CFLAGS += -Os
+CFLAGS += -DNDEBUG
 else
 $(error Invalid BTYPE specified)
 endif

cc3200/boards/cc3200_af.csv

@@ -1,11 +1,11 @@
 Pin,Name,Default,AF0,AF1,AF2,AF3,AF4,AF5,AF6,AF7,AF8,AF9,AF10,AF11,AF12,AF13,AF14,AF15,ADC
-1,GP10,GP10,GP10,I2C0_SCL,,TIM3_PWM0,,,SD0_CLK,UART1_TX,,,,,TIM0_CC1,,,,
-2,GP11,GP11,GP11,I2C0_SDA,,TIM3_PWM1,pXCLK(XVCLK),,SD0_CMD,UART1_RX,,,,,TIM1_CC0,I2S0_FS,,,
-3,GP12,GP12,GP12,,,I2S0_CLK,pVS(VSYNC),I2C0_SCL,,UART0_TX,,,,,TIM1_CC1,,,,
-4,GP13,GP13,GP13,,,,pHS(HSYNC),I2C0_SDA,,UART0_RX,,,,,TIM2_CC0,,,,
-5,GP14,GP14,GP14,,,,pDATA8(CAM_D4),I2C0_SCL,,SPI0_CLK,,,,,TIM2_CC1,,,,
-6,GP15,GP15,GP15,,,,pDATA9(CAM_D5),I2C0_SDA,,SPI0_MISO,SD0_DAT0,,,,,TIM3_CC0,,,
-7,GP16,GP16,GP16,,,,pDATA10(CAM_D6),UART1_TX,,SPI0_MOSI,SD0_CLK,,,,,TIM3_CC1,,,
+1,GP10,GP10,GP10,I2C0_SCL,,TIM3_PWM,,,SD0_CLK,UART1_TX,,,,,TIM0_CC,,,,
+2,GP11,GP11,GP11,I2C0_SDA,,TIM3_PWM,pXCLK(XVCLK),,SD0_CMD,UART1_RX,,,,,TIM1_CC,I2S0_FS,,,
+3,GP12,GP12,GP12,,,I2S0_CLK,pVS(VSYNC),I2C0_SCL,,UART0_TX,,,,,TIM1_CC,,,,
+4,GP13,GP13,GP13,,,,pHS(HSYNC),I2C0_SDA,,UART0_RX,,,,,TIM2_CC,,,,
+5,GP14,GP14,GP14,,,,pDATA8(CAM_D4),I2C0_SCL,,SPI0_CLK,,,,,TIM2_CC,,,,
+6,GP15,GP15,GP15,,,,pDATA9(CAM_D5),I2C0_SDA,,SPI0_MISO,SD0_DAT0,,,,,TIM3_CC,,,
+7,GP16,GP16,GP16,,,,pDATA10(CAM_D6),UART1_TX,,SPI0_MOSI,SD0_CLK,,,,,TIM3_CC,,,
 8,GP17,GP17,GP17,,,,pDATA11(CAM_D7),UART1_RX,,SPI0_CS0,SD0_CMD,,,,,,,,
 9,VDD_DIG1,VDD_DIG1,VDD_DIG1,,,,,,,,,,,,,,,,
 10,VIN_IO1,VIN_IO1,VIN_IO1,,,,,,,,,,,,,,,,
@@ -13,13 +13,13 @@ Pin,Name,Default,AF0,AF1,AF2,AF3,AF4,AF5,AF6,AF7,AF8,AF9,AF10,AF11,AF12,AF13,AF1
 12,FLASH_SPI_DOUT,FLASH_SPI_DOUT,FLASH_SPI_DOUT,,,,,,,,,,,,,,,,
 13,FLASH_SPI_DIN,FLASH_SPI_DIN,FLASH_SPI_DIN,,,,,,,,,,,,,,,,
 14,FLASH_SPI_CS,FLASH_SPI_CS,FLASH_SPI_CS,,,,,,,,,,,,,,,,
-15,GP22,GP22,GP22,,,,,TIM2_CC0,,I2S0_FS,,,,,,,,,
+15,GP22,GP22,GP22,,,,,TIM2_CC,,I2S0_FS,,,,,,,,,
 16,GP23,TDI,GP23,TDI,UART1_TX,,,,,,,I2C0_SCL,,,,,,,
-17,GP24,TDO,GP24,TDO,UART1_RX,,TIM3_CC0,TIM0_PWM0,I2S0_FS,,,I2C0_SDA,,,,,,,
+17,GP24,TDO,GP24,TDO,UART1_RX,,TIM3_CC,TIM0_PWM,I2S0_FS,,,I2C0_SDA,,,,,,,
 18,GP28,GP28,GP28,,,,,,,,,,,,,,,,
-19,TCK,TCK,,TCK,,,,,,,TIM1_PWM2,,,,,,,,
+19,TCK,TCK,,TCK,,,,,,,TIM1_PWM,,,,,,,,
 20,GP29,TMS,GP29,TMS,,,,,,,,,,,,,,,
-21,GP25,SOP2,GP25,,I2S0_FS,,,,,,,TIM1_PWM0,,,,,,,
+21,GP25,SOP2,GP25,,I2S0_FS,,,,,,,TIM1_PWM,,,,,,,
 22,WLAN_XTAL_N,WLAN_XTAL_N,WLAN_XTAL_N,,,,,,,,,,,,,,,,
 23,WLAN_XTAL_P,WLAN_XTAL_P,WLAN_XTAL_P,,,,,,,,,,,,,,,,
 24,VDD_PLL,VDD_PLL,VDD_PLL,,,,,,,,,,,,,,,,
@@ -48,19 +48,19 @@ Pin,Name,Default,AF0,AF1,AF2,AF3,AF4,AF5,AF6,AF7,AF8,AF9,AF10,AF11,AF12,AF13,AF1
 47,VDD_ANA2,VDD_ANA2,VDD_ANA2,,,,,,,,,,,,,,,,
 48,VDD_ANA1,VDD_ANA1,VDD_ANA1,,,,,,,,,,,,,,,,
 49,VDD_RAM,VDD_RAM,VDD_RAM,,,,,,,,,,,,,,,,
-50,GP0,GP0,GP0,,,UART0_RTS,I2S0_DAT0,,I2S0_DAT1,TIM0_CC0,,SPI0_CS0,UART1_RTS,,UART0_CTS,,,,
+50,GP0,GP0,GP0,,,UART0_RTS,I2S0_DAT0,,I2S0_DAT1,TIM0_CC,,SPI0_CS0,UART1_RTS,,UART0_CTS,,,,
 51,RTC_XTAL_P,RTC_XTAL_P,RTC_XTAL_P,,,,,,,,,,,,,,,,
 52,RTC_XTAL_N,RTC_XTAL_N,GP32,,I2S0_CLK,,I2S0_DAT0,,UART0_RTS,,SPI0_MOSI,,,,,,,,
-53,GP30,GP30,GP30,,I2S0_CLK,I2S0_FS,TIM2_CC1,,,SPI0_MISO,,UART0_TX,,,,,,,
+53,GP30,GP30,GP30,,I2S0_CLK,I2S0_FS,TIM2_CC,,,SPI0_MISO,,UART0_TX,,,,,,,
 54,VIN_IO2,VIN_IO2,VIN_IO2,,,,,,,,,,,,,,,,
-55,GP1,GP1,GP1,,,UART0_TX,pCLK (PIXCLK),,UART1_TX,TIM0_CC1,,,,,,,,,
+55,GP1,GP1,GP1,,,UART0_TX,pCLK (PIXCLK),,UART1_TX,TIM0_CC,,,,,,,,,
 56,VDD_DIG2,VDD_DIG2,VDD_DIG2,,,,,,,,,,,,,,,,
-57,GP2,GP2,GP2,,,UART0_RX,,,UART1_RX,TIM1_CC0,,,,,,,,,ADC0_CH0
+57,GP2,GP2,GP2,,,UART0_RX,,,UART1_RX,TIM1_CC,,,,,,,,,ADC0_CH0
 58,GP3,GP3,GP3,,,,pDATA7(CAM_D3),,UART1_TX,,,,,,,,,,ADC0_CH1
 59,GP4,GP4,GP4,,,,pDATA6(CAM_D2),,UART1_RX,,,,,,,,,,ADC0_CH2
-60,GP5,GP5,GP5,,,,pDATA5(CAM_D1),,I2S0_DAT1,TIM2_CC1,,,,,,,,,ADC0_CH3
-61,GP6,GP6,GP6,,,UART1_CTS,pDATA4(CAM_D0),UART0_RTS,UART0_CTS,TIM3_CC0,,,,,,,,,
+60,GP5,GP5,GP5,,,,pDATA5(CAM_D1),,I2S0_DAT1,TIM2_CC,,,,,,,,,ADC0_CH3
+61,GP6,GP6,GP6,,,UART1_CTS,pDATA4(CAM_D0),UART0_RTS,UART0_CTS,TIM3_CC,,,,,,,,,
 62,GP7,GP7,GP7,,,UART1_RTS,,,,,,,UART0_RTS,UART0_TX,,I2S0_CLK,,,
-63,GP8,GP8,GP8,,,,,,SD0_IRQ,I2S0_FS,,,,,TIM3_CC0,,,,
-64,GP9,GP9,GP9,,,TIM2_PWM1,,,SD0_DAT0,I2S0_DAT0,,,,,TIM0_CC0,,,,
+63,GP8,GP8,GP8,,,,,,SD0_IRQ,I2S0_FS,,,,,TIM3_CC,,,,
+64,GP9,GP9,GP9,,,TIM2_PWM,,,SD0_DAT0,I2S0_DAT0,,,,,TIM0_CC,,,,
 65,GND_TAB,GND_TAB,GND_TAB,,,,,,,,,,,,,,,,

cc3200/boards/make-pins.py

@@ -12,7 +12,7 @@ SUPPORTED_AFS = { 'UART': ('TX', 'RX', 'RTS', 'CTS'),
                   'SPI': ('CLK', 'MOSI', 'MISO', 'CS0'),
                   #'I2S': ('CLK', 'FS', 'DAT0', 'DAT1'),
                   'I2C': ('SDA', 'SCL'),
-                  'TIM': ('PWM0', 'PWM1', 'CC0', 'CC1'),
+                  'TIM': ('PWM'),
                   'SD': ('CLK', 'CMD', 'DAT0'),
                   'ADC': ('CH0', 'CH1', 'CH2', 'CH3')
                 }
@@ -44,6 +44,7 @@ class AF:
     def print(self):
         print ('    AF({:16s}, {:4d}, {:8s}, {:4d}, {:8s}),    // {}'.format(self.name, self.idx, self.fn, self.unit, self.type, self.name))
 
+
 class Pin:
     """Holds the information associated with a pin."""
     def __init__(self, name, port, gpio_bit, pin_num):

cc3200/bootmgr/main.c

@@ -414,7 +414,7 @@ int main (void) {
 //*****************************************************************************
 #include "py/qstr.h"
 
-const byte *qstr_data(qstr q, mp_uint_t *len) {
+const byte *qstr_data(qstr q, size_t *len) {
     *len = 0;
     return NULL;
 }

cc3200/fatfs/src/drivers/sflash_diskio.c

@@ -96,7 +96,7 @@ DRESULT sflash_disk_status(void) {
     if (!sflash_init_done) {
         return STA_NOINIT;
     }
-    return 0;
+    return RES_OK;
 }
 
 DRESULT sflash_disk_read(BYTE *buff, DWORD sector, UINT count) {
@@ -126,7 +126,7 @@ DRESULT sflash_disk_read(BYTE *buff, DWORD sector, UINT count) {
         }
         // Copy the requested sector from the block cache
         memcpy (buff, &sflash_block_cache[(secindex * SFLASH_SECTOR_SIZE)], SFLASH_SECTOR_SIZE);
-        buff += SFLASH_BLOCK_SIZE;
+        buff += SFLASH_SECTOR_SIZE;
     }
     return RES_OK;
 }
@@ -161,7 +161,7 @@ DRESULT sflash_disk_write(const BYTE *buff, DWORD sector, UINT count) {
         }
         // Copy the input sector to the block cache
         memcpy (&sflash_block_cache[(secindex * SFLASH_SECTOR_SIZE)], buff, SFLASH_SECTOR_SIZE);
-        buff += SFLASH_BLOCK_SIZE;
+        buff += SFLASH_SECTOR_SIZE;
         sflash_cache_is_dirty = true;
     } while (++index < count);
 

cc3200/hal/cc3200_asm.h

@@ -67,6 +67,18 @@ static inline void __set_PRIMASK(uint32_t priMask) {
     __asm volatile ("msr primask, %0" : : "r" (priMask) : "memory");
 }
 
+__attribute__(( always_inline ))
+static inline uint32_t __get_BASEPRI(void) {
+    uint32_t result;
+    __asm volatile ("mrs %0, basepri" : "=r" (result));
+    return(result);
+}
+
+__attribute__(( always_inline ))
+static inline void __set_BASEPRI(uint32_t value) {
+    __asm volatile ("msr basepri, %0" : : "r" (value) : "memory");
+}
+
 __attribute__(( always_inline ))
 static inline void enable_irq(mp_uint_t state) {
     __set_PRIMASK(state);

cc3200/misc/mperror.c

@@ -196,6 +196,10 @@ void nlr_jump_fail(void *val) {
 
 void mperror_enable_heartbeat (bool enable) {
     if (enable) {
+    #ifndef BOOTLOADER
+        // configure the led again
+        pin_config ((pin_obj_t *)&MICROPY_SYS_LED_GPIO, PIN_MODE_0, GPIO_DIR_MODE_OUT, PIN_TYPE_STD, 0, PIN_STRENGTH_6MA);
+    #endif
         mperror_heart_beat.enabled = true;
         mperror_heart_beat.do_disable = false;
         mperror_heartbeat_switch_off();

cc3200/mods/modmachine.c

@@ -165,7 +165,7 @@ STATIC mp_obj_t machine_wake_reason (void) {
 STATIC MP_DEFINE_CONST_FUN_OBJ_0(machine_wake_reason_obj, machine_wake_reason);
 
 STATIC const mp_map_elem_t machine_module_globals_table[] = {
-    { MP_OBJ_NEW_QSTR(MP_QSTR___name__),            MP_OBJ_NEW_QSTR(MP_QSTR_machine) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR___name__),            MP_OBJ_NEW_QSTR(MP_QSTR_umachine) },
 
     { MP_OBJ_NEW_QSTR(MP_QSTR_reset),               (mp_obj_t)&machine_reset_obj },
 #ifdef DEBUG
@@ -212,6 +212,6 @@ STATIC MP_DEFINE_CONST_DICT(machine_module_globals, machine_module_globals_table
 
 const mp_obj_module_t machine_module = {
     .base = { &mp_type_module },
-    .name = MP_QSTR_machine,
+    .name = MP_QSTR_umachine,
     .globals = (mp_obj_dict_t*)&machine_module_globals,
 };

cc3200/mods/modnetwork.c

@@ -91,7 +91,7 @@ STATIC const mp_arg_t network_server_args[] = {
     { MP_QSTR_login,        MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
     { MP_QSTR_timeout,      MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
 };
-STATIC mp_obj_t network_server_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
+STATIC mp_obj_t network_server_make_new(const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
     // parse args
     mp_map_t kw_args;
     mp_map_init_fixed_table(&kw_args, n_kw, all_args + n_args);
@@ -153,7 +153,7 @@ STATIC const mp_map_elem_t mp_module_network_globals_table[] = {
     { MP_OBJ_NEW_QSTR(MP_QSTR_WLAN),                (mp_obj_t)&mod_network_nic_type_wlan },
 
 #if (MICROPY_PORT_HAS_TELNET || MICROPY_PORT_HAS_FTP)
-    { MP_OBJ_NEW_QSTR(MP_QSTR_server),              (mp_obj_t)&network_server_type },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_Server),              (mp_obj_t)&network_server_type },
 #endif
 };
 
@@ -177,7 +177,7 @@ STATIC MP_DEFINE_CONST_DICT(network_server_locals_dict, network_server_locals_di
 
 STATIC const mp_obj_type_t network_server_type = {
     { &mp_type_type },
-    .name = MP_QSTR_server,
+    .name = MP_QSTR_Server,
     .make_new = network_server_make_new,
     .locals_dict = (mp_obj_t)&network_server_locals_dict,
 };

cc3200/mods/moduos.c

@@ -37,7 +37,7 @@
 #include "moduos.h"
 #include "diskio.h"
 #include "sflash_diskio.h"
-#include "file.h"
+#include "extmod/vfs_fat_file.h"
 #include "random.h"
 #include "mpexception.h"
 #include "version.h"

cc3200/mods/modusocket.c

@@ -106,8 +106,10 @@ void modusocket_enter_sleep (void) {
         }
     }
 
-    // wait for any of the sockets to become ready...
-    sl_Select(maxfd + 1, &socketset, NULL, NULL, NULL);
+    if (maxfd > 0) {
+        // wait for any of the sockets to become ready...
+        sl_Select(maxfd + 1, &socketset, NULL, NULL, NULL);
+    }
 }
 
 void modusocket_close_all_user_sockets (void) {
@@ -125,7 +127,7 @@ void modusocket_close_all_user_sockets (void) {
 // socket class
 
 // constructor socket(family=AF_INET, type=SOCK_STREAM, proto=IPPROTO_TCP, fileno=None)
-STATIC mp_obj_t socket_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
+STATIC mp_obj_t socket_make_new(const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
     mp_arg_check_num(n_args, n_kw, 0, 4, false);
 
     // create socket object

cc3200/mods/modwlan.c

@@ -33,6 +33,7 @@
 #include "py/obj.h"
 #include "py/objstr.h"
 #include "py/runtime.h"
+#include "py/stream.h"
 #include "py/mphal.h"
 #include "inc/hw_types.h"
 #include "inc/hw_ints.h"
@@ -149,8 +150,8 @@ STATIC wlan_obj_t wlan_obj = {
         .ssid = MICROPY_PORT_WLAN_AP_SSID,
         .key = MICROPY_PORT_WLAN_AP_KEY,
         .mac = {0},
-        .ssid_o = {0},
-        .bssid = {0},
+        //.ssid_o = {0},
+        //.bssid = {0},
     #if (MICROPY_PORT_HAS_TELNET || MICROPY_PORT_HAS_FTP)
         .servers_enabled = false,
     #endif
@@ -210,11 +211,11 @@ void SimpleLinkWlanEventHandler(SlWlanEvent_t *pWlanEvent) {
     {
         case SL_WLAN_CONNECT_EVENT:
         {
-            slWlanConnectAsyncResponse_t *pEventData = &pWlanEvent->EventData.STAandP2PModeWlanConnected;
+            //slWlanConnectAsyncResponse_t *pEventData = &pWlanEvent->EventData.STAandP2PModeWlanConnected;
             // copy the new connection data
-            memcpy(wlan_obj.bssid, pEventData->bssid, SL_BSSID_LENGTH);
-            memcpy(wlan_obj.ssid_o, pEventData->ssid_name, pEventData->ssid_len);
-            wlan_obj.ssid_o[pEventData->ssid_len] = '\0';
+            //memcpy(wlan_obj.bssid, pEventData->bssid, SL_BSSID_LENGTH);
+            //memcpy(wlan_obj.ssid_o, pEventData->ssid_name, pEventData->ssid_len);
+            //wlan_obj.ssid_o[pEventData->ssid_len] = '\0';
             SET_STATUS_BIT(wlan_obj.status, STATUS_BIT_CONNECTION);
         #if (MICROPY_PORT_HAS_TELNET || MICROPY_PORT_HAS_FTP)
             // we must reset the servers in case that the last connection
@@ -228,15 +229,16 @@ void SimpleLinkWlanEventHandler(SlWlanEvent_t *pWlanEvent) {
             CLR_STATUS_BIT(wlan_obj.status, STATUS_BIT_IP_ACQUIRED);
         #if (MICROPY_PORT_HAS_TELNET || MICROPY_PORT_HAS_FTP)
             servers_reset();
+            servers_wlan_cycle_power();
         #endif
             break;
         case SL_WLAN_STA_CONNECTED_EVENT:
         {
-            slPeerInfoAsyncResponse_t *pEventData = &pWlanEvent->EventData.APModeStaConnected;
+            //slPeerInfoAsyncResponse_t *pEventData = &pWlanEvent->EventData.APModeStaConnected;
             // get the mac address and name of the connected device
-            memcpy(wlan_obj.bssid, pEventData->mac, SL_BSSID_LENGTH);
-            memcpy(wlan_obj.ssid_o, pEventData->go_peer_device_name, pEventData->go_peer_device_name_len);
-            wlan_obj.ssid_o[pEventData->go_peer_device_name_len] = '\0';
+            //memcpy(wlan_obj.bssid, pEventData->mac, SL_BSSID_LENGTH);
+            //memcpy(wlan_obj.ssid_o, pEventData->go_peer_device_name, pEventData->go_peer_device_name_len);
+            //wlan_obj.ssid_o[pEventData->go_peer_device_name_len] = '\0';
             SET_STATUS_BIT(wlan_obj.status, STATUS_BIT_CONNECTION);
         #if (MICROPY_PORT_HAS_TELNET || MICROPY_PORT_HAS_FTP)
             // we must reset the servers in case that the last connection
@@ -249,6 +251,7 @@ void SimpleLinkWlanEventHandler(SlWlanEvent_t *pWlanEvent) {
             CLR_STATUS_BIT(wlan_obj.status, STATUS_BIT_CONNECTION);
         #if (MICROPY_PORT_HAS_TELNET || MICROPY_PORT_HAS_FTP)
             servers_reset();
+            servers_wlan_cycle_power();
         #endif
             break;
         case SL_WLAN_P2P_DEV_FOUND_EVENT:
@@ -547,6 +550,12 @@ void wlan_set_current_time (uint32_t seconds_since_2000) {
     sl_DevSet(SL_DEVICE_GENERAL_CONFIGURATION, SL_DEVICE_GENERAL_CONFIGURATION_DATE_TIME, sizeof(SlDateTime_t), (_u8 *)(&sl_datetime));
 }
 
+void wlan_off_on (void) {
+    // no need to lock the WLAN object on every API call since the servers and the MicroPtyhon
+    // task have the same priority
+    wlan_reenable(wlan_obj.mode);
+}
+
 //*****************************************************************************
 // DEFINE STATIC FUNCTIONS
 //*****************************************************************************
@@ -554,8 +563,8 @@ void wlan_set_current_time (uint32_t seconds_since_2000) {
 STATIC void wlan_clear_data (void) {
     CLR_STATUS_BIT_ALL(wlan_obj.status);
     wlan_obj.ip = 0;
-    memset(wlan_obj.ssid_o, 0, sizeof(wlan_obj.ssid));
-    memset(wlan_obj.bssid, 0, sizeof(wlan_obj.bssid));
+    //memset(wlan_obj.ssid_o, 0, sizeof(wlan_obj.ssid));
+    //memset(wlan_obj.bssid, 0, sizeof(wlan_obj.bssid));
 }
 
 STATIC void wlan_reenable (SlWlanMode_t mode) {
@@ -821,7 +830,7 @@ STATIC const mp_arg_t wlan_init_args[] = {
     { MP_QSTR_channel,      MP_ARG_KW_ONLY  | MP_ARG_INT,  {.u_int = 1} },
     { MP_QSTR_antenna,      MP_ARG_KW_ONLY  | MP_ARG_INT,  {.u_int = ANTENNA_TYPE_INTERNAL} },
 };
-STATIC mp_obj_t wlan_make_new (mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
+STATIC mp_obj_t wlan_make_new(const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
     // parse args
     mp_map_t kw_args;
     mp_map_init_fixed_table(&kw_args, n_kw, all_args + n_args);

cc3200/mods/modwlan.h

@@ -95,6 +95,7 @@ extern void wlan_get_mac (uint8_t *macAddress);
 extern void wlan_get_ip (uint32_t *ip);
 extern bool wlan_is_connected (void);
 extern void wlan_set_current_time (uint32_t seconds_since_2000);
+extern void wlan_off_on (void);
 
 extern int wlan_gethostbyname(const char *name, mp_uint_t len, uint8_t *out_ip, uint8_t family);
 extern int wlan_socket_socket(mod_network_socket_obj_t *s, int *_errno);

cc3200/mods/pybadc.c

@@ -140,7 +140,7 @@ STATIC const mp_arg_t pyb_adc_init_args[] = {
     { MP_QSTR_id,                          MP_ARG_INT, {.u_int = 0} },
     { MP_QSTR_bits,       MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 12} },
 };
-STATIC mp_obj_t adc_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
+STATIC mp_obj_t adc_make_new(const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
     // parse args
     mp_map_t kw_args;
     mp_map_init_fixed_table(&kw_args, n_kw, all_args + n_args);

cc3200/mods/pybi2c.c

@@ -63,7 +63,7 @@ typedef struct _pyb_i2c_obj_t {
 #define PYBI2C_MIN_BAUD_RATE_HZ                (50000)
 #define PYBI2C_MAX_BAUD_RATE_HZ                (400000)
 
-#define PYBI2C_TRANSC_TIMEOUT_MS               (10)
+#define PYBI2C_TRANSC_TIMEOUT_MS               (20)
 #define PYBI2C_TRANSAC_WAIT_DELAY_US           (10)
 
 #define PYBI2C_TIMEOUT_TO_COUNT(to_us, baud)   (((baud) * to_us) / 16000000)
@@ -78,9 +78,13 @@ typedef struct _pyb_i2c_obj_t {
  DECLARE PRIVATE DATA
  ******************************************************************************/
 STATIC pyb_i2c_obj_t pyb_i2c_obj = {.baudrate = 0};
-
 STATIC const mp_obj_t pyb_i2c_def_pin[2] = {&pin_GP13, &pin_GP23};
 
+/******************************************************************************
+ DECLARE PRIVATE FUNCTIONS
+ ******************************************************************************/
+STATIC bool pyb_i2c_write(byte addr, byte *data, uint len, bool stop);
+
 /******************************************************************************
  DEFINE PRIVATE FUNCTIONS
  ******************************************************************************/
@@ -107,13 +111,13 @@ STATIC bool pyb_i2c_transaction(uint cmd) {
     // Wait until the current byte has been transferred.
     // Poll on the raw interrupt status.
     while ((MAP_I2CMasterIntStatusEx(I2CA0_BASE, false) & (I2C_MASTER_INT_DATA | I2C_MASTER_INT_TIMEOUT)) == 0) {
-        // wait for a few microseconds
-        UtilsDelay(UTILS_DELAY_US_TO_COUNT(PYBI2C_TRANSAC_WAIT_DELAY_US));
-        timeout -= PYBI2C_TRANSAC_WAIT_DELAY_US;
         if (timeout < 0) {
             // the peripheral is not responding, so stop
             return false;
         }
+        // wait for a few microseconds
+        UtilsDelay(UTILS_DELAY_US_TO_COUNT(PYBI2C_TRANSAC_WAIT_DELAY_US));
+        timeout -= PYBI2C_TRANSAC_WAIT_DELAY_US;
     }
 
     // Check for any errors in the transfer
@@ -145,13 +149,22 @@ STATIC void pyb_i2c_check_init(pyb_i2c_obj_t *self) {
 }
 
 STATIC bool pyb_i2c_scan_device(byte devAddr) {
-    // Set I2C codec slave address
+    bool ret = false;
+    // Set the I2C slave address
     MAP_I2CMasterSlaveAddrSet(I2CA0_BASE, devAddr, true);
     // Initiate the transfer.
-    RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_SINGLE_RECEIVE));
-    // Since this is a hack, send the stop bit anyway
+    if (pyb_i2c_transaction(I2C_MASTER_CMD_SINGLE_RECEIVE)) {
+        ret = true;
+    }
+    // Send the stop bit to cancel the read transaction
     MAP_I2CMasterControl(I2CA0_BASE, I2C_MASTER_CMD_BURST_SEND_ERROR_STOP);
-    return true;
+    if (!ret) {
+        uint8_t data = 0;
+        if (pyb_i2c_write(devAddr, &data, sizeof(data), true)) {
+            ret = true;
+        }
+    }
+    return ret;
 }
 
 STATIC bool pyb_i2c_mem_addr_write (byte addr, byte *mem_addr, uint mem_addr_len) {
@@ -319,7 +332,7 @@ STATIC const mp_arg_t pyb_i2c_init_args[] = {
     { MP_QSTR_baudrate,  MP_ARG_KW_ONLY  | MP_ARG_INT, {.u_int = 100000} },
     { MP_QSTR_pins,      MP_ARG_KW_ONLY  | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
 };
-STATIC mp_obj_t pyb_i2c_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
+STATIC mp_obj_t pyb_i2c_make_new(const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
     // parse args
     mp_map_t kw_args;
     mp_map_init_fixed_table(&kw_args, n_kw, all_args + n_args);
@@ -365,7 +378,7 @@ STATIC mp_obj_t pyb_i2c_scan(mp_obj_t self_in) {
     pyb_i2c_check_init(&pyb_i2c_obj);
     mp_obj_t list = mp_obj_new_list(0, NULL);
     for (uint addr = 1; addr <= 127; addr++) {
-        for (int i = 0; i < 7; i++) {
+        for (int i = 0; i < 3; i++) {
             if (pyb_i2c_scan_device(addr)) {
                 mp_obj_list_append(list, mp_obj_new_int(addr));
                 break;

cc3200/mods/pybpin.c

@@ -60,7 +60,6 @@ DECLARE PRIVATE FUNCTIONS
 STATIC pin_obj_t *pin_find_named_pin(const mp_obj_dict_t *named_pins, mp_obj_t name);
 STATIC pin_obj_t *pin_find_pin_by_port_bit (const mp_obj_dict_t *named_pins, uint port, uint bit);
 STATIC int8_t pin_obj_find_af (const pin_obj_t* pin, uint8_t fn, uint8_t unit, uint8_t type);
-STATIC int8_t pin_find_af_index (const pin_obj_t* pin, uint8_t fn, uint8_t unit, uint8_t type);
 STATIC void pin_free_af_from_pins (uint8_t fn, uint8_t unit, uint8_t type);
 STATIC void pin_deassign (pin_obj_t* pin);
 STATIC void pin_obj_configure (const pin_obj_t *self);
@@ -199,6 +198,14 @@ uint8_t pin_find_peripheral_type (const mp_obj_t pin, uint8_t fn, uint8_t unit)
     nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
 }
 
+int8_t pin_find_af_index (const pin_obj_t* pin, uint8_t fn, uint8_t unit, uint8_t type) {
+    int8_t af = pin_obj_find_af(pin, fn, unit, type);
+    if (af < 0) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
+    }
+    return af;
+}
+
 /******************************************************************************
 DEFINE PRIVATE FUNCTIONS
  ******************************************************************************/
@@ -231,14 +238,6 @@ STATIC int8_t pin_obj_find_af (const pin_obj_t* pin, uint8_t fn, uint8_t unit, u
     return -1;
 }
 
-STATIC int8_t pin_find_af_index (const pin_obj_t* pin, uint8_t fn, uint8_t unit, uint8_t type) {
-    int8_t af = pin_obj_find_af(pin, fn, unit, type);
-    if (af < 0) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
-    }
-    return af;
-}
-
 STATIC void pin_free_af_from_pins (uint8_t fn, uint8_t unit, uint8_t type) {
     mp_map_t *named_map = mp_obj_dict_get_map((mp_obj_t)&pin_board_pins_locals_dict);
     for (uint i = 0; i < named_map->used - 1; i++) {
@@ -248,7 +247,7 @@ STATIC void pin_free_af_from_pins (uint8_t fn, uint8_t unit, uint8_t type) {
             // check if the pin supports the target af
             int af = pin_obj_find_af(pin, fn, unit, type);
             if (af > 0 && af == pin->af) {
-                // the pin is assigned to the target af, de-assign it
+                // the pin supports the target af, de-assign it
                 pin_deassign (pin);
             }
         }
@@ -648,7 +647,7 @@ STATIC void pin_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t
     mp_printf(print, ", alt=%d)", alt);
 }
 
-STATIC mp_obj_t pin_make_new(mp_obj_t self_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
+STATIC mp_obj_t pin_make_new(const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
     mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
 
     // Run an argument through the mapper and return the result.

cc3200/mods/pybpin.h

@@ -72,10 +72,7 @@ enum {
 };
 
 enum {
-    PIN_TYPE_TIM_PWM0 = 0,
-    PIN_TYPE_TIM_PWM1,
-    PIN_TYPE_TIM_CC0,
-    PIN_TYPE_TIM_CC1,
+    PIN_TYPE_TIM_PWM = 0,
 };
 
 enum {
@@ -139,5 +136,6 @@ pin_obj_t *pin_find(mp_obj_t user_obj);
 void pin_assign_pins_af (mp_obj_t *pins, uint32_t n_pins, uint32_t pull, uint32_t fn, uint32_t unit);
 uint8_t pin_find_peripheral_unit (const mp_obj_t pin, uint8_t fn, uint8_t type);
 uint8_t pin_find_peripheral_type (const mp_obj_t pin, uint8_t fn, uint8_t unit);
+int8_t pin_find_af_index (const pin_obj_t* pin, uint8_t fn, uint8_t unit, uint8_t type);;
 
 #endif  // PYBPIN_H_

cc3200/mods/pybrtc.c

@@ -285,7 +285,7 @@ STATIC const mp_arg_t pyb_rtc_init_args[] = {
     { MP_QSTR_id,                             MP_ARG_INT, {.u_int = 0} },
     { MP_QSTR_datetime,                       MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
 };
-STATIC mp_obj_t pyb_rtc_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
+STATIC mp_obj_t pyb_rtc_make_new(const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
     // parse args
     mp_map_t kw_args;
     mp_map_init_fixed_table(&kw_args, n_kw, all_args + n_args);

cc3200/mods/pybsd.c

@@ -64,7 +64,7 @@ STATIC const mp_obj_t pyb_sd_def_pin[3] = {&pin_GP10, &pin_GP11, &pin_GP15};
  DECLARE PRIVATE FUNCTIONS
  ******************************************************************************/
 STATIC void pyb_sd_hw_init (pybsd_obj_t *self);
-STATIC mp_obj_t pyb_sd_make_new (mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args);
+STATIC mp_obj_t pyb_sd_make_new (const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args);
 STATIC mp_obj_t pyb_sd_deinit (mp_obj_t self_in);
 
 /******************************************************************************
@@ -123,7 +123,7 @@ STATIC const mp_arg_t pyb_sd_init_args[] = {
     { MP_QSTR_id,                          MP_ARG_INT, {.u_int = 0} },
     { MP_QSTR_pins,                        MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
 };
-STATIC mp_obj_t pyb_sd_make_new (mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
+STATIC mp_obj_t pyb_sd_make_new (const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
     // parse args
     mp_map_t kw_args;
     mp_map_init_fixed_table(&kw_args, n_kw, all_args + n_args);

cc3200/mods/pybspi.c

@@ -231,7 +231,7 @@ static const mp_arg_t pyb_spi_init_args[] = {
     { MP_QSTR_firstbit,     MP_ARG_KW_ONLY  | MP_ARG_INT,  {.u_int = PYBSPI_FIRST_BIT_MSB} },
     { MP_QSTR_pins,         MP_ARG_KW_ONLY  | MP_ARG_OBJ,  {.u_obj = MP_OBJ_NULL} },
 };
-STATIC mp_obj_t pyb_spi_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
+STATIC mp_obj_t pyb_spi_make_new(const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
     // parse args
     mp_map_t kw_args;
     mp_map_init_fixed_table(&kw_args, n_kw, all_args + n_args);

cc3200/mods/pybtimer.c

@@ -43,7 +43,10 @@
 #include "interrupt.h"
 #include "prcm.h"
 #include "timer.h"
+#include "pin.h"
 #include "pybtimer.h"
+#include "pybpin.h"
+#include "pins.h"
 #include "mpirq.h"
 #include "pybsleep.h"
 #include "mpexception.h"
@@ -55,30 +58,8 @@
 /// Each timer consists of a counter that counts up at a certain rate.  The rate
 /// at which it counts is the peripheral clock frequency (in Hz) divided by the
 /// timer prescaler.  When the counter reaches the timer period it triggers an
-/// event, and the counter resets back to zero.  By using the callback method,
+/// event, and the counter resets back to zero.  By using the irq method,
 /// the timer event can call a Python function.
-///
-/// Example usage to toggle an LED at a fixed frequency:
-///
-///     tim = pyb.Timer(4)                                              # create a timer object using timer 4
-///     tim.init(mode=Timer.PERIODIC)                                   # initialize it in periodic mode
-///     tim_ch = tim.channel(Timer.A, freq=2)                           # configure channel A at a frequency of 2Hz
-///     tim_ch.callback(handler=lambda t:led.toggle())                  # toggle a LED on every cycle of the timer
-///
-/// Further examples:
-///
-///     tim1 = pyb.Timer(2, mode=Timer.EVENT_COUNT)                     # initialize it capture mode
-///     tim2 = pyb.Timer(1, mode=Timer.PWM)                             # initialize it in PWM mode
-///     tim_ch = tim1.channel(Timer.A, freq=1, polarity=Timer.POSITIVE) # start the event counter with a frequency of 1Hz and triggered by positive edges
-///     tim_ch = tim2.channel(Timer.B, freq=10000, duty_cycle=50)       # start the PWM on channel B with a 50% duty cycle
-///     tim_ch.time()                                                   # get the current time in usec (can also be set)
-///     tim_ch.freq(20)                                                 # set the frequency (can also get)
-///     tim_ch.duty_cycle(30)                                           # set the duty cycle to 30% (can also get)
-///     tim_ch.duty_cycle(30, Timer.NEGATIVE)                           # set the duty cycle to 30% and change the polarity to negative
-///     tim_ch.event_count()                                            # get the number of captured events
-///     tim_ch.event_time()                                             # get the the time of the last captured event
-///     tim_ch.period(2000000)                                          # change the period to 2 seconds
-///
 
 /******************************************************************************
  DECLARE PRIVATE CONSTANTS
@@ -87,6 +68,9 @@
 #define PYBTIMER_POLARITY_POS                       (0x01)
 #define PYBTIMER_POLARITY_NEG                       (0x02)
 
+#define PYBTIMER_TIMEOUT_TRIGGER                    (0x01)
+#define PYBTIMER_MATCH_TRIGGER                      (0x02)
+
 #define PYBTIMER_SRC_FREQ_HZ                        HAL_FCPU_HZ
 
 /******************************************************************************
@@ -108,8 +92,8 @@ typedef struct _pyb_timer_channel_obj_t {
     uint32_t frequency;
     uint32_t period;
     uint16_t channel;
+    uint16_t duty_cycle;
     uint8_t  polarity;
-    uint8_t  duty_cycle;
 } pyb_timer_channel_obj_t;
 
 /******************************************************************************
@@ -121,12 +105,14 @@ STATIC pyb_timer_obj_t pyb_timer_obj[PYBTIMER_NUM_TIMERS] = {{.timer = TIMERA0_B
                                                              {.timer = TIMERA2_BASE, .peripheral = PRCM_TIMERA2},
                                                              {.timer = TIMERA3_BASE, .peripheral = PRCM_TIMERA3}};
 STATIC const mp_obj_type_t pyb_timer_channel_type;
+STATIC const mp_obj_t pyb_timer_pwm_pin[8] = {&pin_GP24, MP_OBJ_NULL, &pin_GP25, MP_OBJ_NULL, MP_OBJ_NULL, &pin_GP9, &pin_GP10, &pin_GP11};
 
 /******************************************************************************
  DECLARE PRIVATE FUNCTIONS
  ******************************************************************************/
 STATIC mp_obj_t pyb_timer_channel_irq (mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
 STATIC void timer_disable (pyb_timer_obj_t *tim);
+STATIC void timer_channel_init (pyb_timer_channel_obj_t *ch);
 STATIC void TIMER0AIntHandler(void);
 STATIC void TIMER0BIntHandler(void);
 STATIC void TIMER1AIntHandler(void);
@@ -177,6 +163,8 @@ STATIC void pyb_timer_channel_remove (pyb_timer_channel_obj_t *ch) {
     pyb_timer_channel_obj_t *channel;
     if ((channel = pyb_timer_channel_find(ch->timer->timer, ch->channel))) {
         mp_obj_list_remove(&MP_STATE_PORT(pyb_timer_channel_obj_list), channel);
+        // unregister it with the sleep module
+        pyb_sleep_remove((const mp_obj_t)channel);
     }
 }
 
@@ -184,6 +172,8 @@ STATIC void pyb_timer_channel_add (pyb_timer_channel_obj_t *ch) {
     // remove it in case it already exists
     pyb_timer_channel_remove(ch);
     mp_obj_list_append(&MP_STATE_PORT(pyb_timer_channel_obj_list), ch);
+    // register it with the sleep module
+    pyb_sleep_add((const mp_obj_t)ch, (WakeUpCB_t)timer_channel_init);
 }
 
 STATIC void timer_disable (pyb_timer_obj_t *tim) {
@@ -191,8 +181,15 @@ STATIC void timer_disable (pyb_timer_obj_t *tim) {
     MAP_TimerDisable(tim->timer, TIMER_A | TIMER_B);
     MAP_TimerIntDisable(tim->timer, tim->irq_trigger);
     MAP_TimerIntClear(tim->timer, tim->irq_trigger);
+    pyb_timer_channel_obj_t *ch;
+    // disable its channels
+    if ((ch = pyb_timer_channel_find (tim->timer, TIMER_A))) {
+        pyb_sleep_remove(ch);
+    }
+    if ((ch = pyb_timer_channel_find (tim->timer, TIMER_B))) {
+        pyb_sleep_remove(ch);
+    }
     MAP_PRCMPeripheralClkDisable(tim->peripheral, PRCM_RUN_MODE_CLK | PRCM_SLP_MODE_CLK);
-    memset(&pyb_timer_obj[tim->id], 0, sizeof(pyb_timer_obj_t));
 }
 
 // computes prescaler period and match value so timer triggers at freq-Hz
@@ -205,20 +202,23 @@ STATIC uint32_t compute_prescaler_period_and_match_value(pyb_timer_channel_obj_t
     if (period_c == 0) {
         goto error;
     }
-    prescaler = period_c >> 16;
+
+    prescaler = period_c >> 16; // The prescaler is an extension of the timer counter
     *period_out = period_c;
+
     if (prescaler > 0xFF && maxcount == 0xFFFF) {
         goto error;
     }
     // check limit values for the duty cycle
     if (ch->duty_cycle == 0) {
         *match_out = period_c - 1;
-    }
-    else {
-        *match_out = period_c - ((period_c * ch->duty_cycle) / 100);
-    }
-    if ((ch->timer->config & 0x0F) == TIMER_CFG_A_PWM && (*match_out > 0xFFFF)) {
-        goto error;
+    } else {
+        if (period_c > 0xFFFF) {
+            uint32_t match = (period_c * 100) / 10000;
+            *match_out = period_c - ((match * ch->duty_cycle) / 100);
+        } else {
+            *match_out = period_c - ((period_c * ch->duty_cycle) / 10000);
+        }
     }
     return prescaler;
 
@@ -250,17 +250,7 @@ STATIC void timer_channel_init (pyb_timer_channel_obj_t *ch) {
         MAP_TimerControlLevel(ch->timer->timer, ch->channel, (ch->polarity == PYBTIMER_POLARITY_NEG) ? true : false);
         // set the match value (which is simply the duty cycle translated to ticks)
         MAP_TimerMatchSet(ch->timer->timer, ch->channel, match);
-    }
-    // configure the event edge type if we are in such mode
-    else if ((ch->timer->config & 0x0F) == TIMER_CFG_A_CAP_COUNT || (ch->timer->config & 0x0F) == TIMER_CFG_A_CAP_TIME) {
-        uint32_t polarity = TIMER_EVENT_BOTH_EDGES;
-        if (ch->polarity == PYBTIMER_POLARITY_POS) {
-            polarity = TIMER_EVENT_POS_EDGE;
-        }
-        else if (ch->polarity == PYBTIMER_POLARITY_NEG) {
-            polarity = TIMER_EVENT_NEG_EDGE;
-        }
-        MAP_TimerControlEvent(ch->timer->timer, ch->channel, polarity);
+        MAP_TimerPrescaleMatchSet(ch->timer->timer, ch->channel, match >> 16);
     }
 
 #ifdef DEBUG
@@ -282,37 +272,18 @@ STATIC void pyb_timer_print(const mp_print_t *print, mp_obj_t self_in, mp_print_
     // timer mode
     qstr mode_qst = MP_QSTR_PWM;
     switch(mode) {
-    case TIMER_CFG_A_ONE_SHOT:
+    case TIMER_CFG_A_ONE_SHOT_UP:
         mode_qst = MP_QSTR_ONE_SHOT;
         break;
-    case TIMER_CFG_A_PERIODIC:
+    case TIMER_CFG_A_PERIODIC_UP:
         mode_qst = MP_QSTR_PERIODIC;
         break;
-    case TIMER_CFG_A_CAP_COUNT:
-        mode_qst = MP_QSTR_EDGE_COUNT;
-        break;
-    case TIMER_CFG_A_CAP_TIME:
-        mode_qst = MP_QSTR_EDGE_TIME;
-        break;
     default:
         break;
     }
-    mp_printf(print, "<Timer%u, mode=Timer.%q>", (tim->id + 1), mode_qst);
+    mp_printf(print, "Timer(%u, mode=Timer.%q)", tim->id, mode_qst);
 }
 
-/// \method init(mode, *, width)
-/// Initialise the timer.  Initialisation must give the desired mode
-/// and an optional timer width
-///
-///     tim.init(mode=Timer.ONE_SHOT, width=32)        # one shot mode
-///     tim.init(mode=Timer.PERIODIC)                  # configure in free running periodic mode
-///                                                      split into two 16-bit independent timers
-///
-/// Keyword arguments:
-///
-///   - `width` - specifies the width of the timer. Default is 32 bit mode. When in 16 bit mode
-///               the timer is splitted into 2 independent channels.
-///
 STATIC mp_obj_t pyb_timer_init_helper(pyb_timer_obj_t *tim, mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_mode,         MP_ARG_REQUIRED | MP_ARG_INT, },
@@ -325,8 +296,7 @@ STATIC mp_obj_t pyb_timer_init_helper(pyb_timer_obj_t *tim, mp_uint_t n_args, co
 
     // check the mode
     uint32_t _mode = args[0].u_int;
-    if (_mode != TIMER_CFG_A_ONE_SHOT && _mode != TIMER_CFG_A_PERIODIC && _mode != TIMER_CFG_A_CAP_COUNT &&
-        _mode != TIMER_CFG_A_CAP_TIME && _mode != TIMER_CFG_A_PWM) {
+    if (_mode != TIMER_CFG_A_ONE_SHOT_UP && _mode != TIMER_CFG_A_PERIODIC_UP && _mode != TIMER_CFG_A_PWM) {
         goto error;
     }
 
@@ -336,7 +306,7 @@ STATIC mp_obj_t pyb_timer_init_helper(pyb_timer_obj_t *tim, mp_uint_t n_args, co
     }
     bool is16bit = (args[1].u_int == 16);
 
-    if (!is16bit && (_mode != TIMER_CFG_A_ONE_SHOT && _mode != TIMER_CFG_A_PERIODIC)) {
+    if (!is16bit && _mode == TIMER_CFG_A_PWM) {
         // 32-bit mode is only available when in free running modes
         goto error;
     }
@@ -352,16 +322,12 @@ error:
     nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
 }
 
-/// \classmethod \constructor(id, ...)
-/// Construct a new timer object of the given id.  If additional
-/// arguments are given, then the timer is initialised by `init(...)`.
-/// `id` can be 1 to 4
-STATIC mp_obj_t pyb_timer_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
+STATIC mp_obj_t pyb_timer_make_new(const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
     // check arguments
     mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
 
     // create a new Timer object
-    int32_t timer_idx = mp_obj_get_int(args[0]) - 1;
+    int32_t timer_idx = mp_obj_get_int(args[0]);
     if (timer_idx < 0 || timer_idx > (PYBTIMER_NUM_TIMERS - 1)) {
         nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_resource_not_avaliable));
     }
@@ -379,15 +345,11 @@ STATIC mp_obj_t pyb_timer_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t
     return (mp_obj_t)tim;
 }
 
-// \method init()
-/// initializes the timer
 STATIC mp_obj_t pyb_timer_init(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
     return pyb_timer_init_helper(args[0], n_args - 1, args + 1, kw_args);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_timer_init_obj, 1, pyb_timer_init);
 
-// \method deinit()
-/// disables the timer
 STATIC mp_obj_t pyb_timer_deinit(mp_obj_t self_in) {
     pyb_timer_obj_t *self = self_in;
     timer_disable(self);
@@ -395,24 +357,6 @@ STATIC mp_obj_t pyb_timer_deinit(mp_obj_t self_in) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_timer_deinit_obj, pyb_timer_deinit);
 
-/// \method channel(channel, *, freq, period, polarity, duty_cycle)
-/// Initialise the timer channel. Initialization requires at least a frequency param. With no
-/// extra params given besides the channel id, the channel is returned with the previous configuration
-/// os 'None', if it hasn't been initialized before.
-///
-///     tim1.channel(Timer.A, freq=1000)  # set channel A frequency to 1KHz
-///     tim2.channel(Timer.AB, freq=10)   # both channels (because it's a 32 bit timer) combined to create a 10Hz timer
-///
-///     when initialiazing the channel of a 32-bit timer, channel ID MUST be = Timer.AB
-///
-/// Keyword arguments:
-///
-///   - `freq`       - specifies the frequency in Hz.
-///   - `period`     - specifies the period in  microseconds.
-///   - `polarity`   - in PWM specifies the polarity of the pulse. In capture mode specifies the edge to capture.
-///                    in order to capture on both negative and positive edges, make it = Timer.POSITIVE | Timer.NEGATIVE.
-///   - `duty_cycle` - sets the duty cycle value
-///
 STATIC mp_obj_t pyb_timer_channel(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_freq,                MP_ARG_KW_ONLY  | MP_ARG_INT, {.u_int = 0} },
@@ -474,12 +418,21 @@ STATIC mp_obj_t pyb_timer_channel(mp_uint_t n_args, const mp_obj_t *pos_args, mp
     ch->frequency = args[0].u_int;
     ch->period = args[1].u_int;
     ch->polarity = args[2].u_int;
-    ch->duty_cycle = MIN(100, MAX(0, args[3].u_int));
+    ch->duty_cycle = MIN(10000, MAX(0, args[3].u_int));
 
     timer_channel_init(ch);
 
-    // register it with the sleep module
-    pyb_sleep_add ((const mp_obj_t)ch, (WakeUpCB_t)timer_channel_init);
+    // assign the pin
+    if ((ch->timer->config & 0x0F) == TIMER_CFG_A_PWM) {
+        uint32_t ch_idx = (ch->channel == TIMER_A) ? 0 : 1;
+        // use the default pin if available
+        mp_obj_t pin_o = (mp_obj_t)pyb_timer_pwm_pin[(ch->timer->id * 2) + ch_idx];
+        if (pin_o != MP_OBJ_NULL) {
+            pin_obj_t *pin = pin_find(pin_o);
+            pin_config (pin, pin_find_af_index(pin, PIN_FN_TIM, ch->timer->id, PIN_TYPE_TIM_PWM),
+                        0, PIN_TYPE_STD, -1, PIN_STRENGTH_4MA);
+        }
+    }
 
     // add the timer to the list
     pyb_timer_channel_add(ch);
@@ -500,13 +453,13 @@ STATIC const mp_map_elem_t pyb_timer_locals_dict_table[] = {
     // class constants
     { MP_OBJ_NEW_QSTR(MP_QSTR_A),                       MP_OBJ_NEW_SMALL_INT(TIMER_A) },
     { MP_OBJ_NEW_QSTR(MP_QSTR_B),                       MP_OBJ_NEW_SMALL_INT(TIMER_B) },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_ONE_SHOT),                MP_OBJ_NEW_SMALL_INT(TIMER_CFG_A_ONE_SHOT) },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_PERIODIC),                MP_OBJ_NEW_SMALL_INT(TIMER_CFG_A_PERIODIC) },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_EDGE_COUNT),              MP_OBJ_NEW_SMALL_INT(TIMER_CFG_A_CAP_COUNT) },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_EDGE_TIME),               MP_OBJ_NEW_SMALL_INT(TIMER_CFG_A_CAP_TIME) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_ONE_SHOT),                MP_OBJ_NEW_SMALL_INT(TIMER_CFG_A_ONE_SHOT_UP) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_PERIODIC),                MP_OBJ_NEW_SMALL_INT(TIMER_CFG_A_PERIODIC_UP) },
     { MP_OBJ_NEW_QSTR(MP_QSTR_PWM),                     MP_OBJ_NEW_SMALL_INT(TIMER_CFG_A_PWM) },
     { MP_OBJ_NEW_QSTR(MP_QSTR_POSITIVE),                MP_OBJ_NEW_SMALL_INT(PYBTIMER_POLARITY_POS) },
     { MP_OBJ_NEW_QSTR(MP_QSTR_NEGATIVE),                MP_OBJ_NEW_SMALL_INT(PYBTIMER_POLARITY_NEG) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_TIMEOUT),                 MP_OBJ_NEW_SMALL_INT(PYBTIMER_TIMEOUT_TRIGGER) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_MATCH),                   MP_OBJ_NEW_SMALL_INT(PYBTIMER_MATCH_TRIGGER) },
 };
 STATIC MP_DEFINE_CONST_DICT(pyb_timer_locals_dict, pyb_timer_locals_dict_table);
 
@@ -528,7 +481,6 @@ STATIC const mp_irq_methods_t pyb_timer_channel_irq_methods = {
 STATIC void TIMERGenericIntHandler(uint32_t timer, uint16_t channel) {
     pyb_timer_channel_obj_t *self;
     uint32_t status;
-
     if ((self = pyb_timer_channel_find(timer, channel))) {
         status = MAP_TimerIntStatus(self->timer->timer, true) & self->channel;
         MAP_TimerIntClear(self->timer->timer, status);
@@ -574,16 +526,14 @@ STATIC void pyb_timer_channel_print(const mp_print_t *print, mp_obj_t self_in, m
     // timer channel
     if (ch->channel == TIMER_A) {
         ch_id = "A";
-    }
-    else if (ch->channel == TIMER_B) {
+    } else if (ch->channel == TIMER_B) {
         ch_id = "B";
     }
 
-    mp_printf(print, "<%q %s, timer=%u, %q=%u", MP_QSTR_TimerChannel,
-              ch_id, (ch->timer->id + 1), MP_QSTR_freq, ch->frequency);
+    mp_printf(print, "timer.channel(Timer.%s, %q=%u", ch_id, MP_QSTR_freq, ch->frequency);
 
     uint32_t mode = ch->timer->config & 0xFF;
-    if (mode == TIMER_CFG_A_CAP_COUNT || mode == TIMER_CFG_A_CAP_TIME || mode == TIMER_CFG_A_PWM) {
+    if (mode == TIMER_CFG_A_PWM) {
         mp_printf(print, ", %q=Timer.", MP_QSTR_polarity);
         switch (ch->polarity) {
             case PYBTIMER_POLARITY_POS:
@@ -596,15 +546,11 @@ STATIC void pyb_timer_channel_print(const mp_print_t *print, mp_obj_t self_in, m
                 mp_printf(print, "BOTH");
                 break;
         }
-        if (mode == TIMER_CFG_A_PWM) {
-            mp_printf(print, ", %q=%u", MP_QSTR_duty_cycle, ch->duty_cycle);
-        }
+        mp_printf(print, ", %q=%u.%02u", MP_QSTR_duty_cycle, ch->duty_cycle / 100, ch->duty_cycle % 100);
     }
-    mp_printf(print, ">");
+    mp_printf(print, ")");
 }
 
-/// \method freq([value])
-/// get or set the frequency of the timer channel
 STATIC mp_obj_t pyb_timer_channel_freq(mp_uint_t n_args, const mp_obj_t *args) {
     pyb_timer_channel_obj_t *ch = args[0];
     if (n_args == 1) {
@@ -624,8 +570,6 @@ STATIC mp_obj_t pyb_timer_channel_freq(mp_uint_t n_args, const mp_obj_t *args) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_timer_channel_freq_obj, 1, 2, pyb_timer_channel_freq);
 
-/// \method period([value])
-/// get or set the period of the timer channel in microseconds
 STATIC mp_obj_t pyb_timer_channel_period(mp_uint_t n_args, const mp_obj_t *args) {
     pyb_timer_channel_obj_t *ch = args[0];
     if (n_args == 1) {
@@ -645,74 +589,17 @@ STATIC mp_obj_t pyb_timer_channel_period(mp_uint_t n_args, const mp_obj_t *args)
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_timer_channel_period_obj, 1, 2, pyb_timer_channel_period);
 
-/// \method time([value])
-/// get or set the value of the timer channel in microseconds
-STATIC mp_obj_t pyb_timer_channel_time(mp_uint_t n_args, const mp_obj_t *args) {
-    pyb_timer_channel_obj_t *ch = args[0];
-    uint32_t value;
-    // calculate the period, the prescaler and the match value
-    uint32_t period_c;
-    uint32_t match;
-    (void)compute_prescaler_period_and_match_value(ch, &period_c, &match);
-    if (n_args == 1) {
-        // get
-        value = (ch->channel == TIMER_B) ? HWREG(ch->timer->timer + TIMER_O_TBV) : HWREG(ch->timer->timer + TIMER_O_TAV);
-        // return the current timer value in microseconds
-        // substract value to period since we are always operating in count-down mode
-        uint32_t time_t = (1000 * (period_c - value)) / period_c;
-        return mp_obj_new_int((time_t * 1000) / ch->frequency);
-    }
-    else {
-        // set
-        value = (mp_obj_get_int(args[1]) * ((ch->frequency * period_c) / 1000)) / 1000;
-        if ((value > 0xFFFF) && (ch->timer->config & TIMER_CFG_SPLIT_PAIR)) {
-            // this exceeds the maximum value of a 16-bit timer
-            nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
-        }
-        // write period minus value since we are always operating in count-down mode
-        TimerValueSet (ch->timer->timer, ch->channel, (period_c - value));
-        return mp_const_none;
-    }
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_timer_channel_time_obj, 1, 2, pyb_timer_channel_time);
-
-/// \method event_count()
-/// get the number of events triggered by the configured edge
-STATIC mp_obj_t pyb_timer_channel_event_count(mp_obj_t self_in) {
-    pyb_timer_channel_obj_t *ch = self_in;
-    return mp_obj_new_int(MAP_TimerValueGet(ch->timer->timer, ch->channel == (TIMER_A | TIMER_B) ? TIMER_A : ch->channel));
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_timer_channel_event_count_obj, pyb_timer_channel_event_count);
-
-/// \method event_time()
-/// get the time at which the last event was triggered
-STATIC mp_obj_t pyb_timer_channel_event_time(mp_obj_t self_in) {
-    pyb_timer_channel_obj_t *ch = self_in;
-    // calculate the period, the prescaler and the match value
-    uint32_t period_c;
-    uint32_t match;
-    (void)compute_prescaler_period_and_match_value(ch, &period_c, &match);
-    uint32_t value = MAP_TimerValueGet(ch->timer->timer, ch->channel == (TIMER_A | TIMER_B) ? TIMER_A : ch->channel);
-    // substract value to period since we are always operating in count-down mode
-    uint32_t time_t = (1000 * (period_c - value)) / period_c;
-    return mp_obj_new_int((time_t * 1000) / ch->frequency);
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_timer_channel_event_time_obj, pyb_timer_channel_event_time);
-
-/// \method duty_cycle()
-/// get or set the duty cycle when in PWM mode
 STATIC mp_obj_t pyb_timer_channel_duty_cycle(mp_uint_t n_args, const mp_obj_t *args) {
     pyb_timer_channel_obj_t *ch = args[0];
     if (n_args == 1) {
         // get
         return mp_obj_new_int(ch->duty_cycle);
-    }
-    else {
+    } else {
         // duty cycle must be converted from percentage to ticks
         // calculate the period, the prescaler and the match value
         uint32_t period_c;
         uint32_t match;
-        ch->duty_cycle = MIN(100, MAX(0, mp_obj_get_int(args[1])));
+        ch->duty_cycle = MIN(10000, MAX(0, mp_obj_get_int(args[1])));
         compute_prescaler_period_and_match_value(ch, &period_c, &match);
         if (n_args == 3) {
             // set the new polarity if requested
@@ -720,13 +607,12 @@ STATIC mp_obj_t pyb_timer_channel_duty_cycle(mp_uint_t n_args, const mp_obj_t *a
             MAP_TimerControlLevel(ch->timer->timer, ch->channel, (ch->polarity == PYBTIMER_POLARITY_NEG) ? true : false);
         }
         MAP_TimerMatchSet(ch->timer->timer, ch->channel, match);
+        MAP_TimerPrescaleMatchSet(ch->timer->timer, ch->channel, match >> 16);
         return mp_const_none;
     }
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_timer_channel_duty_cycle_obj, 1, 3, pyb_timer_channel_duty_cycle);
 
-/// \method irq(trigger, priority, handler, wake)
-/// FIXME triggers!!
 STATIC mp_obj_t pyb_timer_channel_irq (mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     mp_arg_val_t args[mp_irq_INIT_NUM_ARGS];
     mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, mp_irq_INIT_NUM_ARGS, mp_irq_init_args, args);
@@ -741,25 +627,28 @@ STATIC mp_obj_t pyb_timer_channel_irq (mp_uint_t n_args, const mp_obj_t *pos_arg
         goto invalid_args;
     }
 
+    // get the trigger
+    uint trigger = mp_obj_get_int(args[0].u_obj);
+
     // disable the callback first
     pyb_timer_channel_irq_disable(ch);
 
     uint8_t shift = (ch->channel == TIMER_B) ? 8 : 0;
     uint32_t _config = (ch->channel == TIMER_B) ? ((ch->timer->config & TIMER_B) >> 8) : (ch->timer->config & TIMER_A);
     switch (_config) {
-    case TIMER_CFG_A_ONE_SHOT:
-    case TIMER_CFG_A_PERIODIC:
+    case TIMER_CFG_A_ONE_SHOT_UP:
+    case TIMER_CFG_A_PERIODIC_UP:
         ch->timer->irq_trigger |= TIMER_TIMA_TIMEOUT << shift;
-        break;
-    case TIMER_CFG_A_CAP_COUNT:
-        ch->timer->irq_trigger |= TIMER_CAPA_MATCH << shift;
-        break;
-    case TIMER_CFG_A_CAP_TIME:
-        ch->timer->irq_trigger |= TIMER_CAPA_EVENT << shift;
+        if (trigger != PYBTIMER_TIMEOUT_TRIGGER) {
+            goto invalid_args;
+        }
         break;
     case TIMER_CFG_A_PWM:
         // special case for the PWM match interrupt
         ch->timer->irq_trigger |= ((ch->channel & TIMER_A) == TIMER_A) ? TIMER_TIMA_MATCH : TIMER_TIMB_MATCH;
+        if (trigger != PYBTIMER_MATCH_TRIGGER) {
+            goto invalid_args;
+        }
         break;
     default:
         break;
@@ -831,9 +720,6 @@ STATIC const mp_map_elem_t pyb_timer_channel_locals_dict_table[] = {
     // instance methods
     { MP_OBJ_NEW_QSTR(MP_QSTR_freq),                 (mp_obj_t)&pyb_timer_channel_freq_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_period),               (mp_obj_t)&pyb_timer_channel_period_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_time),                 (mp_obj_t)&pyb_timer_channel_time_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_event_count),          (mp_obj_t)&pyb_timer_channel_event_count_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_event_time),           (mp_obj_t)&pyb_timer_channel_event_time_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_duty_cycle),           (mp_obj_t)&pyb_timer_channel_duty_cycle_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_irq),                  (mp_obj_t)&pyb_timer_channel_irq_obj },
 };

cc3200/mods/pybuart.c

@@ -443,7 +443,7 @@ STATIC const mp_arg_t pyb_uart_init_args[] = {
     { MP_QSTR_stop,                           MP_ARG_INT,  {.u_int = 1} },
     { MP_QSTR_pins,         MP_ARG_KW_ONLY  | MP_ARG_OBJ,  {.u_obj = MP_OBJ_NULL} },
 };
-STATIC mp_obj_t pyb_uart_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
+STATIC mp_obj_t pyb_uart_make_new(const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
     // parse args
     mp_map_t kw_args;
     mp_map_init_fixed_table(&kw_args, n_kw, all_args + n_args);

cc3200/mods/pybwdt.c

@@ -92,7 +92,7 @@ STATIC const mp_arg_t pyb_wdt_init_args[] = {
     { MP_QSTR_id,                             MP_ARG_OBJ,  {.u_obj = mp_const_none} },
     { MP_QSTR_timeout,                        MP_ARG_INT,  {.u_int = 5000} },   // 5 s
 };
-STATIC mp_obj_t pyb_wdt_make_new (mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
+STATIC mp_obj_t pyb_wdt_make_new(const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
     // check the arguments
     mp_map_t kw_args;
     mp_map_init_fixed_table(&kw_args, n_kw, all_args + n_args);

cc3200/mpconfigport.h

@@ -70,6 +70,7 @@
 #define MICROPY_FATFS_REENTRANT                     (1)
 #define MICROPY_FATFS_TIMEOUT                       (2500)
 #define MICROPY_FATFS_SYNC_T                        SemaphoreHandle_t
+#define MICROPY_FSUSERMOUNT_ADHOC                   (1)
 
 #define MICROPY_STREAMS_NON_BLOCK                   (1)
 #define MICROPY_MODULE_WEAK_LINKS                   (1)
@@ -134,7 +135,7 @@ extern const struct _mp_obj_module_t mp_module_ubinascii;
 extern const struct _mp_obj_module_t mp_module_ussl;
 
 #define MICROPY_PORT_BUILTIN_MODULES \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_machine),     (mp_obj_t)&machine_module },      \
+    { MP_OBJ_NEW_QSTR(MP_QSTR_umachine),     (mp_obj_t)&machine_module },      \
 	{ MP_OBJ_NEW_QSTR(MP_QSTR_wipy),        (mp_obj_t)&wipy_module },         \
     { MP_OBJ_NEW_QSTR(MP_QSTR_uos),         (mp_obj_t)&mp_module_uos },       \
     { MP_OBJ_NEW_QSTR(MP_QSTR_utime),       (mp_obj_t)&mp_module_utime },     \
@@ -154,10 +155,11 @@ extern const struct _mp_obj_module_t mp_module_ussl;
     { MP_OBJ_NEW_QSTR(MP_QSTR_socket),      (mp_obj_t)&mp_module_usocket },   \
     { MP_OBJ_NEW_QSTR(MP_QSTR_binascii),    (mp_obj_t)&mp_module_ubinascii }, \
     { MP_OBJ_NEW_QSTR(MP_QSTR_ssl),         (mp_obj_t)&mp_module_ussl },      \
+    { MP_OBJ_NEW_QSTR(MP_QSTR_machine),     (mp_obj_t)&machine_module },      \
 
 // extra constants
 #define MICROPY_PORT_CONSTANTS \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_machine),     (mp_obj_t)&machine_module },      \
+    { MP_OBJ_NEW_QSTR(MP_QSTR_umachine),     (mp_obj_t)&machine_module },      \
 
 // vm state and root pointers for the gc
 #define MP_STATE_PORT MP_STATE_VM

cc3200/qstrdefsport.h

@@ -26,7 +26,7 @@
  */
 
 // for machine module
-Q(machine)
+Q(umachine)
 #ifdef DEBUG
 Q(info)
 #endif
@@ -279,7 +279,7 @@ Q(CERT_REQUIRED)
 
 // for network class
 Q(network)
-Q(server)
+Q(Server)
 Q(init)
 Q(deinit)
 Q(login)
@@ -365,18 +365,15 @@ Q(width)
 Q(channel)
 Q(polarity)
 Q(duty_cycle)
-Q(time)
-Q(event_count)
-Q(event_time)
 Q(A)
 Q(B)
 Q(ONE_SHOT)
 Q(PERIODIC)
-Q(EDGE_COUNT)
-Q(EDGE_TIME)
 Q(PWM)
 Q(POSITIVE)
 Q(NEGATIVE)
+Q(TIMEOUT)
+Q(MATCH)
 
 // for uhashlib module
 //Q(uhashlib)

cc3200/serverstask.c

@@ -39,7 +39,8 @@
 #include "pybwdt.h"
 #include "modusocket.h"
 #include "mpexception.h"
-
+#include "modnetwork.h"
+#include "modwlan.h"
 
 /******************************************************************************
  DEFINE PRIVATE TYPES
@@ -50,13 +51,13 @@ typedef struct {
     bool do_disable;
     bool do_enable;
     bool do_reset;
+    bool do_wlan_cycle_power;
 } servers_data_t;
 
 /******************************************************************************
  DECLARE PRIVATE DATA
  ******************************************************************************/
-static servers_data_t servers_data = {.timeout = SERVERS_DEF_TIMEOUT_MS, .enabled = false, .do_disable = false,
-                                      .do_enable = false, .do_reset = false};
+static servers_data_t servers_data = {.timeout = SERVERS_DEF_TIMEOUT_MS};
 static volatile bool sleep_sockets = false;
 
 /******************************************************************************
@@ -120,10 +121,16 @@ void TASK_Servers (void *pvParameters) {
         }
 
         if (sleep_sockets) {
-            sleep_sockets = false;
             pybwdt_srv_sleeping(true);
             modusocket_enter_sleep();
             pybwdt_srv_sleeping(false);
+            mp_hal_delay_ms(SERVERS_CYCLE_TIME_MS * 2);
+            if (servers_data.do_wlan_cycle_power) {
+                servers_data.do_wlan_cycle_power = false;
+                wlan_off_on();
+            }
+            sleep_sockets = false;
+
         }
 
         // set the alive flag for the wdt
@@ -152,6 +159,10 @@ void servers_reset (void) {
     servers_data.do_reset = true;
 }
 
+void servers_wlan_cycle_power (void) {
+    servers_data.do_wlan_cycle_power = true;
+}
+
 bool servers_are_enabled (void) {
     return servers_data.enabled;
 }

cc3200/serverstask.h

@@ -62,6 +62,7 @@ extern void TASK_Servers (void *pvParameters);
 extern void servers_start (void);
 extern void servers_stop (void);
 extern void servers_reset (void);
+extern void servers_wlan_cycle_power (void);
 extern bool servers_are_enabled (void);
 extern void servers_close_socket (int16_t *sd);
 extern void servers_set_login (char *user, char *pass);

cc3200/version.h

@@ -27,6 +27,6 @@
 #ifndef VERSION_H_
 #define VERSION_H_
 
-#define WIPY_SW_VERSION_NUMBER                              "1.1.1"
+#define WIPY_SW_VERSION_NUMBER                              "1.2.0"
 
 #endif /* VERSION_H_ */

docs/conf.py

@@ -21,6 +21,40 @@ import os
 # documentation root, use os.path.abspath to make it absolute, like shown here.
 #sys.path.insert(0, os.path.abspath('.'))
 
+# Work out the port to generate the docs for
+from collections import OrderedDict
+micropy_port = os.getenv('MICROPY_PORT') or 'pyboard'
+tags.add('port_' + micropy_port)
+ports = OrderedDict((
+    ('unix', ('unix', 'unix')),
+    ('pyboard', ('pyboard', 'the pyboard')),
+    ('wipy', ('WiPy', 'the WiPy')),
+    ('esp8266', ('ESP8266', 'the ESP8266')),
+))
+
+# The members of the html_context dict are available inside topindex.html
+micropy_version = os.getenv('MICROPY_VERSION') or 'latest'
+micropy_all_versions = (os.getenv('MICROPY_ALL_VERSIONS') or 'latest').split(',')
+url_pattern = '%s/en/%%s/%%s' % (os.getenv('MICROPY_URL_PREFIX') or '/',)
+html_context = {
+    'port':micropy_port,
+    'port_short_name':ports[micropy_port][0],
+    'port_name':ports[micropy_port][1],
+    'port_version':micropy_version,
+    'all_ports':[
+        (port_name[0], url_pattern % (micropy_version, port_id))
+            for port_id, port_name in ports.items()
+    ],
+    'all_versions':[
+        (ver, url_pattern % (ver, micropy_port))
+            for ver in micropy_all_versions
+    ],
+}
+
+
+# Specify a custom master document based on the port name
+master_doc = micropy_port + '_' + 'index'
+
 # -- General configuration ------------------------------------------------
 
 # If your documentation needs a minimal Sphinx version, state it here.
@@ -51,16 +85,16 @@ source_suffix = '.rst'
 
 # General information about the project.
 project = 'MicroPython'
-copyright = '2014, Damien P. George'
+copyright = '2014-2016, Damien P. George and contributors'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
 # built documents.
 #
 # The short X.Y version.
-version = '1.5'
+version = '1.7'
 # The full version, including alpha/beta/rc tags.
-release = '1.5.1'
+release = '1.7'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
@@ -213,8 +247,8 @@ latex_elements = {
 # (source start file, target name, title,
 #  author, documentclass [howto, manual, or own class]).
 latex_documents = [
-  ('index', 'MicroPython.tex', 'MicroPython Documentation',
-   'Damien P. George', 'manual'),
+  (master_doc, 'MicroPython.tex', 'MicroPython Documentation',
+   'Damien P. George and contributors', 'manual'),
 ]
 
 # The name of an image file (relative to this directory) to place at the top of
@@ -244,7 +278,7 @@ latex_documents = [
 # (source start file, name, description, authors, manual section).
 man_pages = [
     ('index', 'micropython', 'MicroPython Documentation',
-     ['Damien P. George'], 1),
+     ['Damien P. George and contributors'], 1),
 ]
 
 # If true, show URL addresses after external links.
@@ -257,8 +291,8 @@ man_pages = [
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-  ('index', 'MicroPython', 'MicroPython Documentation',
-   'Damien P. George', 'MicroPython', 'One line description of project.',
+  (master_doc, 'MicroPython', 'MicroPython Documentation',
+   'Damien P. George and contributors', 'MicroPython', 'One line description of project.',
    'Miscellaneous'),
 ]
 
@@ -278,33 +312,8 @@ texinfo_documents = [
 # Example configuration for intersphinx: refer to the Python standard library.
 intersphinx_mapping = {'http://docs.python.org/': None}
 
-
-# Work out the port to generate the docs for
-from collections import OrderedDict
-micropy_port = os.getenv('MICROPY_PORT') or 'pyboard'
-tags.add('port_' + micropy_port)
-ports = OrderedDict((
-    ("unix", "unix"),
-    ("pyboard", "the pyboard"),
-    ("wipy", "the WiPy"),
-    ("esp8266", "esp8266"),
-))
-
-# The members of the html_context dict are available inside topindex.html
-url_prefix = os.getenv('MICROPY_URL_PREFIX') or '/'
-html_context = {
-    'port':micropy_port,
-    'port_name':ports[micropy_port],
-    'all_ports':[(n, url_prefix + p) for p, n in ports.items()],
-}
-
 # Append the other ports' specific folders/files to the exclude pattern
 exclude_patterns.extend([port + '*' for port in ports if port != micropy_port])
 # Exclude pyb module if the port is the WiPy
 if micropy_port == 'wipy':
     exclude_patterns.append('library/pyb*')
-else: # exclude machine
-    exclude_patterns.append('library/machine*')
-
-# Specify a custom master document based on the port name
-master_doc = micropy_port + '_' + 'index'

docs/esp8266/quickref.rst

@@ -0,0 +1,254 @@
+.. _quickref:
+
+Quick reference for the ESP8266
+===============================
+
+.. image:: https://learn.adafruit.com/system/assets/assets/000/028/689/medium640/adafruit_products_pinoutstop.jpg
+    :alt: Adafruit Feather HUZZAH board
+    :width: 640px
+
+The Adafruit Feather HUZZAH board (image attribution: Adafruit).
+
+General board control
+---------------------
+
+The MicroPython REPL is on UART0 (GPIO1=TX, GPIO3=RX) at baudrate 115200.
+Tab-completion is useful to find out what methods an object has.
+Paste mode (ctrl-E) is useful to paste a large slab of Python code into
+the REPL.
+
+The ``machine`` module::
+
+    import machine
+
+    machine.freq()          # get the current frequency of the CPU
+    machine.freq(160000000) # set the CPU frequency to 160 MHz
+
+The ``esp`` module::
+
+    import esp
+
+    esp.osdebug(None)       # turn off vendor O/S debugging messages
+    esp.osdebug(0)          # redirect vendor O/S debugging messages to UART(0)
+
+Networking
+----------
+
+The ``network`` module::
+
+    import network
+
+    wlan = network.WLAN(network.STA_IF) # create station interface
+    wlan.active(True)       # activate the interface
+    wlan.scan()             # scan for access points
+    wlan.isconnected()      # check if the station is connected to an AP
+    wlan.connect('essid', 'password') # connect to an AP
+    wlan.mac()              # get the interface's MAC adddress
+    wlan.ifconfig()         # get the interface's IP/netmask/gw/DNS addresses
+
+    ap = network.WLAN(network.AP_IF) # create access-point interface
+    ap.active(True)         # activate the interface
+    ap.config(essid='ESP-AP') # set the ESSID of the access point
+
+A useful function for connecting to your local WiFi network is::
+
+    def do_connect():
+        import network
+        wlan = network.WLAN(network.STA_IF)
+        wlan.active(True)
+        if not wlan.isconnected():
+            print('connecting to network...')
+            wlan.connect('essid', 'password')
+            while not wlan.isconnected():
+                pass
+        print('network config:', wlan.ifconfig())
+
+Once the network is established the ``socket`` module can be used
+to create and use TCP/UDP sockets as usual.
+
+Delay and timing
+----------------
+
+Use the ``time`` module::
+
+    import time
+
+    time.sleep(1)           # sleep for 1 second
+    time.sleep_ms(500)      # sleep for 500 milliseconds
+    time.sleep_us(10)       # sleep for 10 microseconds
+    start = time.ticks_ms() # get millisecond counter
+    delta = time.ticks_diff(start, time.ticks_ms()) # compute time difference
+
+Timers
+------
+
+Virtual (RTOS-based) timers are supported. Use the ``machine.Timer`` class
+with timer ID of -1::
+
+    from machine import Timer
+
+    tim = Timer(-1)
+    tim.init(period=5000, mode=Timer.ONE_SHOT, callback=lambda t:print(1))
+    tim.init(period=2000, mode=Timer.PERIODIC, callback=lambda t:print(2))
+
+The period is in milliseconds.
+
+Pins and GPIO
+-------------
+
+Use the ``machine.Pin`` class::
+
+    from machine import Pin
+
+    p0 = Pin(0, Pin.OUT)    # create output pin on GPIO0
+    p0.high()               # set pin to high
+    p0.low()                # set pin to low
+    p0.value(1)             # set pin to high
+
+    p2 = Pin(2, Pin.IN)     # create input pin on GPIO2
+    print(p2.value())       # get value, 0 or 1
+
+    p4 = Pin(4, Pin.IN, Pin.PULL_UP) # enable internal pull-up resistor
+    p5 = Pin(5, Pin.OUT, value=1) # set pin high on creation
+
+Available pins are: 0, 1, 2, 3, 4, 5, 12, 13, 14, 15, 16, which correspond
+to the actual GPIO pin numbers of ESP8266 chip. Note that many end-user
+boards use their own adhoc pin numbering (marked e.g. D0, D1, ...). As
+MicroPython supports different boards and modules, physical pin numbering
+was chosen as the lowest common denominator. For mapping between board
+logical pins and physical chip pins, consult your board documentation.
+
+Note that Pin(1) and Pin(3) are REPL UART TX and RX respectively.
+Also note that Pin(16) is a special pin (used for wakeup from deepsleep
+mode) and may be not available for use with higher-level classes like
+``Neopixel``.
+
+PWM (pulse width modulation)
+----------------------------
+
+PWM can be enabled on all pins except Pin(16).  There is a single frequency
+for all channels, with range between 1 and 1000 (measured in Hz).  The duty
+cycle is between 0 and 1023 inclusive.
+
+Use the ``machine.PWM`` class::
+
+    from machine import Pin, PWM
+
+    pwm0 = PWM(Pin(0))      # create PWM object from a pin
+    pwm0.freq()             # get current frequency
+    pwm0.freq(1000)         # set frequency
+    pwm0.duty()             # get current duty cycle
+    pwm0.duty(200)          # set duty cycle
+    pwm0.deinit()           # turn off PWM on the pin
+
+    pwm2 = PWM(Pin(2), freq=500, duty=512) # create and configure in one go
+
+ADC (analog to digital conversion)
+----------------------------------
+
+ADC is available on a dedicated pin.
+Note that input voltages on the ADC pin must be between 0v and 1.0v.
+
+Use the ``machine.ADC`` class::
+
+    from machine import ADC
+
+    adc = ADC(0)            # create ADC object on ADC pin
+    adc.read()              # read value, 0-1024
+
+SPI bus
+-------
+
+The SPI driver is implemented in software and works on all pins::
+
+    from machine import Pin, SPI
+
+    # construct an SPI bus on the given pins
+    # polarity is the idle state of SCK
+    # phase=0 means sample on the first edge of SCK, phase=1 means the second
+    spi = SPI(baudrate=100000, polarity=1, phase=0, sck=Pin(0), mosi=Pin(2), miso=Pin(4))
+
+    spi.init(baudrate=200000) # set the baudrate
+
+    spi.read(10)            # read 10 bytes on MISO
+    spi.read(10, 0xff)      # read 10 bytes while outputing 0xff on MOSI
+
+    buf = bytearray(50)     # create a buffer
+    spi.readinto(buf)       # read into the given buffer (reads 50 bytes in this case)
+    spi.readinto(buf, 0xff) # read into the given buffer and output 0xff on MOSI
+
+    spi.write(b'12345')     # write 5 bytes on MOSI
+
+    buf = bytearray(4)      # create a buffer
+    spi.write_readinto(b'1234', buf) # write to MOSI and read from MISO into the buffer
+    spi.write_readinto(buf, buf) # write buf to MOSI and read MISO back into buf
+
+I2C bus
+-------
+
+The I2C driver is implemented in software and works on all pins::
+
+    from machine import Pin, I2C
+
+    # construct an I2C bus
+    i2c = I2C(scl=Pin(5), sda=Pin(4), freq=100000)
+
+    i2c.readfrom(0x3a, 4)   # read 4 bytes from slave device with address 0x3a
+    i2c.writeto(0x3a, '12') # write '12' to slave device with address 0x3a
+
+    buf = bytearray(10)     # create a buffer with 10 bytes
+    i2c.writeto(0x3a, buf)  # write the given buffer to the slave
+
+    i2c.readfrom(0x3a, 4, stop=False) # don't send a stop bit after reading
+    i2c.writeto(0x3a, buf, stop=False) # don't send a stop bit after writing
+
+OneWire driver
+--------------
+
+The OneWire driver is implemented in software and works on all pins::
+
+    from machine import Pin
+    import onewire
+
+    ow = onewire.OneWire(Pin(12)) # create a OneWire bus on GPIO12
+    ow.scan()               # return a list of devices on the bus
+    ow.reset()              # reset the bus
+    ow.read_byte()          # read a byte
+    ow.read_bytes(5)        # read 5 bytes
+    ow.write_byte(0x12)     # write a byte on the bus
+    ow.write_bytes('123')   # write bytes on the bus
+    ow.select_rom(b'12345678') # select a specific device by its ROM code
+
+There is a specific driver for DS18B20 devices::
+
+    import time
+    ds = onewire.DS18B20(ow)
+    roms = ds.scan()
+    ds.start_measure()
+    time.sleep_ms(750)
+    for rom in roms:
+        print(ds.get_temp(rom))
+
+Be sure to put a 4.7k pull-up resistor on the data line.
+
+NeoPixel driver
+---------------
+
+Use the ``neopixel`` module::
+
+    from machine import Pin
+    from neopixel import NeoPixel
+
+    pin = Pin(0, Pin.OUT)   # set GPIO0 to output to drive NeoPixels
+    np = NeoPixel(pin, 8)   # create NeoPixel driver on GPIO0 for 8 pixels
+    np[0] = (255, 255, 255) # set the first pixel to white
+    np.write()              # write data to all pixels
+    r, g, b = np[0]         # get first pixel colour
+
+    import neopixel
+    neopixel.demo(np)       # run a demo
+
+For low-level driving of a NeoPixel::
+
+    import esp
+    esp.neopixel_write(pin, grb_buf, is800khz)

docs/esp8266_contents.rst

@@ -3,6 +3,7 @@ MicroPython documentation contents
 
 .. toctree::
 
+    esp8266/quickref.rst
     library/index.rst
     reference/index.rst
     license.rst

docs/esp8266_index.rst

@@ -3,6 +3,7 @@ MicroPython documentation and references
 
 .. toctree::
 
+    esp8266/quickref.rst
     library/index.rst
     license.rst
     esp8266_contents.rst

docs/library/esp.rst

@@ -10,46 +10,6 @@ The ``esp`` module contains specific functions related to the ESP8266 module.
 Functions
 ---------
 
-.. function:: mac([address])
-
-    Get or set the network interface's MAC address.
-
-    If the ``address`` parameter is provided, sets the address to its value. If
-    the function is called wihout parameters, returns the current address.
-
-.. function:: getaddrinfo((hostname, port, lambda))
-
-    Initiate resolving of the given hostname.
-
-    When the hostname is resolved, the provided ``lambda`` callback will be
-    called with two arguments, first being the hostname being resolved,
-    second a tuple with information about that hostname.
-
-.. function:: wifi_mode([mode])
-
-    Get or set the wireless network operating mode.
-
-    If the ``mode`` parameter is provided, sets the mode to its value. If
-    the function is called wihout parameters, returns the current mode.
-
-    The possible modes are defined as constants:
-
-        * ``STA_MODE`` -- station mode,
-        * ``AP_MODE`` -- software access point mode,
-        * ``STA_AP_MODE`` -- mixed station and software access point mode.
-
-.. function:: phy_mode([mode])
-
-    Get or set the network interface mode.
-
-    If the ``mode`` parameter is provided, sets the mode to its value. If
-    the function is called wihout parameters, returns the current mode.
-
-    The possible modes are defined as constants:
-        * ``MODE_11B`` -- IEEE 802.11b,
-        * ``MODE_11G`` -- IEEE 802.11g,
-        * ``MODE_11N`` -- IEEE 802.11n.
-
 .. function:: sleep_type([sleep_type])
 
     Get or set the sleep type.
@@ -79,11 +39,3 @@ Functions
 .. function:: flash_id()
 
     Read the device ID of the flash memory.
-
-Classes
--------
-
-.. toctree::
-    :maxdepth: 1
-
-    esp.socket.rst

docs/library/index.rst

@@ -55,6 +55,17 @@ For additional libraries, please download them from the `micropython-lib reposit
        sys.rst
        time.rst
 
+.. only:: port_esp8266
+
+    .. toctree::
+       :maxdepth: 1
+
+       gc.rst
+       math.rst
+       struct.rst
+       sys.rst
+       time.rst
+
 Python micro-libraries
 ----------------------
 
@@ -85,6 +96,19 @@ library.
       usocket.rst
       uzlib.rst
 
+.. only:: port_esp8266
+
+   .. toctree::
+      :maxdepth: 1
+
+      ubinascii.rst
+      uctypes.rst
+      uhashlib.rst
+      uheapq.rst
+      ujson.rst
+      ure.rst
+      uzlib.rst
+
 .. only:: port_pyboard
 
    Libraries specific to the pyboard
@@ -134,6 +158,6 @@ library.
    .. toctree::
       :maxdepth: 2
 
-      pyb.rst
-      esp.rst
       network.rst
+      esp.rst
+      machine.rst

docs/library/machine.Pin.rst

@@ -24,7 +24,7 @@ Usage Model:
             print(pin.id())
 
         pin_int = Pin('GP10', mode=Pin.IN, pull=Pin.PULL_DOWN)
-        pin_int.irq(mode=Pin.IRQ_RISING, handler=pincb)
+        pin_int.irq(trigger=Pin.IRQ_RISING, handler=pincb)
         # the callback can be triggered manually
         pin_int.irq()()
         # to disable the callback

docs/library/machine.Timer.rst

@@ -5,55 +5,49 @@ class Timer -- control internal timers
 
 .. only:: port_wipy
 
-    .. note::
-
-        Contrary with the rest of the API, timer IDs start at 1, not a t zero. This is because
-        the ``Timer`` API is still provisional. A new MicroPython wide API will come soon.
-
     Timers can be used for a great variety of tasks, calling a function periodically,
     counting events, and generating a PWM signal are among the most common use cases.
-    Each timer consists of 2 16-bit channels and this channels can be tied together to
-    form 1 32-bit timer. The operating mode needs to be configured per timer, but then
+    Each timer consists of two 16-bit channels and this channels can be tied together to
+    form one 32-bit timer. The operating mode needs to be configured per timer, but then
     the period (or the frequency) can be independently configured on each channel. 
     By using the callback method, the timer event can call a Python function.
 
     Example usage to toggle an LED at a fixed frequency::
 
         from machine import Timer
-        tim = Timer(4)                                   # create a timer object using timer 4
+        from machine import Pin
+        led = Pin('GP16', mode=Pin.OUT)                  # enable GP16 as output to drive the LED
+        tim = Timer(3)                                   # create a timer object using timer 3
         tim.init(mode=Timer.PERIODIC)                    # initialize it in periodic mode
-        tim_ch = tim.channel(Timer.A, freq=2)            # configure channel A at a frequency of 2Hz
-        tim_ch.callback(handler=lambda t:led.toggle())   # toggle a LED on every cycle of the timer
+        tim_ch = tim.channel(Timer.A, freq=5)            # configure channel A at a frequency of 5Hz
+        tim_ch.irq(handler=lambda t:led.toggle(), trigger=Timer.TIMEOUT)        # toggle a LED on every cycle of the timer
 
     Example using named function for the callback::
 
         from machine import Timer
-        tim = Timer(1, mode=Timer.PERIODIC)
-        tim_a = tim.channel(Timer.A, freq=1000)
+        from machine import Pin
+        tim = Timer(1, mode=Timer.PERIODIC, width=32)
+        tim_a = tim.channel(Timer.A | Timer.B, freq=1)   # 1 Hz frequency requires a 32 bit timer
 
-        led = Pin('GPIO2', mode=Pin.OUT)
+        led = Pin('GP16', mode=Pin.OUT) # enable GP16 as output to drive the LED
 
         def tick(timer):                # we will receive the timer object when being called
-            print(timer.time())         # show current timer's time value (is microseconds)
+            global led
             led.toggle()                # toggle the LED
 
-        tim_a.callback(handler=tick)
+        tim_a.irq(handler=tick, trigger=Timer.TIMEOUT)         # create the interrupt
 
     Further examples::
 
         from machine import Timer
-        tim1 = Timer(2, mode=Timer.EVENT_COUNT)                         # initialize it capture mode
-        tim2 = Timer(1, mode=Timer.PWM)                                 # initialize it in PWM mode
-        tim_ch = tim1.channel(Timer.A, freq=1, polarity=Timer.POSITIVE) # start the event counter with a frequency of 1Hz and triggered by positive edges
-        tim_ch = tim2.channel(Timer.B, freq=10000, duty_cycle=50)       # start the PWM on channel B with a 50% duty cycle
-        tim_ch.time()                                                   # get the current time in usec (can also be set)
-        tim_ch.freq(20)                                                 # set the frequency (can also get)
-        tim_ch.duty_cycle(30)                                           # set the duty cycle to 30% (can also get)
-        tim_ch.duty_cycle(30, Timer.NEGATIVE)                           # set the duty cycle to 30% and change the polarity to negative
-        tim_ch.event_count()                                            # get the number of captured events
-        tim_ch.event_time()                                             # get the the time of the last captured event
-        tim_ch.period(2000000)                                          # change the period to 2 seconds
-
+        tim1 = Timer(1, mode=Timer.ONE_SHOT)                               # initialize it in one shot mode
+        tim2 = Timer(2, mode=Timer.PWM)                                    # initialize it in PWM mode
+        tim1_ch = tim1.channel(Timer.A, freq=10, polarity=Timer.POSITIVE)  # start the event counter with a frequency of 10Hz and triggered by positive edges
+        tim2_ch = tim2.channel(Timer.B, freq=10000, duty_cycle=5000)       # start the PWM on channel B with a 50% duty cycle
+        tim2_ch.freq(20)                                                   # set the frequency (can also get)
+        tim2_ch.duty_cycle(3010)                                           # set the duty cycle to 30.1% (can also get)
+        tim2_ch.duty_cycle(3020, Timer.NEGATIVE)                           # set the duty cycle to 30.2% and change the polarity to negative
+        tim2_ch.period(2000000)                                            # change the period to 2 seconds
 
 .. note::
 
@@ -69,9 +63,7 @@ Constructors
 
     .. only:: port_wipy
 
-       Construct a new timer object of the given id.  If additional
-       arguments are given, then the timer is initialised by ``init(...)``.
-       ``id`` can be 1 to 4.
+       Construct a new timer object of the given id. ``id`` can take values from 0 to 3.
 
 
 Methods
@@ -94,10 +86,9 @@ Methods
              period of the channel expires.
            - ``Timer.PERIODIC`` - The timer runs periodically at the configured 
              frequency of the channel.
-           - ``Timer.EDGE_TIME`` - Meaure the time pin level changes.
-           - ``Timer.EDGE_COUNT`` - Count the number of pin level changes.
+           - ``Timer.PWM``      - Output a PWM signal on a pin.
 
-         - ``width`` must be either 16 or 32 (bits). For really low frequencies <= ~1Hz
+         - ``width`` must be either 16 or 32 (bits). For really low frequencies < 5Hz
            (or large periods), 32-bit timers should be used. 32-bit mode is only available
            for ``ONE_SHOT`` AND ``PERIODIC`` modes.
 
@@ -112,7 +103,7 @@ Methods
     
        If only a channel identifier passed, then a previously initialized channel
        object is returned (or ``None`` if there is no previous channel).
-       
+
        Othwerwise, a TimerChannel object is initialized and returned.
        
        The operating mode is is the one configured to the Timer object that was used to
@@ -130,12 +121,22 @@ Methods
 
             Either ``freq`` or ``period`` must be given, never both.
 
-         - ``polarity`` this is applicable for:
-           
-           - ``PWM``, defines the polarity of the duty cycle
-           - ``EDGE_TIME`` and ``EDGE_COUNT``, defines the polarity of the pin level change to detect.
-             To detect both rising and falling edges, make ``polarity=Timer.POSITIVE | Timer.NEGATIVE``.
-         - ``duty_cycle`` only applicable to ``PWM``. It's a percentage (0-100)
+         - ``polarity`` this is applicable for ``PWM``, and defines the polarity of the duty cycle
+         - ``duty_cycle`` only applicable to ``PWM``. It's a percentage (0.00-100.00). Since the WiPy
+           doesn't support floating point numbers the duty cycle must be specified in the range 0-10000,
+           where 10000 would represent 100.00, 5050 represents 50.50, and so on.
+
+       .. note::
+
+          When the channel is in PWM mode, the corresponding pin is assigned automatically, therefore
+          there's no need to assign the alternate function of the pin via the ``Pin`` class. The pins which
+          support PWM functionality are the following:
+
+          - ``GP24`` on Timer 0 channel A.
+          - ``GP25`` on Timer 1 channel A.
+          - ``GP9``  on Timer 2 channel B.
+          - ``GP10`` on Timer 3 channel A.
+          - ``GP11`` on Timer 3 channel B.
 
 class TimerChannel --- setup a channel for a timer
 ==================================================
@@ -166,31 +167,49 @@ Methods
             - ``priority`` level of the interrupt. Can take values in the range 1-7.
               Higher values represent higher priorities.
             - ``handler`` is an optional function to be called when the interrupt is triggered.
+            - ``trigger`` must be ``Timer.TIMEOUT`` when the operating mode is either ``Timer.PERIODIC`` or
+              ``Timer.ONE_SHOT``. In the case that mode is ``Timer.PWM`` then trigger must be equal to
+              ``Timer.MATCH``.
 
         Returns a callback object.
 
 .. only:: port_wipy
 
     .. method:: timerchannel.freq([value])
-    
+
        Get or set the timer channel frequency (in Hz).
 
     .. method:: timerchannel.period([value])
 
        Get or set the timer channel period (in microseconds).
-       
-    .. method:: timerchannel.time([value])
-
-       Get or set the timer channel current **time** value (in microseconds).
-    
-    .. method:: timerchannel.event_count()
-
-       Get the number of edge events counted.
-
-    .. method:: timerchannel.event_time()
-
-       Get the time of ocurrance of the last event.
 
     .. method:: timerchannel.duty_cycle([value])
-     
-       Get or set the duty cycle of the PWM signal (in the range of 0-100).
+
+       Get or set the duty cycle of the PWM signal. It's a percentage (0.00-100.00). Since the WiPy
+       doesn't support floating point numbers the duty cycle must be specified in the range 0-10000,
+       where 10000 would represent 100.00, 5050 represents 50.50, and so on.
+
+Constants
+---------
+
+.. data:: Timer.ONE_SHOT
+.. data:: Timer.PERIODIC
+.. data:: Timer.PWM
+
+   Selects the timer operating mode.
+
+.. data:: Timer.A
+.. data:: Timer.B
+
+   Selects the timer channel. Must be ORed (``Timer.A`` | ``Timer.B``) when
+   using a 32-bit timer.
+
+.. data:: Timer.POSITIVE
+.. data:: Timer.NEGATIVE
+
+   Timer channel polarity selection (only relevant in PWM mode).
+
+.. data:: Timer.TIMEOUT
+.. data:: Timer.MATCH
+
+   Timer channel IRQ triggers.

docs/library/machine.rst

@@ -11,7 +11,7 @@ Reset related functions
 
 .. function:: reset()
 
-   Resets the WiPy in a manner similar to pushing the external RESET
+   Resets the device in a manner similar to pushing the external RESET
    button.
 
 .. function:: reset_cause()
@@ -87,7 +87,7 @@ Miscellaneous functions
 .. function:: unique_id()
 
    Returns a string of 6 bytes (48 bits), which is the unique ID of the MCU.
-   This also corresponds to the ``MAC address`` of the WiPy.
+   This also corresponds to the network ``MAC address``.
 
 .. _machine_constants:
 

docs/library/network.rst

@@ -8,7 +8,8 @@
 This module provides network drivers and routing configuration.  Network
 drivers for specific hardware are available within this module and are
 used to configure a hardware network interface.  Configured interfaces
-are then available for use via the :mod:`socket` module.
+are then available for use via the :mod:`socket` module. To use this module
+the network build of firmware must be installed.
 
 For example::
 
@@ -29,19 +30,27 @@ For example::
 
 .. only:: port_wipy
 
-    .. _network.server:
+    .. _network.Server:
 
-    class server
+    class Server
     ============
 
-    The server class controls the behaviour and the configuration of the FTP and telnet
+    The ``Server`` class controls the behaviour and the configuration of the FTP and telnet
     services running on the WiPy. Any changes performed using this class' methods will
     affect both.
 
+    Example::
+
+    import network
+    server = network.Server()
+    server.deinit() # disable the server
+    # enable the server again with new settings
+    server.init(login=('user', 'password'), timeout=600)
+
     Constructors
     ------------
 
-    .. class:: network.server(id, ...)
+    .. class:: network.Server(id, ...)
 
        Create a server instance, see ``init`` for parameters of initialization.
 
@@ -220,26 +229,52 @@ For example::
 
 .. only:: port_esp8266
 
+    Functions
+    =========
+
+    .. function:: phy_mode([mode])
+
+        Get or set the PHY mode.
+
+        If the ``mode`` parameter is provided, sets the mode to its value. If
+        the function is called wihout parameters, returns the current mode.
+
+        The possible modes are defined as constants:
+            * ``MODE_11B`` -- IEEE 802.11b,
+            * ``MODE_11G`` -- IEEE 802.11g,
+            * ``MODE_11N`` -- IEEE 802.11n.
+
     class WLAN
     ==========
 
     This class provides a driver for WiFi network processor in the ESP8266.  Example usage::
 
         import network
-        # setup as a station
-        nic = network.WLAN()
+        # enable station interface and connect to WiFi access point
+        nic = network.WLAN(network.STA_IF)
+        nic.active(True)
         nic.connect('your-ssid', 'your-password')
-        # now use socket as usual
+        # now use sockets as usual
 
     Constructors
     ------------
-    .. class:: WLAN()
+    .. class:: WLAN(interface_id)
 
-    Create a WLAN driver object.
+    Create a WLAN network interface object. Supported interfaces are
+    ``network.STA_IF`` (station aka client, connects to upstream WiFi access
+    points) and ``network.AP_IF`` (access point, allows other WiFi clients to
+    connect). Availability of the methods below depends on interface type.
+    For example, only STA interface may ``connect()`` to an access point.
 
     Methods
     -------
 
+    .. method:: wlan.active([is_active])
+
+        Activate ("up") or deactivate ("down") network interface, if boolean
+        argument is passed. Otherwise, query current state if no argument is
+        provided. Most other methods require active interface.
+
     .. method:: wlan.connect(ssid, password)
 
         Connect to the specified wireless network, using the specified password.
@@ -248,16 +283,20 @@ For example::
 
         Disconnect from the currently connected wireless network.
 
-    .. method:: wlan.scan(cb)
+    .. method:: wlan.mac([address])
 
-        Initiate scanning for the available wireless networks.
+        Get or set the network interface MAC address.
 
-        Scanning is only possible if the radio is in station or station+AP mode; if
-        called while in AP only mode, an OSError exception will be raised.
+        If the ``address`` parameter is provided, sets the address to its
+        value, which should be bytes object of length 6. If the function
+        is called wihout parameters, returns the current address.
 
-        Once the scanning is complete, the provided callback function ``cb`` will
-        be called once for each network found, and passed a tuple with information
-        about that network:
+    .. method:: wlan.scan()
+
+        Scan for the available wireless networks.
+
+        Scanning is only possible on STA interface. Returns list of tuples with
+        the information about WiFi access points:
 
             (ssid, bssid, channel, RSSI, authmode, hidden)
 
@@ -274,7 +313,7 @@ For example::
             * 0 -- visible
             * 1 -- hidden
 
-    .. method:: status()
+    .. method:: wlan.status()
 
         Return the current status of the wireless connection.
 

docs/library/os.rst

@@ -4,12 +4,13 @@
 .. module:: os
    :synopsis: basic "operating system" services
 
-The ``os`` module contains functions for filesystem access and ``urandom``.
+The ``os`` module contains functions for filesystem access and ``urandom``
+function.
 
-Pyboard specifics
------------------
+Port specifics
+--------------
 
-The filesystem on the pyboard has ``/`` as the root directory and the
+The filesystem has ``/`` as the root directory and the
 available physical drives are accessible from here.  They are currently:
 
     ``/flash``      -- the internal flash filesystem

docs/library/pyb.ADC.rst

@@ -18,6 +18,7 @@ class ADC -- analog to digital conversion
         val = adc.read_core_vbat()      # read MCU VBAT
         val = adc.read_core_vref()      # read MCU VREF
 
+ 
 Constructors
 ------------
 
@@ -74,3 +75,68 @@ Methods
 
        This function does not allocate any memory.
 
+The ADCAll Object
+-----------------
+
+.. only:: port_pyboard
+
+    Instantiating this changes all ADC pins to analog inputs. The raw MCU temperature,
+    VREF and VBAT data can be accessed on ADC channels 16, 17 and 18 respectively.
+    Appropriate scaling will need to be applied. The temperature sensor on the chip
+    has poor absolute accuracy and is suitable only for detecting temperature changes.
+
+    The ``ADCAll`` ``read_core_vbat()`` and ``read_core_vref()`` methods read
+    the backup battery voltage and the (1.21V nominal) reference voltage using the
+    3.3V supply as a reference. Assuming the ``ADCAll`` object has been Instantiated with
+    ``adc = pyb.ADCAll(12)`` the 3.3V supply voltage may be calculated:
+    
+    ``v33 = 3.3 * 1.21 / adc.read_core_vref()``
+
+    If the 3.3V supply is correct the value of ``adc.read_core_vbat()`` will be
+    valid. If the supply voltage can drop below 3.3V, for example in in battery
+    powered systems with a discharging battery, the regulator will fail to preserve
+    the 3.3V supply resulting in an incorrect reading. To produce a value which will
+    remain valid under these circumstances use the following:
+
+    ``vback = adc.read_core_vbat() * 1.21 / adc.read_core_vref()``
+
+    It is possible to access these values without incurring the side effects of ``ADCAll``::
+    
+        def adcread(chan):                              # 16 temp 17 vbat 18 vref
+            assert chan >= 16 and chan <= 18, 'Invalid ADC channel'
+            start = pyb.millis()
+            timeout = 100
+            stm.mem32[stm.RCC + stm.RCC_APB2ENR] |= 0x100 # enable ADC1 clock.0x4100
+            stm.mem32[stm.ADC1 + stm.ADC_CR2] = 1       # Turn on ADC
+            stm.mem32[stm.ADC1 + stm.ADC_CR1] = 0       # 12 bit
+            if chan == 17:
+                stm.mem32[stm.ADC1 + stm.ADC_SMPR1] = 0x200000 # 15 cycles
+                stm.mem32[stm.ADC + 4] = 1 << 23
+            elif chan == 18:
+                stm.mem32[stm.ADC1 + stm.ADC_SMPR1] = 0x1000000
+                stm.mem32[stm.ADC + 4] = 0xc00000
+            else:
+                stm.mem32[stm.ADC1 + stm.ADC_SMPR1] = 0x40000
+                stm.mem32[stm.ADC + 4] = 1 << 23
+            stm.mem32[stm.ADC1 + stm.ADC_SQR3] = chan
+            stm.mem32[stm.ADC1 + stm.ADC_CR2] = 1 | (1 << 30) | (1 << 10) # start conversion
+            while not stm.mem32[stm.ADC1 + stm.ADC_SR] & 2: # wait for EOC
+                if pyb.elapsed_millis(start) > timeout:
+                    raise OSError('ADC timout')
+            data = stm.mem32[stm.ADC1 + stm.ADC_DR]     # clear down EOC
+            stm.mem32[stm.ADC1 + stm.ADC_CR2] = 0       # Turn off ADC
+            return data
+
+        def v33():
+            return 4096 * 1.21 / adcread(17)
+
+        def vbat():
+            return  1.21 * 2 * adcread(18) / adcread(17)  # 2:1 divider on Vbat channel
+
+        def vref():
+            return 3.3 * adcread(17) / 4096
+
+        def temperature():
+            return 25 + 400 * (3.3 * adcread(16) / 4096 - 0.76)
+
+    

docs/library/pyb.I2C.rst

@@ -63,16 +63,24 @@ Constructors
 
     .. class:: pyb.I2C(bus, ...)
 
-       Construct an I2C object on the given bus.  ``bus`` can be 1 or 2.
-       With no additional parameters, the I2C object is created but not
+       Construct an I2C object on the given bus.  ``bus`` can be 1 or 2, 'X' or
+       'Y'. With no additional parameters, the I2C object is created but not
        initialised (it has the settings from the last initialisation of
        the bus, if any).  If extra arguments are given, the bus is initialised.
        See ``init`` for parameters of initialisation.
 
-       The physical pins of the I2C busses are:
+       The physical pins of the I2C busses on Pyboards V1.0 and V1.1 are:
 
          - ``I2C(1)`` is on the X position: ``(SCL, SDA) = (X9, X10) = (PB6, PB7)``
          - ``I2C(2)`` is on the Y position: ``(SCL, SDA) = (Y9, Y10) = (PB10, PB11)``
+       
+       On the Pyboard Lite:
+       
+         - ``I2C(1)`` is on the X position: ``(SCL, SDA) = (X9, X10) = (PB6, PB7)``
+         - ``I2C(3)`` is on the Y position: ``(SCL, SDA) = (Y9, Y10) = (PA8, PB8)``
+         
+       Calling the constructor with 'X' or 'Y' enables portability between Pyboard
+       types.
 
 Methods
 -------

docs/library/pyb.LED.rst

@@ -25,6 +25,12 @@ Methods
    If no argument is given, return the LED intensity.
    If an argument is given, set the LED intensity and return ``None``.
 
+   *Note:* Only LED(3) and LED(4) can have a smoothly varying intensity, and
+   they use timer PWM to implement it.  LED(3) uses Timer(2) and LED(4) uses
+   Timer(3).  These timers are only configured for PWM if the intensity of the
+   relevant LED is set to a value between 1 and 254.  Otherwise the timers are
+   free for general purpose use.
+
 .. method:: led.off()
 
    Turn the LED off.

docs/library/pyb.SPI.rst

@@ -33,9 +33,9 @@ Constructors
 
     .. class:: pyb.SPI(bus, ...)
 
-       Construct an SPI object on the given bus.  ``bus`` can be 1 or 2.
-       With no additional parameters, the SPI object is created but not
-       initialised (it has the settings from the last initialisation of
+       Construct an SPI object on the given bus.  ``bus`` can be 1 or 2, or
+       'X' or 'Y'. With no additional parameters, the SPI object is created but
+       not initialised (it has the settings from the last initialisation of
        the bus, if any).  If extra arguments are given, the bus is initialised.
        See ``init`` for parameters of initialisation.
 

docs/library/pyb.Timer.rst

@@ -37,9 +37,13 @@ class Timer -- control internal timers
         tim.callback(lambda t: ...)     # set callback for update interrupt (t=tim instance)
         tim.callback(None)              # clear callback
     
-    *Note:* Timer 3 is reserved for internal use.  Timer 5 controls
-    the servo driver, and Timer 6 is used for timed ADC/DAC reading/writing.
-    It is recommended to use the other timers in your programs.
+    *Note:* Timer(2) and Timer(3) are used for PWM to set the intensity of LED(3)
+    and LED(4) respectively.  But these timers are only configured for PWM if
+    the intensity of the relevant LED is set to a value between 1 and 254.  If
+    the intensity feature of the LEDs is not used then these timers are free for
+    general purpose use.  Similarly, Timer(5) controls the servo driver, and
+    Timer(6) is used for timed ADC/DAC reading/writing.  It is recommended to
+    use the other timers in your programs.
 
 *Note:* Memory can't be allocated during a callback (an interrupt) and so
 exceptions raised within a callback don't give much information.  See
@@ -56,7 +60,7 @@ Constructors
     
        Construct a new timer object of the given id.  If additional
        arguments are given, then the timer is initialised by ``init(...)``.
-       ``id`` can be 1 to 14, excluding 3.
+       ``id`` can be 1 to 14.
 
 Methods
 -------

docs/library/pyb.UART.rst

@@ -103,7 +103,7 @@ Methods
 
     .. method:: uart.any()
 
-       Return ``True`` if any characters waiting, else ``False``.
+       Returns the number of characters waiting (may be 0).
 
     .. method:: uart.writechar(char)
 

docs/library/pyb.rst

@@ -25,6 +25,10 @@ Time related functions
    after 2^30 milliseconds (about 12.4 days) this will start to return
    negative numbers.
 
+   Note that if :meth:`pyb.stop()` is issued the hardware counter supporting this
+   function will pause for the duration of the "sleeping" state. This
+   will affect the outcome of :meth:`pyb.elapsed_millis()`.
+
 .. function:: micros()
 
    Returns the number of microseconds since the board was last reset.
@@ -33,6 +37,10 @@ Time related functions
    after 2^30 microseconds (about 17.8 minutes) this will start to return
    negative numbers.
 
+   Note that if :meth:`pyb.stop()` is issued the hardware counter supporting this
+   function will pause for the duration of the "sleeping" state. This
+   will affect the outcome of :meth:`pyb.elapsed_micros()`.
+
 .. function:: elapsed_millis(start)
 
    Returns the number of milliseconds which have elapsed since ``start``.

docs/library/time.rst

@@ -44,7 +44,7 @@ Functions
     
        Sleep for the given number of seconds.
 
-.. only:: port_wipy
+.. only:: port_wipy or port_pyboard
 
     .. function::  sleep_ms(ms)
 

docs/library/ubinascii.rst

@@ -10,11 +10,25 @@ encodings of it in ASCII form (in both directions).
 Functions
 ---------
 
-.. function:: hexlify(data)
+.. function:: hexlify(data, [sep])
 
    Convert binary data to hexadecimal representation. Return bytes string.
 
+   .. admonition:: Difference to CPython
+      :class: attention
+
+      If additional argument, `sep` is supplied, it is used as a seperator
+      between hexadecimal values.
+
 .. function:: unhexlify(data)
 
    Convert hexadecimal data to binary representation. Return bytes string.
    (i.e. inverse of hexlify)
+
+.. function:: a2b_base64(data)
+
+   Convert Base64-encoded data to binary representation. Return bytes string.
+
+.. function:: b2a_base64(data)
+
+   Encode binary data in Base64 format. Return string.

docs/library/uctypes.rst

@@ -6,7 +6,7 @@
 
 This module implements "foreign data interface" for MicroPython. The idea
 behind it is similar to CPython's ``ctypes`` modules, but actual API is
-different, steamlined and optimized for small size.
+different, streamlined and optimized for small size.
 
 Defining structure layout
 -------------------------

docs/pyboard/tutorial/assembler.rst

@@ -64,8 +64,8 @@ This code uses a few new concepts:
 Accepting arguments
 -------------------
 
-Inline assembler functions can accept up to 3 arguments.  If they are
-used, they must be named ``r0``, ``r1`` and ``r2`` to reflect the registers
+Inline assembler functions can accept up to 4 arguments.  If they are
+used, they must be named ``r0``, ``r1``, ``r2`` and ``r3`` to reflect the registers
 and the calling conventions.
 
 Here is a function that adds its arguments::

docs/pyboard/tutorial/switch.rst

@@ -99,3 +99,9 @@ The above sequence of events gets a bit more complicated when multiple
 interrupts occur at the same time.  In that case, the interrupt with the
 highest priority goes first, then the others in order of their priority.
 The switch interrupt is set at the lowest priority.
+
+Further reading
+---------------
+
+For further information about using hardware interrupts see
+:ref:`writing interrupt handlers <isr_rules>`.

docs/reference/asm_thumb2_hints_tips.rst

@@ -78,11 +78,23 @@ three arguments, which must (if used) be named ``r0``, ``r1`` and ``r2``. When
 the code executes the registers will be initialised to those values.
 
 The data types which can be passed in this way are integers and memory
-addresses. Further, integers are restricted in that the top two bits
-must be identical, limiting the range to -2**30 to 2**30 -1. Return
-values are similarly limited. These limitations can be overcome by means
-of the ``array`` module to allow any number of values of any type to
-be accessed.
+addresses. With current firmware all possible 32 bit values may be passed and
+returned. If the return value may have the most significant bit set a Python
+type hint should be employed to enable MicroPython to determine whether the
+value should be interpreted as a signed or unsigned integer: types are
+``int`` or ``uint``.
+
+::
+
+    @micropython.asm_thumb
+    def uadd(r0, r1) -> uint:
+        add(r0, r0, r1)
+
+``hex(uadd(0x40000000,0x40000000))`` will return 0x80000000, demonstrating the
+passing and return of integers where bits 30 and 31 differ.
+
+The limitations on the number of arguments and return values can be overcome by means
+of the ``array`` module which enables any number of values of any type to be accessed.
 
 Multiple arguments
 ~~~~~~~~~~~~~~~~~~

docs/reference/asm_thumb2_misc.rst

@@ -5,6 +5,9 @@ Miscellaneous instructions
 * wfi() Suspend execution in a low power state until an interrupt occurs.
 * cpsid(flags) set the Priority Mask Register - disable interrupts.
 * cpsie(flags) clear the Priority Mask Register - enable interrupts.
+* mrs(Rd, special_reg) ``Rd = special_reg`` copy a special register to a general register. The special register
+  may be IPSR (Interrupt Status Register) or BASEPRI (Base Priority Register). The IPSR provides a means of determining
+  the exception number of an interrupt being processed. It contains zero if no interrupt is being processed.
 
 Currently the ``cpsie()`` and ``cpsid()`` functions are partially implemented.
 They require but ignore the flags argument and serve as a means of enabling and disabling interrupts.

docs/reference/asm_thumb2_mov.rst

@@ -21,8 +21,7 @@ Where immediate values are used, these are zero-extended to 32 bits. Thus
 movt writes an immediate value to the top halfword of the destination register.
 It does not affect the contents of the bottom halfword.
 
-* movwt(Rd, imm30) ``Rd = imm30``
+* movwt(Rd, imm32) ``Rd = imm32``
 
-movwt is a pseudo-instruction: the MicroPython assembler emits a ``movw`` and a ``movt``
-to move a zero extended 30 bit value into Rd. Where the full 32 bits are required a
-workround is to use the movw and movt operations.
+movwt is a pseudo-instruction: the MicroPython assembler emits a ``movw`` followed
+by a ``movt`` to move a 32-bit value into Rd.

docs/reference/index.rst

@@ -13,6 +13,8 @@ MicroPython are described in the sections here.
    :maxdepth: 1
 
    repl.rst
+   isr_rules.rst
+   speed_python.rst
 
 .. only:: port_pyboard
 

docs/reference/isr_rules.rst

@@ -0,0 +1,302 @@
+.. _isr_rules:
+
+Writing interrupt handlers
+==========================
+
+On suitable hardware MicroPython offers the ability to write interrupt handlers in Python. Interrupt handlers
+- also known as interrupt service routines (ISR's) - are defined as callback functions. These are executed
+in response to an event such as a timer trigger or a voltage change on a pin. Such events can occur at any point
+in the execution of the program code. This carries significant consequences, some specific to the MicroPython
+language. Others are common to all systems capable of responding to real time events. This document covers
+the language specific issues first, followed by a brief introduction to real time programming for those new to it.
+
+This introduction uses vague terms like "slow" or "as fast as possible". This is deliberate, as speeds are
+application dependent. Acceptable durations for an ISR are dependent on the rate at which interrupts occur,
+the nature of the main program, and the presence of other concurrent events.
+
+Tips and recommended practices
+------------------------------
+
+This summarises the points detailed below and lists the principal recommendations for interrupt handler code.
+
+* Keep the code as short and simple as possible.
+* Avoid memory allocation: no appending to lists or insertion into dictionaries, no floating point.
+* Where an ISR returns multiple bytes use a pre-allocated ``bytearray``. If multiple integers are to be
+  shared between an ISR and the main program consider an array (``array.array``).
+* Where data is shared between the main program and an ISR, consider disabling interrupts prior to accessing
+  the data in the main program and re-enabling them immediately afterwards (see Critcal Sections).
+* Allocate an emergency exception buffer (see below).
+
+
+MicroPython Issues
+------------------
+
+The emergency exception buffer
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+If an error occurs in an ISR, MicroPython is unable to produce an error report unless a special buffer is created
+for the purpose. Debugging is simplified if the following code is included in any program using interrupts.
+
+.. code:: python
+
+    import micropython
+    micropython.alloc_emergency_exception_buf(100)
+
+Simplicity
+~~~~~~~~~~
+
+For a variety of reasons it is important to keep ISR code as short and simple as possible. It should do only what
+has to be done immediately after the event which caused it: operations which can be deferred should be delegated
+to the main program loop. Typically an ISR will deal with the hardware device which caused the interrupt, making
+it ready for the next interrupt to occur. It will communicate with the main loop by updating shared data to indicate
+that the interrupt has occurred, and it will return. An ISR should return control to the main loop as quickly
+as possible. This is not a specific MicroPython issue so is covered in more detail :ref:`below <ISR>`.
+
+Communication between an ISR and the main program
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Normally an ISR needs to communicate with the main program. The simplest means of doing this is via one or more
+shared data objects, either declared as global or shared via a class (see below). There are various restrictions
+and hazards around doing this, which are covered in more detail below. Integers, ``bytes`` and ``bytearray`` objects
+are commonly used for this purpose along with arrays (from the array module) which can store various data types.
+
+The use of object methods as callbacks
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+MicroPython supports this powerful technique which enables an ISR to share instance variables with the underlying
+code. It also enables a class implementing a device driver to support multiple device instances. The following
+example causes two LED's to flash at different rates.
+
+.. code:: python
+
+    import pyb, micropython
+    micropython.alloc_emergency_exception_buf(100)
+    class Foo(object):
+        def __init__(self, timer, led):
+            self.led = led
+            timer.callback(self.cb)
+        def cb(self, tim):
+            self.led.toggle()
+
+    red = Foo(pyb.Timer(4, freq=1), pyb.LED(1))
+    greeen = Foo(pyb.Timer(2, freq=0.8), pyb.LED(2))
+
+In this example the ``red`` instance associates timer 4 with LED 1: when a timer 4 interrupt occurs ``red.cb()``
+is called causing LED 1 to change state. The ``green`` instance operates similarly: a timer 2 interrupt
+results in the execution of ``green.cb()`` and toggles LED 2. The use of instance methods confers two
+benefits. Firstly a single class enables code to be shared between multiple hardware instances. Secondly, as
+a bound method the callback function's first argument is ``self``. This enables the callback to access instance
+data and to save state between successive calls. For example, if the class above had a variable ``self.count``
+set to zero in the constructor, ``cb()`` could increment the counter. The ``red`` and ``green`` instances would
+then maintain independent counts of the number of times each LED had changed state.
+
+Creation of Python objects
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ISR's cannot create instances of Python objects. This is because MicroPython needs to allocate memory for the
+object from a store of free memory block called the heap. This is not permitted in an interrupt handler because
+heap allocation is not re-entrant. In other words the interrupt might occur when the main program is part way
+through performing an allocation - to maintain the integrity of the heap the interpreter disallows memory
+allocations in ISR code.
+
+A consequence of this is that ISR's can't use floating point arithmetic; this is because floats are Python objects. Similarly
+an ISR can't append an item to a list. In practice it can be hard to determine exactly which code constructs will
+attempt to perform memory allocation and provoke an error message: another reason for keeping ISR code short and simple.
+
+One way to avoid this issue is for the ISR to use pre-allocated buffers. For example a class constructor
+creates a ``bytearray`` instance and a boolean flag. The ISR method assigns data to locations in the buffer and sets
+the flag. The memory allocation occurs in the main program code when the object is instantiated rather than in the ISR.
+
+The MicroPython library I/O methods usually provide an option to use a pre-allocated buffer. For
+example ``pyb.i2c.recv()`` can accept a mutable buffer as its first argument: this enables its use in an ISR.
+
+Use of Python objects
+~~~~~~~~~~~~~~~~~~~~~
+
+A further restriction on objects arises because of the way Python works. When an ``import`` statement is executed the
+Python code is compiled to bytecode, with one line of code typically mapping to multiple bytecodes. When the code
+runs the interpreter reads each bytecode and executes it as a series of machine code instructions. Given that an
+interrupt can occur at any time between machine code instructions, the original line of Python code may be only
+partially executed. Consequently a Python object such as a set, list or dictionary modified in the main loop
+may lack internal consistency at the moment the interrupt occurs.
+
+A typical outcome is as follows. On rare occasions the ISR will run at the precise moment in time when the object
+is partially updated. When the ISR tries to read the object, a crash results. Because such problems typically occur
+on rare, random occasions they can be hard to diagnose. There are ways to circumvent this issue, described in
+:ref:`Critical Sections <Critical>` below.
+
+It is important to be clear about what constitutes the modification of an object. An alteration to a built-in type
+such as a dictionary is problematic. Altering the contents of an array or bytearray is not. This is because bytes
+or words are written as a single machine code instruction which is not interruptible: in the parlance of real time
+programming the write is atomic. A user defined object might instantiate an integer, array or bytearray. It is valid
+for both the main loop and the ISR to alter the contents of these.
+
+MicroPython supports integers of arbitrary precision. Values between 2**30 -1 and -2**30 will be stored in
+a single machine word. Larger values are stored as Python objects. Consequently changes to long integers cannot
+be considered atomic. The use of long integers in ISR's is unsafe because memory allocation may be
+attempted as the variable's value changes.
+
+Overcoming the float limitation
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+In general it is best to avoid using floats in ISR code: hardware devices normally handle integers and conversion
+to floats is normally done in the main loop. However there are a few DSP algorithms which require floating point.
+On platforms with hardware floating point (such as the Pyboard) the inline ARM Thumb assembler can be used to work
+round this limitation. This is because the processor stores float values in a machine word; values can be shared
+between the ISR and main program code via an array of floats.
+
+Exceptions
+----------
+
+If an ISR raises an exception it will not propagate to the main loop. The interrupt will be disabled unless the
+exception is handled by the ISR code.
+
+General Issues
+--------------
+
+This is merely a brief introduction to the subject of real time programming. Beginners should note
+that design errors in real time programs can lead to faults which are particularly hard to diagnose. This is because
+they can occur rarely and at intervals which are essentially random. It is crucial to get the initial design right and
+to anticipate issues before they arise. Both interrupt handlers and the main program need to be designed
+with an appreciation of the following issues.
+
+.. _ISR:
+
+Interrupt Handler Design
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+As mentioned above, ISR's should be designed to be as simple as possible. They should always return in a short,
+predictable period of time. This is important because when the ISR is running, the main loop is not: inevitably
+the main loop experiences pauses in its execution at random points in the code. Such pauses can be a source of hard
+to diagnose bugs particularly if their duration is long or variable. In order to understand the implications of
+ISR run time, a basic grasp of interrupt priorities is required.
+
+Interrupts are organised according to a priority scheme. ISR code may itself be interrupted by a higher priority
+interrupt. This has implications if the two interrupts share data (see Critical Sections below). If such an interrupt
+occurs it interposes a delay into the ISR code. If a lower priority interrupt occurs while the ISR is running, it
+will be delayed until the ISR is complete: if the delay is too long, the lower priority interrupt may fail. A
+further issue with slow ISR's is the case where a second interrupt of the same type occurs during its execution.
+The second interrupt will be handled on termination of the first. However if the rate of incoming interrupts
+consistently exceeds the capacity of the ISR to service them the outcome will not be a happy one.
+
+Consequently looping constructs should be avoided or minimised. I/O to devices other than to the interrupting device
+should normally be avoided: I/O such as disk access, ``print`` statements and UART access is relatively slow, and
+its duration may vary. A further issue here is that filesystem functions are not reentrant: using filesystem I/O
+in an ISR and the main program would be hazardous. Crucially ISR code should not wait on an event. I/O is acceptable
+if the code can be guaranteed to return in a predictable period, for example toggling a pin or LED. Accessing the
+interrupting device via I2C or SPI may be necessary but the time taken for such accesses should be calculated or
+measured and its impact on the application assessed.
+
+There is usually a need to share data between the ISR and the main loop. This may be done either through global
+variables or via class or instance variables. Variables are typically integer or boolean types, or integer or byte
+arrays (a pre-allocated integer array offers faster access than a list). Where multiple values are modified by
+the ISR it is necessary to consider the case where the interrupt occurs at a time when the main program has
+accessed some, but not all, of the values. This can lead to inconsistencies.
+
+Consider the following design. An ISR stores incoming data in a bytearray, then adds the number of bytes
+received to an integer representing total bytes ready for processing. The main program reads the number of bytes,
+processes the bytes, then clears down the number of bytes ready. This will work until an interrupt occurs just
+after the main program has read the number of bytes. The ISR puts the added data into the buffer and updates
+the number received, but the main program has already read the number, so processes the data originally received.
+The newly arrived bytes are lost.
+
+There are various ways of avoiding this hazard, the simplest being to use a circular buffer. If it is not possible
+to use a structure with inherent thread safety other ways are described below.
+
+Reentrancy
+~~~~~~~~~~
+
+A potential hazard may occur if a function or method is shared between the main program and one or more ISR's or
+between multiple ISR's. The issue here is that the function may itself be interrupted and a further instance of
+that function run. If this is to occur, the function must be designed to be reentrant. How this is done is an
+advanced topic beyond the scope of this tutorial.
+
+.. _Critical:
+
+Critical Sections
+~~~~~~~~~~~~~~~~~
+
+An example of a critical section of code is one which accesses more than one variable which can be affected by an ISR. If
+the interrupt happens to occur between accesses to the individual variables, their values will be inconsistent. This is
+an instance of a hazard known as a race condition: the ISR and the main program loop race to alter the variables. To
+avoid inconsistency a means must be employed to ensure that the ISR does not alter the values for the duration of
+the critical section. One way to achieve this is to issue ``pyb.disable_irq()`` before the start of the section, and
+``pyb.enable_irq()`` at the end. Here is an example of this approach:
+
+.. code:: python
+
+    import pyb, micropython, array
+    micropython.alloc_emergency_exception_buf(100)
+
+    class BoundsException(Exception):
+        pass
+
+    ARRAYSIZE = const(20)
+    index = 0
+    data = array.array('i', 0 for x in range(ARRAYSIZE))
+
+    def callback1(t):
+        global data, index
+        for x in range(5):
+            data[index] = pyb.rng() # simulate input
+            index += 1
+            if index >= ARRAYSIZE:
+                raise BoundsException('Array bounds exceeded')
+
+    tim4 = pyb.Timer(4, freq=100, callback=callback1)
+
+    for loop in range(1000):
+        if index > 0:
+            irq_state = pyb.disable_irq() # Start of critical section
+            for x in range(index):
+                print(data[x])
+            index = 0
+            pyb.enable_irq(irq_state) # End of critical section
+            print('loop {}'.format(loop))
+        pyb.delay(1)
+
+    tim4.callback(None)
+
+A critical section can comprise a single line of code and a single variable. Consider the following code fragment.
+
+.. code:: python
+
+    count = 0
+    def cb(): # An interrupt callback
+        count +=1
+    def main():
+        # Code to set up the interrupt callback omitted
+        while True:
+            count += 1
+
+This example illustrates a subtle source of bugs. The line ``count += 1`` in the main loop carries a specific race
+condition hazard known as a read-modify-write. This is a classic cause of bugs in real time systems. In the main loop
+MicroPython reads the value of ``t.counter``, adds 1 to it, and writes it back. On rare occasions the  interrupt occurs
+after the read and before the write. The interrupt modifies ``t.counter`` but its change is overwritten by the main
+loop when the ISR returns. In a real system this could lead to rare, unpredictable failures.
+
+As mentioned above, care should be taken if an instance of a Python built in type is modified in the main code and
+that instance is accessed in an ISR. The code performing the modification should be regarded as a critical
+section to ensure that the instance is in a valid state when the ISR runs.
+
+Particular care needs to be taken if a dataset is shared between different ISR's. The hazard here is that the higher
+priority interrupt may occur when the lower priority one has partially updated the shared data. Dealing with this
+situation is an advanced topic beyond the scope of this introduction other than to note that mutex objects described
+below can sometimes be used.
+
+Disabling interrupts for the duration of a critical section is the usual and simplest way to proceed, but it disables
+all interrupts rather than merely the one with the potential to cause problems. It is generally undesirable to disable
+an interrupt for long. In the case of timer interrupts it introduces variability to the time when a callback occurs.
+In the case of device interrupts, it can lead to the device being serviced too late with possible loss of data or
+overrun errors in the device hardware. Like ISR's, a critical section in the main code should have a short, predictable
+duration.
+
+An approach to dealing with critical sections which radically reduces the time for which interrupts are disabled is to
+use an object termed a mutex (name derived from the notion of mutual exclusion). The main program locks the mutex
+before running the critical section and unlocks it at the end. The ISR tests whether the mutex is locked. If it is,
+it avoids the critical section and returns. The design challenge is defining what the ISR should do in the event
+that access to the critical variables is denied. A simple example of a mutex may be found
+`here <https://github.com/peterhinch/micropython-samples.git>`_. Note that the mutex code does disable interrupts,
+but only for the duration of eight machine instructions: the benefit of this approach is that other interrupts are
+virtually unaffected.
+

docs/reference/speed_python.rst

@@ -0,0 +1,318 @@
+Maximising Python Speed
+=======================
+
+This tutorial describes ways of improving the performance of MicroPython code.
+Optimisations involving other languages are covered elsewhere, namely the use
+of modules written in C and the MicroPython inline ARM Thumb-2 assembler.
+
+The process of developing high performance code comprises the following stages
+which should be performed in the order listed.
+
+* Design for speed.
+* Code and debug.
+
+Optimisation steps:
+
+* Identify the slowest section of code.
+* Improve the efficiency of the Python code.
+* Use the native code emitter.
+* Use the viper code emitter.
+
+Designing for speed
+-------------------
+
+Performance issues should be considered at the outset. This involves taking a view
+on the sections of code which are most performance critical and devoting particular
+attention to their design. The process of optimisation begins when the code has
+been tested: if the design is correct at the outset optimisation will be
+straightforward and may actually be unnecessary.
+
+Algorithms
+~~~~~~~~~~
+
+The most important aspect of designing any routine for performance is ensuring that
+the best algorithm is employed. This is a topic for textbooks rather than for a 
+MicroPython guide but spectacular performance gains can sometimes be achieved
+by adopting algorithms known for their efficiency.
+
+RAM Allocation
+~~~~~~~~~~~~~~
+
+To design efficient MicroPython code it is necessary to have an understanding of the
+way the interpreter allocates RAM. When an object is created or grows in size
+(for example where an item is appended to a list) the necessary RAM is allocated
+from a block known as the heap. This takes a significant amount of time;
+further it will on occasion trigger a process known as garbage collection which
+can take several milliseconds.
+
+Consequently the performance of a function or method can be improved if an object is created
+once only and not permitted to grow in size. This implies that the object persists
+for the duration of its use: typically it will be instantiated in a class constructor
+and used in various methods.
+
+This is covered in further detail :ref:`Controlling garbage collection <gc>` below.
+
+Buffers
+~~~~~~~
+
+An example of the above is the common case where a buffer is required, such as one
+used for communication with a device. A typical driver will create the buffer in the
+constructor and use it in its I/O methods which will be called repeatedly.
+
+The MicroPython libraries typically provide optional support for pre-allocated buffers.
+For example the ``uart.readinto()`` method allows two options for its argument, an integer
+or a buffer. If an integer is supplied it will read up to that number of bytes and
+return the outcome: this implies that a buffer is created with a corresponding
+memory allocation. Providing a pre-allocated buffer as the argument avoids this. See
+the code fragment in :ref:`Caching object references <Caching>` below.
+
+Floating Point
+~~~~~~~~~~~~~~
+
+For the most speed critical sections of code it is worth noting that performing
+any kind of floating point operation involves heap allocation. Where possible use
+integer operations and restrict the use of floating point to sections of the code
+where performance is not paramount.
+
+Arrays
+~~~~~~
+
+Consider the use of the various types of array classes as an alternative to lists.
+The ``array`` module supports various element types with 8-bit elements supported
+by Python's built in ``bytes`` and ``bytearray`` classes. These data structures all store
+elements in contiguous memory locations. Once again to avoid memory allocation in critical
+code these should be pre-allocated and passed as arguments or as bound objects.
+
+When passing slices of objects such as ``bytearray`` instances, Python creates
+a copy which involves allocation. This can be avoided using a ``memoryview``
+object:
+
+.. code:: python
+
+    ba = bytearray(100)
+    func(ba[3:10]) # a copy is passed
+    mv = memoryview(ba)
+    func(mv[3:10]) # a pointer to memory is passed
+
+A ``memoryview`` can only be applied to objects supporting the buffer protocol - this
+includes arrays but not lists.
+
+Identifying the slowest section of code
+---------------------------------------
+
+This is a process known as profiling and is covered in textbooks and
+(for standard Python) supported by various software tools. For the type of
+smaller embedded application likely to be running on MicroPython platforms
+the slowest function or method can usually be established by judicious use
+of the timing ``ticks`` group of functions documented
+`here <http://docs.micropython.org/en/latest/pyboard/library/time.html>`_.
+Code execution time can be measured in ms, us, or CPU cycles.
+
+The following enables any function or method to be timed by adding an
+``@timed_function`` decorator:
+
+.. code:: python
+
+    def timed_function(f, *args, **kwargs):
+        myname = str(f).split(' ')[1]
+        def new_func(*args, **kwargs):
+            t = time.ticks_us()
+            result = f(*args, **kwargs)
+            delta = time.ticks_diff(t, time.ticks_us())
+            print('Function {} Time = {:6.3f}ms'.format(myname, delta/1000))
+            return result
+        return new_func
+
+MicroPython code improvements
+-----------------------------
+
+The const() declaration
+~~~~~~~~~~~~~~~~~~~~~~~
+
+MicroPython provides a ``const()`` declaration. This works in a similar way
+to ``#define`` in C in that when the code is compiled to bytecode the compiler
+substitutes the numeric value for the identifier. This avoids a dictionary
+lookup at runtime. The argument to ``const()`` may be anything which, at
+compile time, evaluates to an integer e.g. ``0x100`` or ``1 << 8``.
+
+.. _Caching:
+
+Caching object references
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Where a function or method repeatedly accesses objects performance is improved
+by caching the object in a local variable:
+
+.. code:: python
+
+    class foo(object):
+        def __init__(self):
+            ba = bytearray(100)
+        def bar(self, obj_display):
+            ba_ref = self.ba
+            fb = obj_display.framebuffer
+            # iterative code using these two objects
+
+This avoids the need repeatedly to look up ``self.ba`` and ``obj_display.framebuffer``
+in the body of the method ``bar()``.
+
+.. _gc:
+
+Controlling garbage collection
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+When memory allocation is required, MicroPython attempts to locate an adequately
+sized block on the heap. This may fail, usually because the heap is cluttered
+with objects which are no longer referenced by code. If a failure occurs, the
+process known as garbage collection reclaims the memory used by these redundant
+objects and the allocation is then tried again - a process which can take several
+milliseconds.
+
+There are benefits in pre-empting this by periodically issuing ``gc.collect()``.
+Firstly doing a collection before it is actually required is quicker - typically on the
+order of 1ms if done frequently. Secondly you can determine the point in code
+where this time is used rather than have a longer delay occur at random points,
+possibly in a speed critical section. Finally performing collections regularly
+can reduce fragmentation in the heap. Severe fragmentation can lead to
+non-recoverable allocation failures.
+
+Accessing hardware directly
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+This comes into the category of more advanced programming and involves some knowledge
+of the target MCU. Consider the example of toggling an output pin on the Pyboard. The 
+standard approach would be to write
+
+.. code:: python
+
+    mypin.value(mypin.value() ^ 1) # mypin was instantiated as an output pin
+
+This involves the overhead of two calls to the ``Pin`` instance's ``value()``
+method. This overhead can be eliminated by performing a read/write to the relevant bit
+of the chip's GPIO port output data register (odr). To facilitate this the ``stm``
+module provides a set of constants providing the addresses of the relevant registers.
+A fast toggle of pin ``P4`` (CPU pin ``A14``) - corresponding to the green LED -
+can be performed as follows:
+
+.. code:: python
+
+    BIT14 = const(1 << 14)
+    stm.mem16[stm.GPIOA + stm.GPIO_ODR] ^= BIT14
+
+The Native code emitter
+-----------------------
+
+This causes the MicroPython compiler to emit ARM native opcodes rather than
+bytecode. It covers the bulk of the Python language so most functions will require
+no adaptation (but see below). It is invoked by means of a function decorator:
+
+.. code:: python
+
+    @micropython.native
+    def foo(self, arg):
+        buf = self.linebuf # Cached object
+        # code
+
+There are certain limitations in the current implementation of the native code emitter. 
+
+* Context managers are not supported (the ``with`` statement).
+* Generators are not supported.
+* If ``raise`` is used an argument must be supplied.
+
+The trade-off for the improved performance (roughly twices as fast as bytecode) is an
+increase in compiled code size.
+
+The Viper code emitter
+----------------------
+
+The optimisations discussed above involve standards-compliant Python code. The 
+Viper code emitter is not fully compliant. It supports special Viper native data types
+in pursuit of performance. Integer processing is non-compliant because it uses machine
+words: arithmetic on 32 bit hardware is performed modulo 2**32.
+
+Like the Native emitter Viper produces machine instructions but further optimisations
+are performed, substantially increasing performance especially for integer arithmetic and
+bit manipulations. It is invoked using a decorator:
+
+.. code:: python
+
+    @micropython.viper
+    def foo(self, arg: int) -> int:
+        # code
+
+As the above fragment illustrates it is beneficial to use Python type hints to assist the Viper optimiser. 
+Type hints provide information on the data types of arguments and of the return value; these
+are a standard Python language feature formally defined here `PEP0484 <https://www.python.org/dev/peps/pep-0484/>`_.
+Viper supports its own set of types namely ``int``, ``uint`` (unsigned integer), ``ptr``, ``ptr8``,
+``ptr16`` and ``ptr32``. The ``ptrX`` types are discussed below. Currently the ``uint`` type serves
+a single purpose: as a type hint for a function return value. If such a function returns ``0xffffffff``
+Python will interpret the result as 2**32 -1 rather than as -1.
+
+In addition to the restrictions imposed by the native emitter the following constraints apply:
+
+* Functions may have up to four arguments.
+* Default argument values are not permitted.
+* Floating point may be used but is not optimised.
+
+Viper provides pointer types to assist the optimiser. These comprise
+
+* ``ptr`` Pointer to an object.
+* ``ptr8`` Points to a byte.
+* ``ptr16`` Points to a 16 bit half-word.
+* ``ptr32`` Points to a 32 bit machine word.
+
+The concept of a pointer may be unfamiliar to Python programmers. It has similarities
+to a Python ``memoryview`` object in that it provides direct access to data stored in memory.
+Items are accessed using subscript notation, but slices are not supported: a pointer can return
+a single item only. Its purpose is to provide fast random access to data stored in contiguous
+memory locations - such as data stored in objects which support the buffer protocol, and
+memory-mapped peripheral registers in a microcontroller. It should be noted that programming
+using pointers is hazardous: bounds checking is not performed and the compiler does nothing to
+prevent buffer overrun errors.
+
+Typical usage is to cache variables:
+
+.. code:: python
+
+    @micropython.viper
+    def foo(self, arg: int) -> int:
+        buf = ptr8(self.linebuf) # self.linebuf is a bytearray or bytes object
+        for x in range(20, 30):
+            bar = buf[x] # Access a data item through the pointer
+            # code omitted
+
+In this instance the compiler "knows" that ``buf`` is the address of an array of bytes;
+it can emit code to rapidly compute the address of ``buf[x]`` at runtime. Where casts are
+used to convert objects to Viper native types these should be performed at the start of
+the function rather than in critical timing loops as the cast operation can take several
+microseconds. The rules for casting are as follows:
+
+* Casting operators are currently: ``int``, ``bool``, ``uint``, ``ptr``, ``ptr8``, ``ptr16`` and ``ptr32``.
+* The result of a cast will be a native Viper variable.
+* Arguments to a cast can be a Python object or a native Viper variable.
+* If argument is a native Viper variable, then cast is a no-op (i.e. costs nothing at runtime)
+  that just changes the type (e.g. from ``uint`` to ``ptr8``) so that you can then store/load
+  using this pointer.
+* If the argument is a Python object and the cast is ``int`` or ``uint``, then the Python object
+  must be of integral type and the value of that integral object is returned.
+* The argument to a bool cast must be integral type (boolean or integer); when used as a return
+  type the viper function will return True or False objects.
+* If the argument is a Python object and the cast is ``ptr``, ``ptr``, ``ptr16`` or ``ptr32``,
+  then the Python object must either have the buffer protocol with read-write capabilities
+  (in which case a pointer to the start of the buffer is returned) or it must be of integral
+  type (in which case the value of that integral object is returned).
+ 
+The following example illustrates the use of a ``ptr16`` cast to toggle pin X1 ``n`` times:
+
+.. code:: python
+
+    BIT0 = const(1)
+    @micropython.viper
+    def toggle_n(n: int):
+        odr = ptr16(stm.GPIOA + stm.GPIO_ODR)
+        for _ in range(n):
+            odr[0] ^= BIT0
+
+A detailed technical description of the three code emitters may be found
+on Kickstarter here `Note 1 <https://www.kickstarter.com/projects/214379695/micro-python-python-for-microcontrollers/posts/664832>`_
+and here `Note 2 <https://www.kickstarter.com/projects/214379695/micro-python-python-for-microcontrollers/posts/665145>`_

docs/templates/versions.html

@@ -0,0 +1,39 @@
+<div class="rst-versions" data-toggle="rst-versions" role="note" aria-label="versions">
+  <span class="rst-current-version" data-toggle="rst-current-version">
+    <span class="fa fa-book"> Ports and Versions</span>
+    {{ port_short_name }} ({{ port_version }})
+    <span class="fa fa-caret-down"></span>
+  </span>
+  <div class="rst-other-versions">
+    <dl>
+      <dt>Ports</dt>
+      {% for slug, url in all_ports %}
+        <dd><a href="{{ url }}">{{ slug }}</a></dd>
+      {% endfor %}
+    </dl>
+    <dl>
+      <dt>Versions</dt>
+      {% for slug, url in all_versions %}
+        <dd><a href="{{ url }}">{{ slug }}</a></dd>
+      {% endfor %}
+    </dl>
+    <!--
+    <dl>
+      <dt>Downloads</dt>
+      {% for type, url in downloads %}
+        <dd><a href="{{ url }}">{{ type }}</a></dd>
+      {% endfor %}
+    </dl>
+    -->
+    <hr/>
+    <dl>
+      <dt>External links</dt>
+        <dd>
+          <a href="http://www.micropython.org">micropython.org</a>
+        </dd>
+        <dd>
+          <a href="https://github.com/micropython/micropython">GitHub</a>
+        </dd>
+    </dl>
+  </div>
+</div>

docs/topindex.html

@@ -41,10 +41,10 @@
       {% endif %}
       <p class="biglink">
         <a class="biglink" href="{{ pathto("library/index") }}">Library Reference</a><br/>
-        {% if port == "wipy" %}
-          <span class="linkdescr">MicroPython libraries, including the <a href="{{ pathto("library/machine") }}">machine module</a></span>
-        {% else %}
+        {% if port == "pyboard" %}
           <span class="linkdescr">MicroPython libraries, including the <a href="{{ pathto("library/pyb") }}">pyb module</a></span>
+        {% else %}
+          <span class="linkdescr">MicroPython libraries, including the <a href="{{ pathto("library/machine") }}">machine module</a></span>
         {% endif %}
       </p>
     </td>

docs/wipy/quickref.rst

@@ -49,10 +49,10 @@ See :ref:`machine.Timer <machine.Timer>` and :ref:`machine.Pin <machine.Pin>`. :
     from machine import Timer
     from machine import Pin
 
-    tim = Timer(1, mode=Timer.PERIODIC)
+    tim = Timer(0, mode=Timer.PERIODIC)
     tim_a = tim.channel(Timer.A, freq=1000)
     tim_a.time() # get the value in microseconds
-    tim_a.freq(1) # 1 Hz
+    tim_a.freq(5) # 5 Hz
     
     p_out = Pin('GP2', mode=Pin.OUT)
     tim_a.irq(handler=lambda t: p_out.toggle())
@@ -63,16 +63,12 @@ PWM (pulse width modulation)
 See :ref:`machine.Pin <machine.Pin>` and :ref:`machine.Timer <machine.Timer>`. ::
 
     from machine import Timer
-    from machine import Pin
 
-    # assign GP25 to alternate function 9 (PWM)
-    p_out = Pin('GP25', mode=Pin.AF, alt=9)
-
-    # timer 2 in PWM mode and width must be 16 buts
-    tim = Timer(2, mode=Timer.PWM, width=16)
+    # timer 1 in PWM mode and width must be 16 buts
+    tim = Timer(1, mode=Timer.PWM, width=16)
     
-    # enable channel A @1KHz with a 50% duty cycle
-    tim_a = tim.channel(Timer.A, freq=1000, duty_cycle=50)
+    # enable channel A @1KHz with a 50.55% duty cycle
+    tim_a = tim.channel(Timer.A, freq=1000, duty_cycle=5055)
 
 ADC (analog to digital conversion)
 ----------------------------------
@@ -201,12 +197,12 @@ See :ref:`network.WLAN <network.WLAN>` and :mod:`machine`. ::
 Telnet and FTP server
 ---------------------
 
-See :ref:`network.server <network.server>` ::
+See :ref:`network.Server <network.Server>` ::
 
-    from network import server
+    from network import Server
 
     # init with new user, password and seconds timeout
-    server = server.init(login=('user', 'password'), timeout=60)
+    server = Server(login=('user', 'password'), timeout=60)
     server.timeout(300) # change the timeout
     server.timeout() # get the timeout
     server.isrunning() # check wether the server is running or not

drivers/sdcard/sdcard.py

@@ -25,6 +25,9 @@ class SDCard:
     #R1_ERASE_SEQUENCE_ERROR = const(1 << 4)
     #R1_ADDRESS_ERROR = const(1 << 5)
     #R1_PARAMETER_ERROR = const(1 << 6)
+    TOKEN_CMD25 = const(0xfc)
+    TOKEN_STOP_TRAN = const(0xfd)
+    TOKEN_DATA = const(0xfe)
 
     def __init__(self, spi, cs):
         self.spi = spi
@@ -136,6 +139,18 @@ class SDCard:
         self.spi.send(0xff)
         return -1
 
+    def cmd_nodata(self, cmd):
+        self.spi.send(cmd)
+        self.spi.send_recv(0xff) # ignore stuff byte
+        for _ in range(CMD_TIMEOUT):
+            if self.spi.send_recv(0xff)[0] == 0xff:
+                self.cs.high()
+                self.spi.send(0xff)
+                return 0    # OK
+        self.cs.high()
+        self.spi.send(0xff)
+        return 1 # timeout
+
     def readinto(self, buf):
         self.cs.low()
 
@@ -154,11 +169,11 @@ class SDCard:
         self.cs.high()
         self.spi.send(0xff)
 
-    def write(self, buf):
+    def write(self, token, buf):
         self.cs.low()
 
         # send: start of block, data, checksum
-        self.spi.send(0xfe)
+        self.spi.send(token)
         self.spi.send(buf)
         self.spi.send(0xff)
         self.spi.send(0xff)
@@ -176,29 +191,62 @@ class SDCard:
         self.cs.high()
         self.spi.send(0xff)
 
+    def write_token(self, token):
+        self.cs.low()
+        self.spi.send(token)
+        self.spi.send(0xff)
+        # wait for write to finish
+        while self.spi.send_recv(0xff)[0] == 0:
+            pass
+
+        self.cs.high()
+        self.spi.send(0xff)
+
     def count(self):
         return self.sectors
 
     def readblocks(self, block_num, buf):
-        # TODO support multiple block reads
-        assert len(buf) == 512
-
-        # CMD17: set read address for single block
-        if self.cmd(17, block_num * self.cdv, 0) != 0:
-            return 1
-
-        # receive the data
-        self.readinto(buf)
+        nblocks, err = divmod(len(buf), 512)
+        assert nblocks and not err, 'Buffer length is invalid'
+        if nblocks == 1:
+            # CMD17: set read address for single block
+            if self.cmd(17, block_num * self.cdv, 0) != 0:
+                return 1
+            # receive the data
+            self.readinto(buf)
+        else:
+            # CMD18: set read address for multiple blocks
+            if self.cmd(18, block_num * self.cdv, 0) != 0:
+                return 1
+            offset = 0
+            mv = memoryview(buf)
+            while nblocks:
+                self.readinto(mv[offset : offset + 512])
+                offset += 512
+                nblocks -= 1
+            return self.cmd_nodata(12)
         return 0
 
     def writeblocks(self, block_num, buf):
-        # TODO support multiple block writes
-        assert len(buf) == 512
+        nblocks, err = divmod(len(buf), 512)
+        assert nblocks and not err, 'Buffer length is invalid'
+        if nblocks == 1:
+            # CMD24: set write address for single block
+            if self.cmd(24, block_num * self.cdv, 0) != 0:
+                return 1
 
-        # CMD24: set write address for single block
-        if self.cmd(24, block_num * self.cdv, 0) != 0:
-            return 1
-
-        # send the data
-        self.write(buf)
+            # send the data
+            self.write(TOKEN_DATA, buf)
+        else:
+            # CMD25: set write address for first block
+            if self.cmd(25, block_num * self.cdv, 0) != 0:
+                return 1
+            # send the data
+            offset = 0
+            mv = memoryview(buf)
+            while nblocks:
+                self.write(TOKEN_CMD25, mv[offset : offset + 512])
+                offset += 512
+                nblocks -= 1
+            self.write_token(TOKEN_STOP_TRAN)
         return 0

drivers/sdcard/sdtest.py

@@ -0,0 +1,57 @@
+# Test for sdcard block protocol
+# Peter hinch 30th Jan 2016
+import os, sdcard, pyb
+
+def sdtest():
+    sd = sdcard.SDCard(pyb.SPI(1), pyb.Pin.board.X21) # Compatible with PCB
+    pyb.mount(sd, '/fc')
+    print('Filesystem check')
+    print(os.listdir('/fc'))
+
+    line = 'abcdefghijklmnopqrstuvwxyz\n'
+    lines = line * 200 # 5400 chars
+    short = '1234567890\n'
+
+    fn = '/fc/rats.txt'
+    print()
+    print('Multiple block read/write')
+    with open(fn,'w') as f:
+        n = f.write(lines)
+        print(n, 'bytes written')
+        n = f.write(short)
+        print(n, 'bytes written')
+        n = f.write(lines)
+        print(n, 'bytes written')
+
+    with open(fn,'r') as f:
+        result1 = f.read()
+        print(len(result1), 'bytes read')
+
+    fn = '/fc/rats1.txt'
+    print()
+    print('Single block read/write')
+    with open(fn,'w') as f:
+        n = f.write(short) # one block
+        print(n, 'bytes written')
+
+    with open(fn,'r') as f:
+        result2 = f.read()
+        print(len(result2), 'bytes read')
+
+    pyb.mount(None, '/fc')
+
+    print()
+    print('Verifying data read back')
+    success = True
+    if result1 == ''.join((lines, short, lines)):
+        print('Large file Pass')
+    else:
+        print('Large file Fail')
+        success = False
+    if result2 == short:
+        print('Small file Pass')
+    else:
+        print('Small file Fail')
+        success = False
+    print()
+    print('Tests', 'passed' if success else 'failed')

esp8266/Makefile

@@ -9,8 +9,8 @@ include ../py/py.mk
 MAKE_FROZEN = ../tools/make-frozen.py
 
 SCRIPTDIR = scripts
-PORT = /dev/ttyACM0
-BAUD = 115200
+PORT ?= /dev/ttyACM0
+BAUD ?= 115200
 CROSS_COMPILE = xtensa-lx106-elf-
 ESP_SDK = $(shell $(CC) -print-sysroot)/usr
 
@@ -23,18 +23,21 @@ INC += -I../lib/timeutils
 INC += -I$(BUILD)
 INC += -I$(ESP_SDK)/include
 
-UART_OS = 1
+# UART for "os" messages. 0 is normal UART as used by MicroPython REPL,
+# 1 is debug UART (tx only).
+UART_OS = 0
 
 CFLAGS_XTENSA = -fsingle-precision-constant -Wdouble-promotion \
 	-D__ets__ -DICACHE_FLASH \
 	-fno-inline-functions \
 	-Wl,-EL -mlongcalls -mtext-section-literals \
+	-DLWIP_OPEN_SRC
 
 CFLAGS = $(INC) -Wall -Wpointer-arith -Werror -ansi -std=gnu99 -nostdlib -DUART_OS=$(UART_OS) \
-	$(CFLAGS_XTENSA) $(COPT)
+	$(CFLAGS_XTENSA) $(COPT) $(CFLAGS_EXTRA)
 
 LDFLAGS = -nostdlib -T esp8266.ld -Map=$(@:.elf=.map) --cref
-LIBS = -L$(ESP_SDK)/lib -lmain -ljson -llwip -lpp -lnet80211 -lwpa -lphy -lnet80211
+LIBS = -L$(ESP_SDK)/lib -lmain -ljson -lssl -llwip_open -lpp -lnet80211 -lwpa -lphy -lnet80211
 
 LIBGCC_FILE_NAME = $(shell $(CC) $(CFLAGS) -print-libgcc-file-name)
 LIBS += -L$(dir $(LIBGCC_FILE_NAME)) -lgcc
@@ -45,7 +48,7 @@ CFLAGS += -g
 COPT = -O0
 else
 CFLAGS += -fdata-sections -ffunction-sections
-COPT += -Os -DNDEBUG
+COPT += -Os -mforce-l32 -DNDEBUG
 LDFLAGS += --gc-sections
 endif
 
@@ -54,29 +57,64 @@ SRC_C = \
 	main.c \
 	esp_mphal.c \
 	gccollect.c \
+	lexerstr32.c \
 	uart.c \
+	esppwm.c \
+	espneopixel.c \
 	modpyb.c \
 	modpybpin.c \
+	modpybpwm.c \
 	modpybrtc.c \
 	modpybadc.c \
+	modpybuart.c \
+	modpybi2c.c \
+	modpybspi.c \
 	modesp.c \
 	modnetwork.c \
 	modutime.c \
 	moduos.c \
+	modmachine.c \
+	modonewire.c \
 	utils.c \
+	ets_alt_task.c \
 	$(BUILD)/frozen.c \
+	fatfs_port.o \
 
 STM_SRC_C = $(addprefix stmhal/,\
 	pybstdio.c \
 	)
 
+EXTMOD_SRC_C = $(addprefix extmod/,\
+	modlwip.o \
+        )
+
 LIB_SRC_C = $(addprefix lib/,\
 	libc/string0.c \
+	libm/math.c \
+	libm/fmodf.c \
+	libm/roundf.c \
+	libm/ef_sqrt.c \
+	libm/kf_rem_pio2.c \
+	libm/kf_sin.c \
+	libm/kf_cos.c \
+	libm/kf_tan.c \
+	libm/ef_rem_pio2.c \
+	libm/sf_sin.c \
+	libm/sf_cos.c \
+	libm/sf_tan.c \
+	libm/sf_frexp.c \
+	libm/sf_modf.c \
+	libm/sf_ldexp.c \
+	libm/asinfacosf.c \
+	libm/atanf.c \
+	libm/atan2f.c \
 	mp-readline/readline.c \
 	netutils/netutils.c \
 	timeutils/timeutils.c \
 	utils/pyexec.c \
 	utils/printf.c \
+	fatfs/ff.c \
+	fatfs/option/ccsbcs.c \
 	)
 
 SRC_S = \
@@ -87,6 +125,7 @@ OBJ += $(PY_O)
 OBJ += $(addprefix $(BUILD)/, $(SRC_C:.c=.o))
 OBJ += $(addprefix $(BUILD)/, $(SRC_S:.s=.o))
 OBJ += $(addprefix $(BUILD)/, $(STM_SRC_C:.c=.o))
+OBJ += $(addprefix $(BUILD)/, $(EXTMOD_SRC_C:.c=.o))
 OBJ += $(addprefix $(BUILD)/, $(LIB_SRC_C:.c=.o))
 #OBJ += $(BUILD)/pins_$(BOARD).o
 
@@ -111,8 +150,8 @@ $(BUILD)/frozen.c: $(wildcard $(SCRIPTDIR)/*) $(CONFVARS_FILE)
 
 deploy: $(BUILD)/firmware-combined.bin
 	$(ECHO) "Writing $< to the board"
-	#$(Q)esptool.py --port $(PORT) write_flash 0 $<
-	$(Q)esptool.py --port $(PORT) --baud $(BAUD) write_flash 0 $(BUILD)/firmware.elf-0x00000.bin 0x10000 $(BUILD)/firmware.elf-0x10000.bin
+	$(Q)esptool.py --port $(PORT) --baud $(BAUD) write_flash --flash_size=8m 0 $<
+	#$(Q)esptool.py --port $(PORT) --baud $(BAUD) write_flash --flash_size=8m 0 $(BUILD)/firmware.elf-0x00000.bin 0x9000 $(BUILD)/firmware.elf-0x0[1-f]000.bin
 
 reset:
 	echo -e "\r\nimport pyb; pyb.hard_reset()\r\n" >$(PORT)
@@ -120,7 +159,7 @@ reset:
 $(BUILD)/firmware-combined.bin: $(BUILD)/firmware.elf
 	$(ECHO) "Create $@"
 	$(Q)esptool.py elf2image $^
-	$(Q)$(PYTHON) makeimg.py $(BUILD)/firmware.elf-0x00000.bin $(BUILD)/firmware.elf-0x10000.bin $@
+	$(Q)$(PYTHON) makeimg.py $(BUILD)/firmware.elf-0x00000.bin $(BUILD)/firmware.elf-0x0[1-f]000.bin $@
 
 $(BUILD)/firmware.elf: $(OBJ)
 	$(ECHO) "LINK $@"

esp8266/README.md

@@ -8,49 +8,81 @@ WARNING: The port is highly experimental and any APIs are subject to change.
 
 Currently implemented features include:
 - REPL (Python prompt) over UART0.
-- 24k heap RAM available for Python code.
 - Garbage collector, exceptions.
 - Unicode support.
-- Builtin modules: gc, array, collections, io, struct, sys, esp, network.
-- C long-long type used as bignum implementation (gives 64 bit signed ints).
-- Rudimentary WiFi support in station mode.
-- Sockets with callbacks.
-- Basic GPIO support.
-
-Note that floating-point numbers are not supported.
+- Builtin modules: gc, array, collections, io, struct, sys, esp, network,
+  many more.
+- Arbitrary-precision long integers and 30-bit precision floats.
+- Basic WiFi support.
+- Sockets using modlwip.
+- GPIO and bit-banging I2C, SPI support.
+- 1-Wire and WS2812 (aka Neopixel) protocols support.
 
 On the TODO list:
 - Full wifi support.
 - Internal filesystem using the flash.
 - ...
 
+Work-in-progress documentation is available at
+http://docs.micropython.org/en/latest/esp8266/ .
+
 Build instructions
 ------------------
 
 The tool chain required for the build is the OpenSource ESP SDK, which can be
 found at <https://github.com/pfalcon/esp-open-sdk>.  Clone this repository and
-run `make` in its directory to build and install the SDK locally.
+run `make` in its directory to build and install the SDK locally.  Make sure
+to add toolchain bin directory to your PATH.  Read esp-open-sdk's README for
+additional important information on toolchain setup.
+
+Add the external dependencies to the MicroPython repository checkout:
+```bash
+$ git submodule update --init
+```
+See the README in the repository root for more information about external
+dependencies.
 
 Then, to build MicroPython for the ESP8266, just run:
 ```bash
+$ cd esp8266
 $ make
 ```
-This should produce binary images in the `build/` subdirectory.  To flash them
-to your ESP8266, use:
+This will produce binary images in the `build/` subdirectory. If you install
+MicroPython to your module for the first time, or after installing any other
+firmware, you should erase flash completely:
+
+```
+esptool.py --port /dev//ttyXXX erase_flash
+```
+
+Erase flash also as a troubleshooting measure, if a module doesn't behave as
+expected.
+
+To flash MicroPython image to your ESP8266, use:
 ```bash
 $ make deploy
 ```
 This will use the `esptool.py` script to download the images.  You must have
-your ESP module in the bootloader, and connected to a serial port on your PC.
+your ESP module in the bootloader mode, and connected to a serial port on your PC.
 The default serial port is `/dev/ttyACM0`.  To specify another, use, eg:
 ```bash
 $ make PORT=/dev/ttyUSB0 deploy
 ```
 
-The images that are built are:
-- `firmware.elf-0x00000.bin`: to be flashed at 0x00000
-- `firmware.elf-0x10000.bin`: to be flashed at 0x10000
+The image produced is `firmware-combined.bin`, to be flashed at 0x00000.
 
-There is also a combined image, made up of the above 2 binary files with the
-appropriate padding:
-- `firmware-combined.bin`: to be flashed at 0x00000
+Troubleshooting
+---------------
+
+While the port is still in alpha, it's known to be generally stable. If you
+experience strange bootloops, crashes, lockups, here's a list to check against:
+
+- You didn't erase flash before programming MicroPython firmware.
+- Firmware can be occasionally flashed incorrectly. Just retry. Recent
+  esptool.py versions have --verify option.
+- Power supply you use doesn't provide enough power for ESP8266 or isn't
+  stable enough.
+- A module/flash may be defective (not unheard of for cheap modules).
+
+Please consult dedicated ESP8266 forums/resources for hardware-related
+problems.

esp8266/eagle.rom.addr.v6.ld

@@ -132,12 +132,12 @@ PROVIDE ( ets_memcmp = 0x400018d4 );
 PROVIDE ( ets_memcpy = 0x400018b4 );
 PROVIDE ( ets_memmove = 0x400018c4 );
 PROVIDE ( ets_memset = 0x400018a4 );
-PROVIDE ( ets_post = 0x40000e24 );
+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_run = 0x40000e04 );
+PROVIDE ( _ets_set_idle_cb = 0x40000dc0 );
 PROVIDE ( ets_set_user_start = 0x40000fbc );
 PROVIDE ( ets_str2macaddr = 0x40002af8 );
 PROVIDE ( ets_strcmp = 0x40002aa8 );
@@ -146,12 +146,12 @@ PROVIDE ( ets_strlen = 0x40002ac8 );
 PROVIDE ( ets_strncmp = 0x40002ab8 );
 PROVIDE ( ets_strncpy = 0x40002a98 );
 PROVIDE ( ets_strstr = 0x40002ad8 );
-PROVIDE ( ets_task = 0x40000dd0 );
+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_init = 0x40002e68 );
 PROVIDE ( ets_timer_setfn = 0x40002c48 );
 PROVIDE ( ets_uart_printf = 0x40002544 );
 PROVIDE ( ets_update_cpu_frequency = 0x40002f04 );
@@ -343,5 +343,8 @@ PROVIDE ( xthal_window_spill = 0x4000e324 );
 PROVIDE ( xthal_window_spill_nw = 0x4000e320 );
 
 PROVIDE ( Te0 = 0x3fffccf0 );
+PROVIDE ( Td0 = 0x3fffd100 );
+PROVIDE ( Td4s = 0x3fffd500);
+PROVIDE ( rcons = 0x3fffd0f0);
 PROVIDE ( UartDev = 0x3fffde10 );
 PROVIDE ( flashchip = 0x3fffc714);

esp8266/esp8266.ld

@@ -5,7 +5,7 @@ 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 = 0x40210000, len = 0x5A000
+    irom0_0_seg :  org = 0x40209000, len = 0x80000
 }
 
 /* define the top of RAM */
@@ -80,26 +80,84 @@ SECTIONS
         *(.irom0.literal .irom.literal .irom.text.literal .irom0.text .irom.text)
 
         /* we put some specific text in this section */
-        *py/*.o*(.literal* .text*)
-        *pyexec.o(.literal*, .text*)
-        *readline.o(.literal*, .text*)
-        *pybstdio.o(.literal*, .text*)
+
+        *py/argcheck.o*(.literal* .text*)
+        *py/asm*.o*(.literal* .text*)
+        *py/bc.o*(.literal* .text*)
+        *py/binary.o*(.literal* .text*)
+        *py/builtin*.o*(.literal* .text*)
+        *py/compile.o*(.literal* .text*)
+        *py/emit*.o*(.literal* .text*)
+        *py/formatfloat.o*(.literal* .text*)
+        *py/frozenmod.o*(.literal* .text*)
+        *py/gc.o*(.literal* .text*)
+        *py/lexer*.o*(.literal* .text*)
+        *py/malloc*.o*(.literal* .text*)
+        *py/map*.o*(.literal* .text*)
+        *py/mod*.o*(.literal* .text*)
+        *py/mpprint.o*(.literal* .text*)
+        *py/mpstate.o*(.literal* .text*)
+        *py/mpz.o*(.literal* .text*)
+        *py/native*.o*(.literal* .text*)
+        *py/nlr*.o*(.literal* .text*)
+        *py/obj*.o*(.literal* .text*)
+        *py/opmethods.o*(.literal* .text*)
+        *py/parse*.o*(.literal* .text*)
+        *py/qstr.o*(.literal* .text*)
+        *py/repl.o*(.literal* .text*)
+        *py/runtime.o*(.literal* .text*)
+        *py/scope.o*(.literal* .text*)
+        *py/sequence.o*(.literal* .text*)
+        *py/showbc.o*(.literal* .text*)
+        *py/smallint.o*(.literal* .text*)
+        *py/stackctrl.o*(.literal* .text*)
+        *py/stream.o*(.literal* .text*)
+        *py/unicode.o*(.literal* .text*)
+        *py/vm.o*(.literal* .text*)
+        *py/vstr.o*(.literal* .text*)
+        *py/warning.o*(.literal* .text*)
+
+        *extmod/*.o*(.literal* .text*)
+
+        *lib/fatfs/*.o*(.literal*, .text*)
+        *lib/libm/*.o*(.literal*, .text*)
+        *lib/mp-readline/*.o(.literal*, .text*)
+        *lib/netutils/*.o*(.literal*, .text*)
+        *lib/timeutils/*.o*(.literal*, .text*)
+        *lib/utils/*.o*(.literal*, .text*)
+
+        *stmhal/pybstdio.o(.literal*, .text*)
+
         *gccollect.o(.literal* .text*)
         *gchelper.o(.literal* .text*)
+        *lexerstr32.o(.literal* .text*)
+        *utils.o(.literal* .text*)
         *modpyb.o(.literal*, .text*)
         *modpybpin.o(.literal*, .text*)
+        *modpybpwm.o(.literal*, .text*)
         *modpybrtc.o(.literal*, .text*)
+        *modpybadc.o(.literal*, .text*)
+        *modpybuart.o(.literal*, .text*)
+        *modpybi2c.o(.literal*, .text*)
+        *modpybspi.o(.literal*, .text*)
         *modesp.o(.literal* .text*)
         *modnetwork.o(.literal* .text*)
         *moduos.o(.literal* .text*)
         *modutime.o(.literal* .text*)
+        *modlwip.o(.literal* .text*)
+        *modsocket.o(.literal* .text*)
 
         /* we put as much rodata as possible in this section */
         /* note that only rodata accessed as a machine word is allowed here */
         *py/qstr.o(.rodata.const_pool)
-        *py/*.o(.rodata.mp_type_*) /* catches type: mp_obj_type_t */
-        *py/*.o(.rodata.*_locals_dict*) /* catches types: mp_obj_dict_t, mp_map_elem_t */
-        *py/*.o(.rodata.mp_module_*) /* catches types: mp_obj_module_t, mp_obj_dict_t, mp_map_elem_t */
+        *.o(.rodata.mp_type_*) /* catches type: mp_obj_type_t */
+        *.o(.rodata.*_locals_dict*) /* catches types: mp_obj_dict_t, mp_map_elem_t */
+        *.o(.rodata.mp_module_*) /* catches types: mp_obj_module_t, mp_obj_dict_t, mp_map_elem_t */
+        */frozen.o(.rodata.mp_frozen_sizes) /* frozen modules */
+        */frozen.o(.rodata.mp_frozen_content) /* frozen modules */
+
+        /* for -mforce-l32 */
+        build/*.o(.rodata*)
 
         _irom0_text_end = ABSOLUTE(.);
     } >irom0_0_seg :irom0_0_phdr
@@ -172,6 +230,7 @@ SECTIONS
     .rodata : ALIGN(4)
     {
         _rodata_start = ABSOLUTE(.);
+        *(.sdk.version)
         *(.rodata)
         *(.rodata.*)
         *(.gnu.linkonce.r.*)

esp8266/esp_mphal.c

@@ -30,13 +30,24 @@
 #include "uart.h"
 #include "esp_mphal.h"
 #include "user_interface.h"
+#include "ets_alt_task.h"
+#include "py/obj.h"
+#include "py/mpstate.h"
+#include "extmod/misc.h"
+#include "lib/utils/pyexec.h"
 
 extern void ets_wdt_disable(void);
 extern void wdt_feed(void);
 extern void ets_delay_us();
 
+STATIC byte input_buf_array[256];
+ringbuf_t input_buf = {input_buf_array, sizeof(input_buf_array)};
+void mp_hal_debug_tx_strn_cooked(void *env, const char *str, uint32_t len);
+const mp_print_t mp_debug_print = {NULL, mp_hal_debug_tx_strn_cooked};
+
 void mp_hal_init(void) {
     ets_wdt_disable(); // it's a pain while developing
+    mp_hal_rtc_init();
     uart_init(UART_BIT_RATE_115200, UART_BIT_RATE_115200);
 }
 
@@ -47,12 +58,15 @@ void mp_hal_feed_watchdog(void) {
 }
 
 void mp_hal_delay_us(uint32_t us) {
-    ets_delay_us(us);
+    uint32_t start = system_get_time();
+    while (system_get_time() - start < us) {
+        ets_event_poll();
+    }
 }
 
 int mp_hal_stdin_rx_chr(void) {
     for (;;) {
-        int c = uart0_rx();
+        int c = ringbuf_get(&input_buf);
         if (c != -1) {
             return c;
         }
@@ -61,19 +75,43 @@ int mp_hal_stdin_rx_chr(void) {
     }
 }
 
-void mp_hal_stdout_tx_str(const char *str) {
+void mp_hal_stdout_tx_char(char c) {
+    uart_tx_one_char(UART0, c);
+    mp_uos_dupterm_tx_strn(&c, 1);
+}
+
+#if 0
+void mp_hal_debug_str(const char *str) {
     while (*str) {
         uart_tx_one_char(UART0, *str++);
     }
+    uart_flush(UART0);
+}
+#endif
+
+void mp_hal_stdout_tx_str(const char *str) {
+    while (*str) {
+        mp_hal_stdout_tx_char(*str++);
+    }
 }
 
 void mp_hal_stdout_tx_strn(const char *str, uint32_t len) {
     while (len--) {
-        uart_tx_one_char(UART0, *str++);
+        mp_hal_stdout_tx_char(*str++);
     }
 }
 
 void mp_hal_stdout_tx_strn_cooked(const char *str, uint32_t len) {
+    while (len--) {
+        if (*str == '\n') {
+            mp_hal_stdout_tx_char('\r');
+        }
+        mp_hal_stdout_tx_char(*str++);
+    }
+}
+
+void mp_hal_debug_tx_strn_cooked(void *env, const char *str, uint32_t len) {
+    (void)env;
     while (len--) {
         if (*str == '\n') {
             uart_tx_one_char(UART0, '\r');
@@ -86,10 +124,95 @@ uint32_t mp_hal_ticks_ms(void) {
     return system_get_time() / 1000;
 }
 
+uint32_t mp_hal_ticks_us(void) {
+    return system_get_time();
+}
+
 void mp_hal_delay_ms(uint32_t delay) {
     mp_hal_delay_us(delay * 1000);
 }
 
 void mp_hal_set_interrupt_char(int c) {
-    // TODO
+    if (c != -1) {
+        mp_obj_exception_clear_traceback(MP_STATE_PORT(mp_kbd_exception));
+    }
+    extern int interrupt_char;
+    interrupt_char = c;
+}
+
+void ets_event_poll(void) {
+    ets_loop_iter();
+    if (MP_STATE_VM(mp_pending_exception) != NULL) {
+        mp_obj_t obj = MP_STATE_VM(mp_pending_exception);
+        MP_STATE_VM(mp_pending_exception) = MP_OBJ_NULL;
+        nlr_raise(obj);
+    }
+}
+
+void __assert_func(const char *file, int line, const char *func, const char *expr) {
+    printf("assert:%s:%d:%s: %s\n", file, line, func, expr);
+    nlr_raise(mp_obj_new_exception_msg(&mp_type_AssertionError,
+        "C-level assert"));
+}
+
+void mp_hal_signal_input(void) {
+    #if MICROPY_REPL_EVENT_DRIVEN
+    system_os_post(UART_TASK_ID, 0, 0);
+    #endif
+}
+
+static int call_dupterm_read(void) {
+    if (MP_STATE_PORT(term_obj) == NULL) {
+        return -1;
+    }
+
+    nlr_buf_t nlr;
+    if (nlr_push(&nlr) == 0) {
+        mp_obj_t read_m[3];
+        mp_load_method(MP_STATE_PORT(term_obj), MP_QSTR_read, read_m);
+        read_m[2] = MP_OBJ_NEW_SMALL_INT(1);
+        mp_obj_t res = mp_call_method_n_kw(1, 0, read_m);
+        if (res == mp_const_none) {
+            return -2;
+        }
+        mp_buffer_info_t bufinfo;
+        mp_get_buffer_raise(res, &bufinfo, MP_BUFFER_READ);
+        if (bufinfo.len == 0) {
+            mp_printf(&mp_plat_print, "dupterm: EOF received, deactivating\n");
+            MP_STATE_PORT(term_obj) = NULL;
+            return -1;
+        }
+        nlr_pop();
+        return *(byte*)bufinfo.buf;
+    } else {
+        // Temporarily disable dupterm to avoid infinite recursion
+        mp_obj_t save_term = MP_STATE_PORT(term_obj);
+        MP_STATE_PORT(term_obj) = NULL;
+        mp_printf(&mp_plat_print, "dupterm: ");
+        mp_obj_print_exception(&mp_plat_print, nlr.ret_val);
+        MP_STATE_PORT(term_obj) = save_term;
+    }
+
+    return -1;
+}
+
+STATIC void dupterm_task_handler(os_event_t *evt) {
+    while (1) {
+        int c = call_dupterm_read();
+        if (c < 0) {
+            break;
+        }
+        ringbuf_put(&input_buf, c);
+    }
+    mp_hal_signal_input();
+}
+
+STATIC os_event_t dupterm_evt_queue[4];
+
+void dupterm_task_init() {
+    system_os_task(dupterm_task_handler, DUPTERM_TASK_ID, dupterm_evt_queue, MP_ARRAY_SIZE(dupterm_evt_queue));
+}
+
+void mp_hal_signal_dupterm_input(void) {
+    system_os_post(DUPTERM_TASK_ID, 0, 0);
 }

esp8266/esp_mphal.h

@@ -27,18 +27,33 @@
 #ifndef _INCLUDED_MPHAL_H_
 #define _INCLUDED_MPHAL_H_
 
-// SDK functions not declared in SDK itself
-void ets_isr_mask(unsigned);
+#include "py/ringbuf.h"
+
+struct _mp_print_t;
+// Structure for UART-only output via mp_printf()
+extern const struct _mp_print_t mp_debug_print;
+
+extern ringbuf_t input_buf;
+// Call this after putting data to input_buf
+void mp_hal_signal_input(void);
+// Call this when data is available in dupterm object
+void mp_hal_signal_dupterm_input(void);
 
 void mp_hal_init(void);
+void mp_hal_rtc_init(void);
 void mp_hal_feed_watchdog(void);
 
+uint32_t mp_hal_ticks_us(void);
 void mp_hal_delay_us(uint32_t);
 void mp_hal_set_interrupt_char(int c);
 uint32_t mp_hal_get_cpu_freq(void);
 
 #define UART_TASK_ID 0
+#define DUPTERM_TASK_ID 1
 void uart_task_init();
+void dupterm_task_init();
 
+void ets_event_poll(void);
+#define ETS_POLL_WHILE(cond) { while (cond) ets_event_poll(); }
 
 #endif // _INCLUDED_MPHAL_H_

esp8266/espneopixel.c

@@ -0,0 +1,64 @@
+// Original version from https://github.com/adafruit/Adafruit_NeoPixel
+// Modifications by dpgeorge to support auto-CPU-frequency detection
+
+// This is a mash-up of the Due show() code + insights from Michael Miller's
+// ESP8266 work for the NeoPixelBus library: github.com/Makuna/NeoPixelBus
+// Needs to be a separate .c file to enforce ICACHE_RAM_ATTR execution.
+
+#include "c_types.h"
+#include "eagle_soc.h"
+#include "user_interface.h"
+#include "espneopixel.h"
+
+#define NEO_KHZ400 (1)
+
+static uint32_t _getCycleCount(void) __attribute__((always_inline));
+static inline uint32_t _getCycleCount(void) {
+  uint32_t ccount;
+  __asm__ __volatile__("rsr %0,ccount":"=a" (ccount));
+  return ccount;
+}
+
+void /*ICACHE_RAM_ATTR*/ esp_neopixel_write(uint8_t pin, uint8_t *pixels, uint32_t numBytes, bool is800KHz) {
+
+  uint8_t *p, *end, pix, mask;
+  uint32_t t, time0, time1, period, c, startTime, pinMask;
+
+  pinMask   = 1 << pin;
+  p         =  pixels;
+  end       =  p + numBytes;
+  pix       = *p++;
+  mask      = 0x80;
+  startTime = 0;
+
+  uint32_t fcpu = system_get_cpu_freq() * 1000000;
+
+#ifdef NEO_KHZ400
+  if(is800KHz) {
+#endif
+    time0  = fcpu / 2500000; // 0.4us
+    time1  = fcpu / 1250000; // 0.8us
+    period = fcpu /  800000; // 1.25us per bit
+#ifdef NEO_KHZ400
+  } else { // 400 KHz bitstream
+    time0  = fcpu / 2000000; // 0.5uS
+    time1  = fcpu /  833333; // 1.2us
+    period = fcpu /  400000; // 2.5us per bit
+  }
+#endif
+
+  for(t = time0;; t = time0) {
+    if(pix & mask) t = time1;                             // Bit high duration
+    while(((c = _getCycleCount()) - startTime) < period); // Wait for bit start
+    GPIO_REG_WRITE(GPIO_OUT_W1TS_ADDRESS, pinMask);       // Set high
+    startTime = c;                                        // Save start time
+    while(((c = _getCycleCount()) - startTime) < t);      // Wait high duration
+    GPIO_REG_WRITE(GPIO_OUT_W1TC_ADDRESS, pinMask);       // Set low
+    if(!(mask >>= 1)) {                                   // Next bit/byte
+      if(p >= end) break;
+      pix  = *p++;
+      mask = 0x80;
+    }
+  }
+  while((_getCycleCount() - startTime) < period); // Wait for last bit
+}

esp8266/espneopixel.h

@@ -0,0 +1 @@
+void esp_neopixel_write(uint8_t pin, uint8_t *pixels, uint32_t numBytes, bool is800KHz);

esp8266/esppwm.c

@@ -0,0 +1,428 @@
+/******************************************************************************
+ * Copyright 2013-2014 Espressif Systems (Wuxi)
+ *
+ * FileName: pwm.c
+ *
+ * Description: pwm driver
+ *
+ * Modification history:
+ *     2014/5/1, v1.0 create this file.
+ *     2016/3/2: Modifications by dpgeorge to suit MicroPython
+*******************************************************************************/
+#include <stdio.h>
+#include <string.h>
+
+#include "etshal.h"
+#include "os_type.h"
+#include "gpio.h"
+
+#include "esppwm.h"
+
+#include "py/mpprint.h"
+#define PWM_DBG(...)
+//#define PWM_DBG(...) mp_printf(&mp_plat_print, __VA_ARGS__)
+
+#define ICACHE_RAM_ATTR // __attribute__((section(".text")))
+
+#define PWM_CHANNEL 8
+#define PWM_DEPTH 1023
+#define PWM_FREQ_MAX 1000
+#define PWM_1S 1000000
+
+struct pwm_single_param {
+    uint16_t gpio_set;
+    uint16_t gpio_clear;
+    uint32_t h_time;
+};
+
+struct pwm_param {
+    uint32_t period;
+    uint16_t freq;
+    uint16_t duty[PWM_CHANNEL];
+};
+
+STATIC const uint8_t pin_num[PWM_CHANNEL] = {0, 2, 4, 5, 12, 13, 14, 15};
+
+STATIC struct pwm_single_param pwm_single_toggle[2][PWM_CHANNEL + 1];
+STATIC struct pwm_single_param *pwm_single;
+
+STATIC struct pwm_param pwm;
+
+STATIC int8_t pwm_out_io_num[PWM_CHANNEL] = {-1, -1, -1, -1, -1, -1, -1, -1};
+
+STATIC uint8_t pwm_channel_toggle[2];
+STATIC uint8_t *pwm_channel;
+STATIC uint8_t pwm_toggle = 1;
+STATIC uint8_t pwm_timer_down = 1;
+STATIC uint8_t pwm_current_channel = 0;
+STATIC uint16_t pwm_gpio = 0;
+STATIC uint8_t pwm_channel_num = 0;
+
+//XXX: 0xffffffff/(80000000/16)=35A
+#define US_TO_RTC_TIMER_TICKS(t)          \
+    ((t) ?                                   \
+     (((t) > 0x35A) ?                   \
+      (((t)>>2) * ((APB_CLK_FREQ>>4)/250000) + ((t)&0x3) * ((APB_CLK_FREQ>>4)/1000000))  :    \
+      (((t) *(APB_CLK_FREQ>>4)) / 1000000)) :    \
+     0)
+
+//FRC1
+#define FRC1_ENABLE_TIMER  BIT7
+
+typedef enum {
+    DIVDED_BY_1 = 0,
+    DIVDED_BY_16 = 4,
+    DIVDED_BY_256 = 8,
+} TIMER_PREDIVED_MODE;
+
+typedef enum {
+    TM_LEVEL_INT = 1,
+    TM_EDGE_INT   = 0,
+} TIMER_INT_MODE;
+
+STATIC void ICACHE_FLASH_ATTR
+pwm_insert_sort(struct pwm_single_param pwm[], uint8 n)
+{
+    uint8 i;
+
+    for (i = 1; i < n; i++) {
+        if (pwm[i].h_time < pwm[i - 1].h_time) {
+            int8 j = i - 1;
+            struct pwm_single_param tmp;
+
+            memcpy(&tmp, &pwm[i], sizeof(struct pwm_single_param));
+            memcpy(&pwm[i], &pwm[i - 1], sizeof(struct pwm_single_param));
+
+            while (tmp.h_time < pwm[j].h_time) {
+                memcpy(&pwm[j + 1], &pwm[j], sizeof(struct pwm_single_param));
+                j--;
+                if (j < 0) {
+                    break;
+                }
+            }
+
+            memcpy(&pwm[j + 1], &tmp, sizeof(struct pwm_single_param));
+        }
+    }
+}
+
+STATIC volatile uint8 critical = 0;
+
+#define LOCK_PWM(c)  do {                       \
+    while( (c)==1 );                            \
+    (c) = 1;                                    \
+} while (0)
+
+#define UNLOCK_PWM(c) do {                      \
+    (c) = 0;                                    \
+} while (0)
+
+void ICACHE_FLASH_ATTR
+pwm_start(void)
+{
+    uint8 i, j;
+    PWM_DBG("--Function pwm_start() is called\n");
+    PWM_DBG("pwm_gpio:%x,pwm_channel_num:%d\n",pwm_gpio,pwm_channel_num);
+    PWM_DBG("pwm_out_io_num[0]:%d,[1]:%d,[2]:%d\n",pwm_out_io_num[0],pwm_out_io_num[1],pwm_out_io_num[2]);
+    PWM_DBG("pwm.period:%d,pwm.duty[0]:%d,[1]:%d,[2]:%d\n",pwm.period,pwm.duty[0],pwm.duty[1],pwm.duty[2]);
+
+    LOCK_PWM(critical);   // enter critical
+
+    struct pwm_single_param *local_single = pwm_single_toggle[pwm_toggle ^ 0x01];
+    uint8 *local_channel = &pwm_channel_toggle[pwm_toggle ^ 0x01];
+
+    // step 1: init PWM_CHANNEL+1 channels param
+    for (i = 0; i < pwm_channel_num; i++) {
+        uint32 us = pwm.period * pwm.duty[i] / PWM_DEPTH;
+        local_single[i].h_time = US_TO_RTC_TIMER_TICKS(us);
+        PWM_DBG("i:%d us:%d ht:%d\n",i,us,local_single[i].h_time);
+        local_single[i].gpio_set = 0;
+        local_single[i].gpio_clear = 1 << pin_num[pwm_out_io_num[i]];
+    }
+
+    local_single[pwm_channel_num].h_time = US_TO_RTC_TIMER_TICKS(pwm.period);
+    local_single[pwm_channel_num].gpio_set = pwm_gpio;
+    local_single[pwm_channel_num].gpio_clear = 0;
+    PWM_DBG("i:%d period:%d ht:%d\n",pwm_channel_num,pwm.period,local_single[pwm_channel_num].h_time);
+    // step 2: sort, small to big
+    pwm_insert_sort(local_single, pwm_channel_num + 1);
+
+    *local_channel = pwm_channel_num + 1;
+    PWM_DBG("1channel:%d,single[0]:%d,[1]:%d,[2]:%d,[3]:%d\n",*local_channel,local_single[0].h_time,local_single[1].h_time,local_single[2].h_time,local_single[3].h_time);
+    // step 3: combine same duty channels
+    for (i = pwm_channel_num; i > 0; i--) {
+        if (local_single[i].h_time == local_single[i - 1].h_time) {
+            local_single[i - 1].gpio_set |= local_single[i].gpio_set;
+            local_single[i - 1].gpio_clear |= local_single[i].gpio_clear;
+
+            for (j = i + 1; j < *local_channel; j++) {
+                memcpy(&local_single[j - 1], &local_single[j], sizeof(struct pwm_single_param));
+            }
+
+            (*local_channel)--;
+        }
+    }
+    PWM_DBG("2channel:%d,single[0]:%d,[1]:%d,[2]:%d,[3]:%d\n",*local_channel,local_single[0].h_time,local_single[1].h_time,local_single[2].h_time,local_single[3].h_time);
+    // step 4: cacl delt time
+    for (i = *local_channel - 1; i > 0; i--) {
+        local_single[i].h_time -= local_single[i - 1].h_time;
+    }
+
+    // step 5: last channel needs to clean
+    local_single[*local_channel-1].gpio_clear = 0;
+
+    // step 6: if first channel duty is 0, remove it
+    if (local_single[0].h_time == 0) {
+        local_single[*local_channel - 1].gpio_set &= ~local_single[0].gpio_clear;
+        local_single[*local_channel - 1].gpio_clear |= local_single[0].gpio_clear;
+
+        for (i = 1; i < *local_channel; i++) {
+            memcpy(&local_single[i - 1], &local_single[i], sizeof(struct pwm_single_param));
+        }
+
+        (*local_channel)--;
+    }
+
+    // if timer is down, need to set gpio and start timer
+    if (pwm_timer_down == 1) {
+        pwm_channel = local_channel;
+        pwm_single = local_single;
+        // start
+        gpio_output_set(local_single[0].gpio_set, local_single[0].gpio_clear, pwm_gpio, 0);
+
+        // yeah, if all channels' duty is 0 or 255, don't need to start timer, otherwise start...
+        if (*local_channel != 1) {
+            pwm_timer_down = 0;
+            RTC_REG_WRITE(FRC1_LOAD_ADDRESS, local_single[0].h_time);
+        }
+    }
+
+    if (pwm_toggle == 1) {
+        pwm_toggle = 0;
+    } else {
+        pwm_toggle = 1;
+    }
+
+    UNLOCK_PWM(critical);   // leave critical
+    PWM_DBG("3channel:%d,single[0]:%d,[1]:%d,[2]:%d,[3]:%d\n",*local_channel,local_single[0].h_time,local_single[1].h_time,local_single[2].h_time,local_single[3].h_time);
+}
+
+/******************************************************************************
+ * FunctionName : pwm_set_duty
+ * Description  : set each channel's duty params
+ * Parameters   : uint8 duty    : 0 ~ PWM_DEPTH
+ *                uint8 channel : channel index
+ * Returns      : NONE
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+pwm_set_duty(uint16 duty, uint8 channel)
+{
+    uint8 i;
+    for(i=0;i<pwm_channel_num;i++){
+        if(pwm_out_io_num[i] == channel){
+            channel = i;
+            break;
+        }
+    }
+    if(i==pwm_channel_num)      // non found
+        return;
+
+    LOCK_PWM(critical);   // enter critical
+    if (duty < 1) {
+        pwm.duty[channel] = 0;
+    } else if (duty >= PWM_DEPTH) {
+        pwm.duty[channel] = PWM_DEPTH;
+    } else {
+        pwm.duty[channel] = duty;
+    }
+    UNLOCK_PWM(critical);   // leave critical
+}
+
+/******************************************************************************
+ * FunctionName : pwm_set_freq
+ * Description  : set pwm frequency
+ * Parameters   : uint16 freq : 100hz typically
+ * Returns      : NONE
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+pwm_set_freq(uint16 freq, uint8 channel)
+{
+    LOCK_PWM(critical);   // enter critical
+    if (freq > PWM_FREQ_MAX) {
+        pwm.freq = PWM_FREQ_MAX;
+    } else if (freq < 1) {
+        pwm.freq = 1;
+    } else {
+        pwm.freq = freq;
+    }
+
+    pwm.period = PWM_1S / pwm.freq;
+    UNLOCK_PWM(critical);   // leave critical
+}
+
+/******************************************************************************
+ * FunctionName : pwm_get_duty
+ * Description  : get duty of each channel
+ * Parameters   : uint8 channel : channel index
+ * Returns      : NONE
+*******************************************************************************/
+uint16 ICACHE_FLASH_ATTR
+pwm_get_duty(uint8 channel)
+{
+    uint8 i;
+    for(i=0;i<pwm_channel_num;i++){
+        if(pwm_out_io_num[i] == channel){
+            channel = i;
+            break;
+        }
+    }
+    if(i==pwm_channel_num)      // non found
+        return 0;
+
+    return pwm.duty[channel];
+}
+
+/******************************************************************************
+ * FunctionName : pwm_get_freq
+ * Description  : get pwm frequency
+ * Parameters   : NONE
+ * Returns      : uint16 : pwm frequency
+*******************************************************************************/
+uint16 ICACHE_FLASH_ATTR
+pwm_get_freq(uint8 channel)
+{
+    return pwm.freq;
+}
+
+/******************************************************************************
+ * FunctionName : pwm_period_timer
+ * Description  : pwm period timer function, output high level,
+ *                start each channel's high level timer
+ * Parameters   : NONE
+ * Returns      : NONE
+*******************************************************************************/
+STATIC void ICACHE_RAM_ATTR
+pwm_tim1_intr_handler(void *dummy)
+{
+    (void)dummy;
+    uint8 local_toggle = pwm_toggle;                        // pwm_toggle may change outside
+    RTC_CLR_REG_MASK(FRC1_INT_ADDRESS, FRC1_INT_CLR_MASK);
+
+    if (pwm_current_channel >= (*pwm_channel - 1)) {        // *pwm_channel may change outside
+        pwm_single = pwm_single_toggle[local_toggle];
+        pwm_channel = &pwm_channel_toggle[local_toggle];
+
+        gpio_output_set(pwm_single[*pwm_channel - 1].gpio_set,
+                        pwm_single[*pwm_channel - 1].gpio_clear,
+                        pwm_gpio,
+                        0);
+
+        pwm_current_channel = 0;
+
+        if (*pwm_channel != 1) {
+            RTC_REG_WRITE(FRC1_LOAD_ADDRESS, pwm_single[pwm_current_channel].h_time);
+        } else {
+            pwm_timer_down = 1;
+        }
+    } else {
+        gpio_output_set(pwm_single[pwm_current_channel].gpio_set,
+                        pwm_single[pwm_current_channel].gpio_clear,
+                        pwm_gpio, 0);
+
+        pwm_current_channel++;
+        RTC_REG_WRITE(FRC1_LOAD_ADDRESS, pwm_single[pwm_current_channel].h_time);
+    }
+}
+
+/******************************************************************************
+ * FunctionName : pwm_init
+ * Description  : pwm gpio, params and timer initialization
+ * Parameters   : uint16 freq : pwm freq param
+ *                uint16 *duty : each channel's duty
+ * Returns      : NONE
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+pwm_init(void)
+{
+    uint8 i;
+
+    RTC_REG_WRITE(FRC1_CTRL_ADDRESS,  //FRC2_AUTO_RELOAD|
+                  DIVDED_BY_16
+                  | FRC1_ENABLE_TIMER
+                  | TM_EDGE_INT);
+    RTC_REG_WRITE(FRC1_LOAD_ADDRESS, 0);
+
+    for (i = 0; i < PWM_CHANNEL; i++) {
+        pwm_gpio = 0;
+        pwm.duty[i] = 0;
+    }
+
+    pwm_set_freq(500, 0);
+    pwm_start();
+
+    ETS_FRC_TIMER1_INTR_ATTACH(pwm_tim1_intr_handler, NULL);
+    TM1_EDGE_INT_ENABLE();
+    ETS_FRC1_INTR_ENABLE();
+}
+
+int ICACHE_FLASH_ATTR
+pwm_add(uint8_t pin_id, uint32_t pin_mux, uint32_t pin_func){
+    PWM_DBG("--Function pwm_add() is called. channel:%d\n", channel);
+    PWM_DBG("pwm_gpio:%x,pwm_channel_num:%d\n",pwm_gpio,pwm_channel_num);
+    PWM_DBG("pwm_out_io_num[0]:%d,[1]:%d,[2]:%d\n",pwm_out_io_num[0],pwm_out_io_num[1],pwm_out_io_num[2]);
+    PWM_DBG("pwm.duty[0]:%d,[1]:%d,[2]:%d\n",pwm.duty[0],pwm.duty[1],pwm.duty[2]);
+    int channel = -1;
+    for (int i = 0; i < PWM_CHANNEL; ++i) {
+        if (pin_num[i] == pin_id) {
+            channel = i;
+            break;
+        }
+    }
+    if (channel == -1) {
+        return -1;
+    }
+    uint8 i;
+    for(i=0;i<PWM_CHANNEL;i++){
+        if(pwm_out_io_num[i]==channel)  // already exist
+            return channel;
+        if(pwm_out_io_num[i] == -1){ // empty exist
+            LOCK_PWM(critical);   // enter critical
+            pwm_out_io_num[i] = channel;
+            pwm.duty[i] = 0;
+            pwm_gpio |= (1 << pin_num[channel]);
+            PIN_FUNC_SELECT(pin_mux, pin_func);
+            GPIO_REG_WRITE(GPIO_PIN_ADDR(GPIO_ID_PIN(pin_num[channel])), GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(pin_num[channel]))) & (~ GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_ENABLE))); //disable open drain;
+            pwm_channel_num++;
+            UNLOCK_PWM(critical);   // leave critical
+            return channel;
+        }
+    }
+    return -1;
+}
+
+bool ICACHE_FLASH_ATTR
+pwm_delete(uint8 channel){
+    PWM_DBG("--Function pwm_delete() is called. channel:%d\n", channel);
+    PWM_DBG("pwm_gpio:%x,pwm_channel_num:%d\n",pwm_gpio,pwm_channel_num);
+    PWM_DBG("pwm_out_io_num[0]:%d,[1]:%d,[2]:%d\n",pwm_out_io_num[0],pwm_out_io_num[1],pwm_out_io_num[2]);
+    PWM_DBG("pwm.duty[0]:%d,[1]:%d,[2]:%d\n",pwm.duty[0],pwm.duty[1],pwm.duty[2]);
+    uint8 i,j;
+    for(i=0;i<pwm_channel_num;i++){
+        if(pwm_out_io_num[i]==channel){  // exist
+            LOCK_PWM(critical);   // enter critical
+            pwm_out_io_num[i] = -1;
+            pwm_gpio &= ~(1 << pin_num[channel]);   //clear the bit
+            for(j=i;j<pwm_channel_num-1;j++){
+                pwm_out_io_num[j] = pwm_out_io_num[j+1];
+                pwm.duty[j] = pwm.duty[j+1];
+            }
+            pwm_out_io_num[pwm_channel_num-1] = -1;
+            pwm.duty[pwm_channel_num-1] = 0;
+            pwm_channel_num--;
+            UNLOCK_PWM(critical);   // leave critical
+            return true;
+        }
+    }
+    // non found
+    return true;
+}

esp8266/esppwm.h

@@ -0,0 +1,17 @@
+#ifndef __ESPPWM_H__
+#define __ESPPWM_H__
+
+#include <stdbool.h>
+#include <stdint.h>
+
+void pwm_init(void);
+void pwm_start(void);
+
+void pwm_set_duty(uint16_t duty, uint8_t channel);
+uint16_t pwm_get_duty(uint8_t channel);
+void pwm_set_freq(uint16_t freq, uint8_t channel);
+uint16_t pwm_get_freq(uint8_t channel);
+int pwm_add(uint8_t pin_id, uint32_t pin_mux, uint32_t pin_func);
+bool pwm_delete(uint8_t channel);
+
+#endif

esp8266/ets_alt_task.c

@@ -0,0 +1,194 @@
+#include <stdio.h>
+#include "osapi.h"
+#include "os_type.h"
+#include "ets_sys.h"
+#include <esp_sdk_ver.h>
+#include "etshal.h"
+#include "user_interface.h"
+
+// Use standard ets_task or alternative impl
+#define USE_ETS_TASK 0
+
+#define MP_ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
+
+struct task_entry {
+    os_event_t *queue;
+    os_task_t task;
+    uint8_t qlen;
+    uint8_t prio;
+    int8_t i_get;
+    int8_t i_put;
+};
+
+static void (*idle_cb)(void *);
+static void *idle_arg;
+
+#if ESP_SDK_VERSION >= 010500
+# define FIRST_PRIO 0
+#else
+# define FIRST_PRIO 0x14
+#endif
+#define LAST_PRIO 0x20
+#define PRIO2ID(prio) ((prio) - FIRST_PRIO)
+
+volatile struct task_entry emu_tasks[PRIO2ID(LAST_PRIO) + 1];
+
+static inline int prio2id(uint8_t prio) {
+    int id = PRIO2ID(prio);
+    if (id < 0 || id >= MP_ARRAY_SIZE(emu_tasks)) {
+        printf("task prio out of range: %d\n", prio);
+        while (1);
+    }
+    return id;
+}
+
+#if DEBUG
+void dump_task(int prio, volatile struct task_entry *t) {
+    printf("q for task %d: queue: %p, get ptr: %d, put ptr: %d, qlen: %d\n",
+        prio, t->queue, t->i_get, t->i_put, t->qlen);
+}
+
+void dump_tasks(void) {
+    for (int i = 0; i < MP_ARRAY_SIZE(emu_tasks); i++) {
+        if (emu_tasks[i].qlen) {
+            dump_task(i + FIRST_PRIO, &emu_tasks[i]);
+        }
+    }
+    printf("====\n");
+}
+#endif
+
+bool ets_task(os_task_t task, uint8 prio, os_event_t *queue, uint8 qlen) {
+    static unsigned cnt;
+    printf("#%d ets_task(%p, %d, %p, %d)\n", cnt++, task, prio, queue, qlen);
+#if USE_ETS_TASK
+    return _ets_task(task, prio, queue, qlen);
+#else
+    int id = prio2id(prio);
+    emu_tasks[id].task = task;
+    emu_tasks[id].queue = queue;
+    emu_tasks[id].qlen = qlen;
+    emu_tasks[id].i_get = 0;
+    emu_tasks[id].i_put = 0;
+    return true;
+#endif
+}
+
+bool ets_post(uint8 prio, os_signal_t sig, os_param_t param) {
+//    static unsigned cnt; printf("#%d ets_post(%d, %x, %x)\n", cnt++, prio, sig, param);
+#if USE_ETS_TASK
+    return _ets_post(prio, sig, param);
+#else
+    ets_intr_lock();
+
+    const int id = prio2id(prio);
+    os_event_t *q = emu_tasks[id].queue;
+    if (emu_tasks[id].i_put == -1) {
+        // queue is full
+        printf("ets_post: task %d queue full\n", prio);
+        return false;
+    }
+    q = &q[emu_tasks[id].i_put++];
+    q->sig = sig;
+    q->par = param;
+    if (emu_tasks[id].i_put == emu_tasks[id].qlen) {
+        emu_tasks[id].i_put = 0;
+    }
+    if (emu_tasks[id].i_put == emu_tasks[id].i_get) {
+        // queue got full
+        emu_tasks[id].i_put = -1;
+    }
+    //printf("after ets_post: "); dump_task(prio, &emu_tasks[id]);
+    //dump_tasks();
+
+    ets_intr_unlock();
+
+    return true;
+#endif
+}
+
+bool ets_loop_iter(void) {
+    //static unsigned cnt;
+    bool progress = false;
+    for (volatile struct task_entry *t = emu_tasks; t < &emu_tasks[MP_ARRAY_SIZE(emu_tasks)]; t++) {
+        system_soft_wdt_feed();
+        ets_intr_lock();
+        //printf("etc_loop_iter: "); dump_task(t - emu_tasks + FIRST_PRIO, t);
+        if (t->i_get != t->i_put) {
+            progress = true;
+            //printf("#%d Calling task %d(%p) (%x, %x)\n", cnt++,
+            //    t - emu_tasks + FIRST_PRIO, t->task, t->queue[t->i_get].sig, t->queue[t->i_get].par);
+            int idx = t->i_get;
+            if (t->i_put == -1) {
+                t->i_put = t->i_get;
+            }
+            if (++t->i_get == t->qlen) {
+                t->i_get = 0;
+            }
+            //ets_intr_unlock();
+            t->task(&t->queue[idx]);
+            //ets_intr_lock();
+            //printf("Done calling task %d\n", t - emu_tasks + FIRST_PRIO);
+        }
+        ets_intr_unlock();
+    }
+    return progress;
+}
+
+#if SDK_BELOW_1_1_1
+void my_timer_isr(void *arg) {
+//    uart0_write_char('+');
+    ets_post(0x1f, 0, 0);
+}
+
+// Timer init func is in ROM, and calls ets_task by relative addr directly in ROM
+// so, we have to re-init task using our handler
+void ets_timer_init() {
+    printf("ets_timer_init\n");
+//    _ets_timer_init();
+    ets_isr_attach(10, my_timer_isr, NULL);
+    SET_PERI_REG_MASK(0x3FF00004, 4);
+    ETS_INTR_ENABLE(10);
+    ets_task((os_task_t)0x40002E3C, 0x1f, (os_event_t*)0x3FFFDDC0, 4);
+
+    WRITE_PERI_REG(PERIPHS_TIMER_BASEDDR + 0x30, 0);
+    WRITE_PERI_REG(PERIPHS_TIMER_BASEDDR + 0x28, 0x88);
+    WRITE_PERI_REG(PERIPHS_TIMER_BASEDDR + 0x30, 0);
+    printf("Installed timer ISR\n");
+}
+#endif
+
+bool ets_run(void) {
+#if USE_ETS_TASK
+    #if SDK_BELOW_1_1_1
+    ets_isr_attach(10, my_timer_isr, NULL);
+    #endif
+    _ets_run();
+#else
+//    ets_timer_init();
+    *(char*)0x3FFFC6FC = 0;
+    ets_intr_lock();
+    printf("ets_alt_task: ets_run\n");
+#if DEBUG
+    dump_tasks();
+#endif
+    ets_intr_unlock();
+    while (1) {
+        if (!ets_loop_iter()) {
+            //printf("idle\n");
+            ets_intr_lock();
+            if (idle_cb) {
+                idle_cb(idle_arg);
+            }
+            asm("waiti 0");
+            ets_intr_unlock();
+        }
+    }
+#endif
+}
+
+void ets_set_idle_cb(void (*handler)(void *), void *arg) {
+    //printf("ets_set_idle_cb(%p, %p)\n", handler, arg);
+    idle_cb = handler;
+    idle_arg = arg;
+}

esp8266/ets_alt_task.h

@@ -0,0 +1 @@
+bool ets_loop_iter(void);

esp8266/etshal.h

@@ -1,9 +1,23 @@
 #ifndef _INCLUDED_ETSHAL_H_
 #define _INCLUDED_ETSHAL_H_
 
-void ets_isr_unmask();
+#include <os_type.h>
+
+// see http://esp8266-re.foogod.com/wiki/Random_Number_Generator
+#define WDEV_HWRNG ((volatile uint32_t*)0x3ff20e44)
+
+void ets_delay_us();
+void ets_intr_lock(void);
+void ets_intr_unlock(void);
+void ets_isr_mask(uint32_t mask);
+void ets_isr_unmask(uint32_t mask);
+void ets_isr_attach(int irq_no, void (*handler)(void *), void *arg);
 void ets_install_putc1();
-void ets_isr_attach();
 void uart_div_modify();
+void ets_set_idle_cb(void (*handler)(void *), void *arg);
+
+void ets_timer_arm_new(os_timer_t *tim, uint32_t millis, bool repeat, bool is_milli_timer);
+void ets_timer_setfn(os_timer_t *tim, ETSTimerFunc callback, void *cb_data);
+void ets_timer_disarm(os_timer_t *tim);
 
 #endif // _INCLUDED_ETSHAL_H_

esp8266/fatfs_port.c

@@ -0,0 +1,6 @@
+#include "lib/fatfs/ff.h"
+#include "lib/fatfs/diskio.h"
+
+DWORD get_fattime(void) {
+    return 0;
+}

esp8266/gccollect.c

@@ -39,10 +39,6 @@ void gc_collect(void) {
     // start the GC
     gc_collect_start();
 
-    // We need to scan everything in RAM that can hold a pointer.
-    // The data segment is used, but should not contain pointers, so we just scan the bss.
-    gc_collect_root((void**)&_bss_start, ((uint32_t)&_bss_end - (uint32_t)&_bss_start) / sizeof(uint32_t));
-
     // get the registers and the sp
     mp_uint_t regs[8];
     mp_uint_t sp = gc_helper_get_regs_and_sp(regs);

esp8266/lexerstr32.c

@@ -0,0 +1,69 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2013-2016 Damien P. George
+ * Copyright (c) 2016 Paul Sokolovsky
+ *
+ * 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.
+ */
+
+#include "py/lexer.h"
+
+#if MICROPY_ENABLE_COMPILER
+
+typedef struct _mp_lexer_str32_buf_t {
+    const uint32_t *src_cur;
+    uint32_t val;
+    uint8_t byte_off;
+} mp_lexer_str32_buf_t;
+
+STATIC mp_uint_t str32_buf_next_byte(mp_lexer_str32_buf_t *sb) {
+    byte c = sb->val & 0xff;
+    if (c == 0) {
+        return MP_LEXER_EOF;
+    }
+
+    if (++sb->byte_off > 3) {
+        sb->byte_off = 0;
+        sb->val = *sb->src_cur++;
+    } else {
+        sb->val >>= 8;
+    }
+
+    return c;
+}
+
+STATIC void str32_buf_free(mp_lexer_str32_buf_t *sb) {
+    m_del_obj(mp_lexer_str32_buf_t, sb);
+}
+
+mp_lexer_t *mp_lexer_new_from_str32(qstr src_name, const char *str, mp_uint_t len, mp_uint_t free_len) {
+    mp_lexer_str32_buf_t *sb = m_new_obj_maybe(mp_lexer_str32_buf_t);
+    if (sb == NULL) {
+        return NULL;
+    }
+    sb->byte_off = (uint32_t)str & 3;
+    sb->src_cur = (uint32_t*)(str - sb->byte_off);
+    sb->val = *sb->src_cur++ >> sb->byte_off * 8;
+    return mp_lexer_new(src_name, sb, (mp_lexer_stream_next_byte_t)str32_buf_next_byte, (mp_lexer_stream_close_t)str32_buf_free);
+}
+
+#endif // MICROPY_ENABLE_COMPILER

esp8266/main.c

@@ -32,59 +32,112 @@
 #include "py/runtime0.h"
 #include "py/runtime.h"
 #include "py/stackctrl.h"
-#include "py/frozenmod.h"
 #include "py/mphal.h"
 #include "py/gc.h"
 #include "lib/utils/pyexec.h"
 #include "gccollect.h"
 #include "user_interface.h"
 
-STATIC char heap[16384];
+STATIC char heap[24 * 1024];
 
 STATIC void mp_reset(void) {
-    mp_stack_set_limit(10240);
+    mp_stack_set_top((void*)0x40000000);
+    mp_stack_set_limit(8192);
     mp_hal_init();
     gc_init(heap, heap + sizeof(heap));
     mp_init();
     mp_obj_list_init(mp_sys_path, 0);
     mp_obj_list_init(mp_sys_argv, 0);
+    #if MICROPY_VFS_FAT
+    memset(MP_STATE_PORT(fs_user_mount), 0, sizeof(MP_STATE_PORT(fs_user_mount)));
+    #endif
+    MP_STATE_PORT(mp_kbd_exception) = mp_obj_new_exception(&mp_type_KeyboardInterrupt);
+    MP_STATE_PORT(term_obj) = MP_OBJ_NULL;
 #if MICROPY_MODULE_FROZEN
-    mp_lexer_t *lex = mp_find_frozen_module("main", 4);
-    mp_parse_compile_execute(lex, MP_PARSE_FILE_INPUT, mp_globals_get(), mp_locals_get());
+    pyexec_frozen_module("_boot");
+    pyexec_file("boot.py");
+    pyexec_file("main.py");
 #endif
 }
 
 void soft_reset(void) {
-    mp_hal_stdout_tx_str("PYB: soft reset\r\n");
+    mp_hal_stdout_tx_str("PYB: soft reboot\r\n");
     mp_hal_delay_us(10000); // allow UART to flush output
     mp_reset();
+    #if MICROPY_REPL_EVENT_DRIVEN
     pyexec_event_repl_init();
+    #endif
 }
 
 void init_done(void) {
+    #if MICROPY_REPL_EVENT_DRIVEN
+    uart_task_init();
+    #endif
     mp_reset();
     mp_hal_stdout_tx_str("\r\n");
+    #if MICROPY_REPL_EVENT_DRIVEN
     pyexec_event_repl_init();
-    uart_task_init();
+    #endif
+    dupterm_task_init();
+
+    #if !MICROPY_REPL_EVENT_DRIVEN
+soft_reset:
+    for (;;) {
+        if (pyexec_mode_kind == PYEXEC_MODE_RAW_REPL) {
+            if (pyexec_raw_repl() != 0) {
+                break;
+            }
+        } else {
+            if (pyexec_friendly_repl() != 0) {
+                break;
+            }
+        }
+    }
+    soft_reset();
+    goto soft_reset;
+    #endif
 }
 
 void user_init(void) {
     system_init_done_cb(init_done);
 }
 
+mp_lexer_t *fat_vfs_lexer_new_from_file(const char *filename);
+mp_import_stat_t fat_vfs_import_stat(const char *path);
+
 mp_lexer_t *mp_lexer_new_from_file(const char *filename) {
+    #if MICROPY_VFS_FAT
+    return fat_vfs_lexer_new_from_file(filename);
+    #else
+    (void)filename;
     return NULL;
+    #endif
 }
 
 mp_import_stat_t mp_import_stat(const char *path) {
+    #if MICROPY_VFS_FAT
+    return fat_vfs_import_stat(path);
+    #else
+    (void)path;
     return MP_IMPORT_STAT_NO_EXIST;
+    #endif
 }
 
+mp_obj_t vfs_proxy_call(qstr method_name, mp_uint_t n_args, const mp_obj_t *args);
 mp_obj_t mp_builtin_open(uint n_args, const mp_obj_t *args, mp_map_t *kwargs) {
+    #if MICROPY_VFS_FAT
+    // TODO: Handle kwargs!
+    return vfs_proxy_call(MP_QSTR_open, n_args, args);
+    #else
     return mp_const_none;
+    #endif
 }
 MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_open_obj, 1, mp_builtin_open);
 
+void mp_keyboard_interrupt(void) {
+    MP_STATE_VM(mp_pending_exception) = MP_STATE_PORT(mp_kbd_exception);
+}
+
 void nlr_jump_fail(void *val) {
     printf("NLR jump failed\n");
     for (;;) {

esp8266/makeimg.py

@@ -1,5 +1,7 @@
 import sys
 
+SEGS_MAX_SIZE = 0x9000
+
 assert len(sys.argv) == 4
 
 with open(sys.argv[3], 'wb') as fout:
@@ -9,7 +11,7 @@ with open(sys.argv[3], 'wb') as fout:
         fout.write(data_flash)
         print('flash    ', len(data_flash))
 
-    pad = b'\xff' * (0x10000 - len(data_flash))
+    pad = b'\xff' * (SEGS_MAX_SIZE - len(data_flash))
     fout.write(pad)
     print('padding  ', len(pad))
 
@@ -18,4 +20,4 @@ with open(sys.argv[3], 'wb') as fout:
         fout.write(data_rom)
         print('irom0text', len(data_rom))
 
-    print('total    ', 0x10000 + len(data_rom))
+    print('total    ', SEGS_MAX_SIZE + len(data_rom))

esp8266/modesp.c

@@ -27,6 +27,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <stdbool.h>
+#include <errno.h>
 
 #include "py/nlr.h"
 #include "py/obj.h"
@@ -34,12 +35,18 @@
 #include "py/runtime.h"
 #include "netutils.h"
 #include "queue.h"
+#include "ets_sys.h"
+#include "uart.h"
 #include "user_interface.h"
 #include "espconn.h"
-#include "ip_addr.h"
 #include "spi_flash.h"
 #include "utils.h"
+#include "espneopixel.h"
+#include "modpyb.h"
 
+#define MODESP_ESPCONN (0)
+
+#if MODESP_ESPCONN
 STATIC const mp_obj_type_t esp_socket_type;
 
 typedef struct _esp_socket_obj_t {
@@ -79,7 +86,7 @@ STATIC mp_obj_t esp_socket_make_new_base() {
 
 // constructor esp_socket(family=AF_INET, type=SOCK_STREAM, proto=IPPROTO_TCP, fileno=None)
 // Arguments ignored as we do not support UDP (yet)
-STATIC mp_obj_t esp_socket_make_new(mp_obj_t type_in, mp_uint_t n_args,
+STATIC mp_obj_t esp_socket_make_new(const mp_obj_type_t *type_in, mp_uint_t n_args,
     mp_uint_t n_kw, const mp_obj_t *args) {
     mp_arg_check_num(n_args, n_kw, 0, 4, false);
 
@@ -499,6 +506,7 @@ STATIC const mp_obj_type_t esp_socket_type = {
     .make_new = esp_socket_make_new,
     .locals_dict = (mp_obj_t)&esp_socket_locals_dict,
 };
+#endif
 
 #define MODESP_INCLUDE_CONSTANTS (1)
 
@@ -508,25 +516,15 @@ void error_check(bool status, const char *msg) {
     }
 }
 
-STATIC mp_obj_t esp_wifi_mode(mp_uint_t n_args, const mp_obj_t *args) {
-    if (n_args == 0) {
-        return mp_obj_new_int(wifi_get_opmode());
+STATIC mp_obj_t esp_osdebug(mp_obj_t val) {
+    if (val == mp_const_none) {
+        uart_os_config(-1);
     } else {
-        wifi_set_opmode(mp_obj_get_int(args[0]));
-        return mp_const_none;
+        uart_os_config(mp_obj_get_int(val));
     }
+    return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_wifi_mode_obj, 0, 1, esp_wifi_mode);
-
-STATIC mp_obj_t esp_phy_mode(mp_uint_t n_args, const mp_obj_t *args) {
-    if (n_args == 0) {
-        return mp_obj_new_int(wifi_get_phy_mode());
-    } else {
-        wifi_set_phy_mode(mp_obj_get_int(args[0]));
-        return mp_const_none;
-    }
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_phy_mode_obj, 0, 1, esp_phy_mode);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp_osdebug_obj, esp_osdebug);
 
 STATIC mp_obj_t esp_sleep_type(mp_uint_t n_args, const mp_obj_t *args) {
     if (n_args == 0) {
@@ -538,26 +536,6 @@ STATIC mp_obj_t esp_sleep_type(mp_uint_t n_args, const mp_obj_t *args) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_sleep_type_obj, 0, 1, esp_sleep_type);
 
-STATIC mp_obj_t esp_mac(mp_uint_t n_args, const mp_obj_t *args) {
-    uint8_t mac[6];
-    if (n_args == 0) {
-        wifi_get_macaddr(STATION_IF, mac);
-        return mp_obj_new_bytes(mac, sizeof(mac));
-    } else {
-        mp_buffer_info_t bufinfo;
-        mp_get_buffer_raise(args[0], &bufinfo, MP_BUFFER_READ);
-
-        if (bufinfo.len != 6) {
-            nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError,
-                "invalid buffer length"));
-        }
-
-        wifi_set_macaddr(STATION_IF, bufinfo.buf);
-        return mp_const_none;
-    }
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_mac_obj, 0, 1, esp_mac);
-
 STATIC mp_obj_t esp_deepsleep(mp_uint_t n_args, const mp_obj_t *args) {
     system_deep_sleep(n_args > 0 ? mp_obj_get_int(args[0]) : 0);
     return mp_const_none;
@@ -569,26 +547,106 @@ STATIC mp_obj_t esp_flash_id() {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_0(esp_flash_id_obj, esp_flash_id);
 
+STATIC mp_obj_t esp_flash_read(mp_obj_t offset_in, mp_obj_t len_or_buf_in) {
+    mp_int_t offset = mp_obj_get_int(offset_in);
+
+    mp_int_t len;
+    byte *buf;
+    bool alloc_buf = MP_OBJ_IS_INT(len_or_buf_in);
+
+    if (alloc_buf) {
+        len = mp_obj_get_int(len_or_buf_in);
+        buf = m_new(byte, len);
+    } else {
+        mp_buffer_info_t bufinfo;
+        mp_get_buffer_raise(len_or_buf_in, &bufinfo, MP_BUFFER_WRITE);
+        len = bufinfo.len;
+        buf = bufinfo.buf;
+    }
+
+    // We know that allocation will be 4-byte aligned for sure
+    SpiFlashOpResult res = spi_flash_read(offset, (uint32_t*)buf, len);
+    if (res == SPI_FLASH_RESULT_OK) {
+        if (alloc_buf) {
+            return mp_obj_new_bytes(buf, len);
+        }
+        return mp_const_none;
+    }
+    if (alloc_buf) {
+        m_del(byte, buf, len);
+    }
+    nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(res == SPI_FLASH_RESULT_TIMEOUT ? ETIMEDOUT : EIO)));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(esp_flash_read_obj, esp_flash_read);
+
+STATIC mp_obj_t esp_flash_write(mp_obj_t offset_in, const mp_obj_t buf_in) {
+    mp_int_t offset = mp_obj_get_int(offset_in);
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(buf_in, &bufinfo, MP_BUFFER_READ);
+    if (bufinfo.len & 0x3) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, "len must be multiple of 4"));
+    }
+    SpiFlashOpResult res = spi_flash_write(offset, bufinfo.buf, bufinfo.len);
+    if (res == SPI_FLASH_RESULT_OK) {
+        return mp_const_none;
+    }
+    nlr_raise(mp_obj_new_exception_arg1(
+        &mp_type_OSError,
+        MP_OBJ_NEW_SMALL_INT(res == SPI_FLASH_RESULT_TIMEOUT ? ETIMEDOUT : EIO)));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(esp_flash_write_obj, esp_flash_write);
+
+STATIC mp_obj_t esp_flash_erase(mp_obj_t sector_in) {
+    mp_int_t sector = mp_obj_get_int(sector_in);
+    SpiFlashOpResult res = spi_flash_erase_sector(sector);
+    if (res == SPI_FLASH_RESULT_OK) {
+        return mp_const_none;
+    }
+    nlr_raise(mp_obj_new_exception_arg1(
+        &mp_type_OSError,
+        MP_OBJ_NEW_SMALL_INT(res == SPI_FLASH_RESULT_TIMEOUT ? ETIMEDOUT : EIO)));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp_flash_erase_obj, esp_flash_erase);
+
+STATIC mp_obj_t esp_neopixel_write_(mp_obj_t pin, mp_obj_t buf, mp_obj_t is800k) {
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(buf, &bufinfo, MP_BUFFER_READ);
+    esp_neopixel_write(mp_obj_get_pin_obj(pin)->phys_port,
+        (uint8_t*)bufinfo.buf, bufinfo.len, mp_obj_is_true(is800k));
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(esp_neopixel_write_obj, esp_neopixel_write_);
+
+STATIC mp_obj_t esp_freemem() {
+    return MP_OBJ_NEW_SMALL_INT(system_get_free_heap_size());
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(esp_freemem_obj, esp_freemem);
+
+STATIC mp_obj_t esp_meminfo() {
+    system_print_meminfo();
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(esp_meminfo_obj, esp_meminfo);
+
 STATIC const mp_map_elem_t esp_module_globals_table[] = {
     { MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_esp) },
 
-    { MP_OBJ_NEW_QSTR(MP_QSTR_mac), (mp_obj_t)&esp_mac_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_getaddrinfo), (mp_obj_t)&esp_getaddrinfo_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_wifi_mode), (mp_obj_t)&esp_wifi_mode_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_phy_mode), (mp_obj_t)&esp_phy_mode_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_osdebug), (mp_obj_t)&esp_osdebug_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_sleep_type), (mp_obj_t)&esp_sleep_type_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_deepsleep), (mp_obj_t)&esp_deepsleep_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_flash_id), (mp_obj_t)&esp_flash_id_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_flash_read), (mp_obj_t)&esp_flash_read_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_flash_write), (mp_obj_t)&esp_flash_write_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_flash_erase), (mp_obj_t)&esp_flash_erase_obj },
+    #if MODESP_ESPCONN
     { MP_OBJ_NEW_QSTR(MP_QSTR_socket), (mp_obj_t)&esp_socket_type },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_getaddrinfo), (mp_obj_t)&esp_getaddrinfo_obj },
+    #endif
+    { MP_OBJ_NEW_QSTR(MP_QSTR_neopixel_write), (mp_obj_t)&esp_neopixel_write_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_freemem), (mp_obj_t)&esp_freemem_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_meminfo), (mp_obj_t)&esp_meminfo_obj },
 
 #if MODESP_INCLUDE_CONSTANTS
-    { MP_OBJ_NEW_QSTR(MP_QSTR_MODE_11B),
-        MP_OBJ_NEW_SMALL_INT(PHY_MODE_11B) },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_MODE_11G),
-        MP_OBJ_NEW_SMALL_INT(PHY_MODE_11G) },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_MODE_11N),
-        MP_OBJ_NEW_SMALL_INT(PHY_MODE_11N) },
-
     { MP_OBJ_NEW_QSTR(MP_QSTR_SLEEP_NONE),
         MP_OBJ_NEW_SMALL_INT(NONE_SLEEP_T) },
     { MP_OBJ_NEW_QSTR(MP_QSTR_SLEEP_LIGHT),

esp8266/modmachine.c

@@ -0,0 +1,174 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2013-2015 Damien P. George
+ * Copyright (c) 2016 Paul Sokolovsky
+ *
+ * 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.
+ */
+
+#include <stdint.h>
+
+#include "py/obj.h"
+#include "py/runtime.h"
+#include "extmod/machine_mem.h"
+#include "utils.h"
+#include "modpyb.h"
+
+#include "os_type.h"
+#include "osapi.h"
+#include "etshal.h"
+#include "user_interface.h"
+
+#if MICROPY_PY_MACHINE
+
+STATIC mp_obj_t machine_freq(mp_uint_t n_args, const mp_obj_t *args) {
+    if (n_args == 0) {
+        // get
+        return mp_obj_new_int(system_get_cpu_freq() * 1000000);
+    } else {
+        // set
+        mp_int_t freq = mp_obj_get_int(args[0]) / 1000000;
+        if (freq != 80 && freq != 160) {
+            nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError,
+                    "frequency can only be either 80Mhz or 160MHz"));
+        }
+        system_update_cpu_freq(freq);
+        return mp_const_none;
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_freq_obj, 0, 1, machine_freq);
+
+STATIC mp_obj_t machine_reset(void) {
+    system_restart();
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(machine_reset_obj, machine_reset);
+
+STATIC mp_obj_t machine_unique_id(void) {
+    uint32_t id = system_get_chip_id();
+    return mp_obj_new_bytes((byte*)&id, sizeof(id));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(machine_unique_id_obj, machine_unique_id);
+
+typedef struct _esp_timer_obj_t {
+    mp_obj_base_t base;
+    os_timer_t timer;
+    mp_obj_t callback;
+} esp_timer_obj_t;
+
+const mp_obj_type_t esp_timer_type;
+
+STATIC void esp_timer_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    esp_timer_obj_t *self = self_in;
+    mp_printf(print, "Timer(%p)", &self->timer);
+}
+
+STATIC mp_obj_t esp_timer_make_new(const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
+    mp_arg_check_num(n_args, n_kw, 1, 1, false);
+    esp_timer_obj_t *tim = m_new_obj(esp_timer_obj_t);
+    tim->base.type = &esp_timer_type;
+    return tim;
+}
+
+STATIC void esp_timer_cb(void *arg) {
+    esp_timer_obj_t *self = arg;
+    call_function_1_protected(self->callback, self);
+}
+
+STATIC mp_obj_t esp_timer_init_helper(esp_timer_obj_t *self, mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    static const mp_arg_t allowed_args[] = {
+//        { MP_QSTR_freq,         MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+        { MP_QSTR_period,       MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0xffffffff} },
+        { MP_QSTR_mode,         MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 1} },
+        { MP_QSTR_callback,     MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+    };
+
+    // parse args
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    self->callback = args[2].u_obj;
+    // Be sure to disarm timer before making any changes
+    os_timer_disarm(&self->timer);
+    os_timer_setfn(&self->timer, esp_timer_cb, self);
+    os_timer_arm(&self->timer, args[0].u_int, args[1].u_int);
+
+    return mp_const_none;
+}
+
+STATIC mp_obj_t esp_timer_init(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
+    return esp_timer_init_helper(args[0], n_args - 1, args + 1, kw_args);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(esp_timer_init_obj, 1, esp_timer_init);
+
+STATIC mp_obj_t esp_timer_deinit(mp_obj_t self_in) {
+    esp_timer_obj_t *self = self_in;
+    os_timer_disarm(&self->timer);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp_timer_deinit_obj, esp_timer_deinit);
+
+STATIC const mp_map_elem_t esp_timer_locals_dict_table[] = {
+    { MP_OBJ_NEW_QSTR(MP_QSTR_deinit), (mp_obj_t)&esp_timer_deinit_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_init), (mp_obj_t)&esp_timer_init_obj },
+//    { MP_OBJ_NEW_QSTR(MP_QSTR_callback), (mp_obj_t)&esp_timer_callback_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_ONE_SHOT), MP_OBJ_NEW_SMALL_INT(false) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_PERIODIC), MP_OBJ_NEW_SMALL_INT(true) },
+};
+STATIC MP_DEFINE_CONST_DICT(esp_timer_locals_dict, esp_timer_locals_dict_table);
+
+const mp_obj_type_t esp_timer_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_Timer,
+    .print = esp_timer_print,
+    .make_new = esp_timer_make_new,
+    .locals_dict = (mp_obj_t)&esp_timer_locals_dict,
+};
+
+STATIC const mp_rom_map_elem_t machine_module_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_umachine) },
+    { MP_ROM_QSTR(MP_QSTR_mem8), MP_ROM_PTR(&machine_mem8_obj) },
+    { MP_ROM_QSTR(MP_QSTR_mem16), MP_ROM_PTR(&machine_mem16_obj) },
+    { MP_ROM_QSTR(MP_QSTR_mem32), MP_ROM_PTR(&machine_mem32_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_freq), MP_ROM_PTR(&machine_freq_obj) },
+    { MP_ROM_QSTR(MP_QSTR_reset), MP_ROM_PTR(&machine_reset_obj) },
+    { MP_ROM_QSTR(MP_QSTR_unique_id), MP_ROM_PTR(&machine_unique_id_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_Timer), MP_ROM_PTR(&esp_timer_type) },
+    { MP_ROM_QSTR(MP_QSTR_Pin), MP_ROM_PTR(&pyb_pin_type) },
+    { MP_ROM_QSTR(MP_QSTR_PWM), MP_ROM_PTR(&pyb_pwm_type) },
+    { MP_ROM_QSTR(MP_QSTR_ADC), MP_ROM_PTR(&pyb_adc_type) },
+    { MP_ROM_QSTR(MP_QSTR_UART), MP_ROM_PTR(&pyb_uart_type) },
+    { MP_ROM_QSTR(MP_QSTR_I2C), MP_ROM_PTR(&pyb_i2c_type) },
+    { MP_ROM_QSTR(MP_QSTR_SPI), MP_ROM_PTR(&pyb_spi_type) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(machine_module_globals, machine_module_globals_table);
+
+const mp_obj_module_t mp_module_machine = {
+    .base = { &mp_type_module },
+    .name = MP_QSTR_umachine,
+    .globals = (mp_obj_dict_t*)&machine_module_globals,
+};
+
+#endif // MICROPY_PY_MACHINE

esp8266/modnetwork.c

@@ -32,30 +32,77 @@
 #include "py/nlr.h"
 #include "py/objlist.h"
 #include "py/runtime.h"
+#include "py/mphal.h"
 #include "netutils.h"
 #include "queue.h"
 #include "user_interface.h"
 #include "espconn.h"
-#include "ip_addr.h"
 #include "spi_flash.h"
-#include "utils.h"
+#include "ets_alt_task.h"
+
+#define MODNETWORK_INCLUDE_CONSTANTS (1)
+
+typedef struct _wlan_if_obj_t {
+    mp_obj_base_t base;
+    int if_id;
+} wlan_if_obj_t;
 
 void error_check(bool status, const char *msg);
-extern const mp_obj_module_t network_module;
+const mp_obj_type_t wlan_if_type;
 
-STATIC mp_obj_t get_module() {
-    return (mp_obj_t)&network_module;
+STATIC const wlan_if_obj_t wlan_objs[] = {
+    {{&wlan_if_type}, STATION_IF},
+    {{&wlan_if_type}, SOFTAP_IF},
+};
+
+STATIC void require_if(mp_obj_t wlan_if, int if_no) {
+    wlan_if_obj_t *self = MP_OBJ_TO_PTR(wlan_if);
+    if (self->if_id != if_no) {
+        error_check(false, if_no == STATION_IF ? "STA required" : "AP required");
+    }
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_0(get_module_obj, get_module);
+
+STATIC mp_obj_t get_wlan(mp_uint_t n_args, const mp_obj_t *args) {
+    int idx = 0;
+    if (n_args > 0) {
+        idx = mp_obj_get_int(args[0]);
+    }
+    return MP_OBJ_FROM_PTR(&wlan_objs[idx]);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(get_wlan_obj, 0, 1, get_wlan);
+
+STATIC mp_obj_t esp_active(mp_uint_t n_args, const mp_obj_t *args) {
+    wlan_if_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    uint32_t mode = wifi_get_opmode();
+    if (n_args > 1) {
+        int mask = self->if_id == STATION_IF ? STATION_MODE : SOFTAP_MODE;
+        if (mp_obj_get_int(args[1]) != 0) {
+            mode |= mask;
+        } else {
+            mode &= ~mask;
+        }
+        error_check(wifi_set_opmode(mode), "Cannot update i/f status");
+        return mp_const_none;
+    }
+
+    // Get active status
+    if (self->if_id == STATION_IF) {
+        return mp_obj_new_bool(mode & STATION_MODE);
+    } else {
+        return mp_obj_new_bool(mode & SOFTAP_MODE);
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_active_obj, 1, 2, esp_active);
 
 STATIC mp_obj_t esp_connect(mp_uint_t n_args, const mp_obj_t *args) {
+    require_if(args[0], STATION_IF);
     struct station_config config = {{0}};
     mp_uint_t len;
     const char *p;
 
-    p = mp_obj_str_get_data(args[0], &len);
-    memcpy(config.ssid, p, len);
     p = mp_obj_str_get_data(args[1], &len);
+    memcpy(config.ssid, p, len);
+    p = mp_obj_str_get_data(args[2], &len);
     memcpy(config.password, p, len);
 
     error_check(wifi_station_set_config(&config), "Cannot set STA config");
@@ -63,24 +110,33 @@ STATIC mp_obj_t esp_connect(mp_uint_t n_args, const mp_obj_t *args) {
 
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_connect_obj, 2, 6, esp_connect);
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_connect_obj, 3, 7, esp_connect);
 
-STATIC mp_obj_t esp_disconnect() {
+STATIC mp_obj_t esp_disconnect(mp_obj_t self_in) {
+    require_if(self_in, STATION_IF);
     error_check(wifi_station_disconnect(), "Cannot disconnect from AP");
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_0(esp_disconnect_obj, esp_disconnect);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp_disconnect_obj, esp_disconnect);
 
-#define MODNETWORK_INCLUDE_CONSTANTS (1)
-
-STATIC mp_obj_t esp_status() {
-    return MP_OBJ_NEW_SMALL_INT(wifi_station_get_connect_status());
+STATIC mp_obj_t esp_status(mp_obj_t self_in) {
+    wlan_if_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    if (self->if_id == STATION_IF) {
+        return MP_OBJ_NEW_SMALL_INT(wifi_station_get_connect_status());
+    }
+    return MP_OBJ_NEW_SMALL_INT(-1);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_0(esp_status_obj, esp_status);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp_status_obj, esp_status);
+
+STATIC mp_obj_t *esp_scan_list = NULL;
 
 STATIC void esp_scan_cb(scaninfo *si, STATUS status) {
-    struct bss_info *bs;
-    if (si->pbss) {
+    if (esp_scan_list == NULL) {
+        // called unexpectedly
+        return;
+    }
+    if (si->pbss && status == 0) {
+        struct bss_info *bs;
         STAILQ_FOREACH(bs, si->pbss, next) {
             mp_obj_tuple_t *t = mp_obj_new_tuple(6, NULL);
             t->items[0] = mp_obj_new_bytes(bs->ssid, strlen((char*)bs->ssid));
@@ -89,48 +145,205 @@ STATIC void esp_scan_cb(scaninfo *si, STATUS status) {
             t->items[3] = MP_OBJ_NEW_SMALL_INT(bs->rssi);
             t->items[4] = MP_OBJ_NEW_SMALL_INT(bs->authmode);
             t->items[5] = MP_OBJ_NEW_SMALL_INT(bs->is_hidden);
-            call_function_1_protected(MP_STATE_PORT(scan_cb_obj), t);
+            mp_obj_list_append(*esp_scan_list, MP_OBJ_FROM_PTR(t));
         }
+    } else {
+        // indicate error
+        *esp_scan_list = MP_OBJ_NULL;
     }
+    esp_scan_list = NULL;
 }
 
-STATIC mp_obj_t esp_scan(mp_obj_t cb_in) {
-    MP_STATE_PORT(scan_cb_obj) = cb_in;
+STATIC mp_obj_t esp_scan(mp_obj_t self_in) {
     if (wifi_get_opmode() == SOFTAP_MODE) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, 
-            "Scan not supported in AP mode"));
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError,
+            "scan unsupported in AP mode"));
     }
+    mp_obj_t list = mp_obj_new_list(0, NULL);
+    esp_scan_list = &list;
     wifi_station_scan(NULL, (scan_done_cb_t)esp_scan_cb);
-    return mp_const_none;
+    ETS_POLL_WHILE(esp_scan_list != NULL);
+    if (list == MP_OBJ_NULL) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "scan failed"));
+    }
+    return list;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp_scan_obj, esp_scan);
 
 /// \method isconnected()
 /// Return True if connected to an AP and an IP address has been assigned,
 ///     false otherwise.
-STATIC mp_obj_t esp_isconnected() {
-    if (wifi_station_get_connect_status() == STATION_GOT_IP) {
-        return mp_const_true;
+STATIC mp_obj_t esp_isconnected(mp_obj_t self_in) {
+    wlan_if_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    if (self->if_id == STATION_IF) {
+        if (wifi_station_get_connect_status() == STATION_GOT_IP) {
+            return mp_const_true;
+        }
+    } else {
+        if (wifi_softap_get_station_num() > 0) {
+            return mp_const_true;
+        }
     }
     return mp_const_false;
 }
 
-STATIC MP_DEFINE_CONST_FUN_OBJ_0(esp_isconnected_obj, esp_isconnected);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp_isconnected_obj, esp_isconnected);
 
-STATIC const mp_map_elem_t mp_module_network_globals_table[] = {
-    { MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_network) },
-    // MicroPython "network" module interface requires it to contains classes
-    // to instantiate. But as we have just a static network interace,
-    // use module as a "class", and just make all methods module-global
-    // functions.
-    { MP_OBJ_NEW_QSTR(MP_QSTR_WLAN), (mp_obj_t)&get_module_obj },
+STATIC mp_obj_t esp_mac(mp_uint_t n_args, const mp_obj_t *args) {
+    wlan_if_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    uint8_t mac[6];
+    if (n_args == 1) {
+        wifi_get_macaddr(self->if_id, mac);
+        return mp_obj_new_bytes(mac, sizeof(mac));
+    } else {
+        mp_buffer_info_t bufinfo;
+        mp_get_buffer_raise(args[1], &bufinfo, MP_BUFFER_READ);
+
+        if (bufinfo.len != 6) {
+            nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError,
+                "invalid buffer length"));
+        }
+
+        wifi_set_macaddr(self->if_id, bufinfo.buf);
+        return mp_const_none;
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_mac_obj, 1, 2, esp_mac);
+
+STATIC mp_obj_t esp_ifconfig(mp_obj_t self_in) {
+    wlan_if_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    struct ip_info info;
+    wifi_get_ip_info(self->if_id, &info);
+    mp_obj_t ifconfig[4] = {
+            netutils_format_ipv4_addr((uint8_t*)&info.ip, NETUTILS_BIG),
+            netutils_format_ipv4_addr((uint8_t*)&info.netmask, NETUTILS_BIG),
+            netutils_format_ipv4_addr((uint8_t*)&info.gw, NETUTILS_BIG),
+            MP_OBJ_NEW_QSTR(MP_QSTR_), // no DNS server
+    };
+    return mp_obj_new_tuple(4, ifconfig);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp_ifconfig_obj, esp_ifconfig);
+
+STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
+    if (n_args != 1 && kwargs->used != 0) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError,
+            "either pos or kw args are allowed"));
+    }
+
+    wlan_if_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    union {
+        struct station_config sta;
+        struct softap_config ap;
+    } cfg;
+
+    if (self->if_id == STATION_IF) {
+        error_check(wifi_station_get_config(&cfg.sta), "can't get STA config");
+    } else {
+        error_check(wifi_softap_get_config(&cfg.ap), "can't get AP config");
+    }
+
+    if (kwargs->used != 0) {
+
+        for (mp_uint_t i = 0; i < kwargs->alloc; i++) {
+            if (MP_MAP_SLOT_IS_FILLED(kwargs, i)) {
+                #define QS(x) (uintptr_t)MP_OBJ_NEW_QSTR(x)
+                switch ((uintptr_t)kwargs->table[i].key) {
+                    case QS(MP_QSTR_essid): {
+                        mp_uint_t len;
+                        const char *s = mp_obj_str_get_data(kwargs->table[i].value, &len);
+                        len = MIN(len, sizeof(cfg.ap.ssid));
+                        memcpy(cfg.ap.ssid, s, len);
+                        cfg.ap.ssid_len = len;
+                        break;
+                    }
+                    default:
+                        goto unknown;
+                }
+                #undef QS
+            }
+        }
+
+        if (self->if_id == STATION_IF) {
+            error_check(wifi_station_set_config(&cfg.sta), "can't set STA config");
+        } else {
+            error_check(wifi_softap_set_config(&cfg.ap), "can't set AP config");
+        }
+
+        return mp_const_none;
+    }
+
+    // Get config
+
+    if (n_args != 2) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError,
+            "can query only one param"));
+    }
+
+    #define QS(x) (uintptr_t)MP_OBJ_NEW_QSTR(x)
+    switch ((uintptr_t)args[1]) {
+        case QS(MP_QSTR_essid):
+            return mp_obj_new_str((char*)cfg.ap.ssid, cfg.ap.ssid_len, false);
+    }
+    #undef QS
+
+unknown:
+    nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError,
+        "unknown config param"));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(esp_config_obj, 1, esp_config);
+
+STATIC const mp_map_elem_t wlan_if_locals_dict_table[] = {
+    { MP_OBJ_NEW_QSTR(MP_QSTR_active), (mp_obj_t)&esp_active_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_connect), (mp_obj_t)&esp_connect_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_disconnect), (mp_obj_t)&esp_disconnect_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_status), (mp_obj_t)&esp_status_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_scan), (mp_obj_t)&esp_scan_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_isconnected), (mp_obj_t)&esp_isconnected_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_mac), (mp_obj_t)&esp_mac_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_config), (mp_obj_t)&esp_config_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_ifconfig), (mp_obj_t)&esp_ifconfig_obj },
+};
+
+STATIC MP_DEFINE_CONST_DICT(wlan_if_locals_dict, wlan_if_locals_dict_table);
+
+const mp_obj_type_t wlan_if_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_WLAN,
+    .locals_dict = (mp_obj_t)&wlan_if_locals_dict,
+};
+
+STATIC mp_obj_t esp_wifi_mode(mp_uint_t n_args, const mp_obj_t *args) {
+    if (n_args == 0) {
+        return mp_obj_new_int(wifi_get_opmode());
+    } else {
+        wifi_set_opmode(mp_obj_get_int(args[0]));
+        return mp_const_none;
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_wifi_mode_obj, 0, 1, esp_wifi_mode);
+
+STATIC mp_obj_t esp_phy_mode(mp_uint_t n_args, const mp_obj_t *args) {
+    if (n_args == 0) {
+        return mp_obj_new_int(wifi_get_phy_mode());
+    } else {
+        wifi_set_phy_mode(mp_obj_get_int(args[0]));
+        return mp_const_none;
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_phy_mode_obj, 0, 1, esp_phy_mode);
+
+STATIC const mp_map_elem_t mp_module_network_globals_table[] = {
+    { MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_network) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_WLAN), (mp_obj_t)&get_wlan_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_wifi_mode), (mp_obj_t)&esp_wifi_mode_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_phy_mode), (mp_obj_t)&esp_phy_mode_obj },
 
 #if MODNETWORK_INCLUDE_CONSTANTS
+    { MP_OBJ_NEW_QSTR(MP_QSTR_STA_IF),
+        MP_OBJ_NEW_SMALL_INT(STATION_IF)},
+    { MP_OBJ_NEW_QSTR(MP_QSTR_AP_IF),
+        MP_OBJ_NEW_SMALL_INT(SOFTAP_IF)},
+
     { MP_OBJ_NEW_QSTR(MP_QSTR_STAT_IDLE),
         MP_OBJ_NEW_SMALL_INT(STATION_IDLE)},
     { MP_OBJ_NEW_QSTR(MP_QSTR_STAT_CONNECTING),
@@ -143,6 +356,13 @@ STATIC const mp_map_elem_t mp_module_network_globals_table[] = {
         MP_OBJ_NEW_SMALL_INT(STATION_CONNECT_FAIL)},
     { MP_OBJ_NEW_QSTR(MP_QSTR_STAT_GOT_IP),
         MP_OBJ_NEW_SMALL_INT(STATION_GOT_IP)},
+
+    { MP_OBJ_NEW_QSTR(MP_QSTR_MODE_11B),
+        MP_OBJ_NEW_SMALL_INT(PHY_MODE_11B) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_MODE_11G),
+        MP_OBJ_NEW_SMALL_INT(PHY_MODE_11G) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_MODE_11N),
+        MP_OBJ_NEW_SMALL_INT(PHY_MODE_11N) },
 #endif
 };
 

esp8266/modonewire.c

@@ -0,0 +1,185 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 Damien P. George
+ *
+ * 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.
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+
+#include "etshal.h"
+#include "user_interface.h"
+#include "py/obj.h"
+#include "py/mphal.h"
+#include "modpyb.h"
+
+STATIC uint32_t disable_irq(void) {
+    ets_intr_lock();
+    return 0;
+}
+
+STATIC void enable_irq(uint32_t i) {
+    ets_intr_unlock();
+}
+
+STATIC void mp_hal_delay_us_no_irq(uint32_t us) {
+    uint32_t start = system_get_time();
+    while (system_get_time() - start < us) {
+    }
+}
+
+#define DELAY_US mp_hal_delay_us_no_irq
+
+#define TIMING_RESET1 (0)
+#define TIMING_RESET2 (1)
+#define TIMING_RESET3 (2)
+#define TIMING_READ1 (3)
+#define TIMING_READ2 (4)
+#define TIMING_READ3 (5)
+#define TIMING_WRITE1 (6)
+#define TIMING_WRITE2 (7)
+#define TIMING_WRITE3 (8)
+
+static int timings[] = {480, 40, 420, 5, 5, 40, 10, 50, 10};
+
+STATIC mp_obj_t onewire_timings(mp_obj_t timings_in) {
+    mp_obj_t *items;
+    mp_obj_get_array_fixed_n(timings_in, 9, &items);
+    for (int i = 0; i < 9; ++i) {
+        timings[i] = mp_obj_get_int(items[i]);
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(onewire_timings_obj, onewire_timings);
+
+STATIC mp_obj_t onewire_reset(mp_obj_t pin_in) {
+    uint pin = mp_obj_get_pin(pin_in);
+    pin_set(pin, 0);
+    DELAY_US(timings[TIMING_RESET1]);
+    uint32_t i = disable_irq();
+    pin_set(pin, 1);
+    DELAY_US(timings[TIMING_RESET2]);
+    int status = !pin_get(pin);
+    enable_irq(i);
+    DELAY_US(timings[TIMING_RESET3]);
+    return mp_obj_new_bool(status);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(onewire_reset_obj, onewire_reset);
+
+STATIC int _onewire_readbit(uint pin) {
+    pin_set(pin, 1);
+    uint32_t i = disable_irq();
+    pin_set(pin, 0);
+    DELAY_US(timings[TIMING_READ1]);
+    pin_set(pin, 1);
+    DELAY_US(timings[TIMING_READ2]);
+    int value = pin_get(pin);
+    enable_irq(i);
+    DELAY_US(timings[TIMING_READ3]);
+    return value;
+}
+
+STATIC mp_obj_t onewire_readbit(mp_obj_t pin_in) {
+    return MP_OBJ_NEW_SMALL_INT(_onewire_readbit(mp_obj_get_pin(pin_in)));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(onewire_readbit_obj, onewire_readbit);
+
+STATIC mp_obj_t onewire_readbyte(mp_obj_t pin_in) {
+    uint pin = mp_obj_get_pin(pin_in);
+    uint8_t value = 0;
+    for (int i = 0; i < 8; ++i) {
+        value |= _onewire_readbit(pin) << i;
+    }
+    return MP_OBJ_NEW_SMALL_INT(value);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(onewire_readbyte_obj, onewire_readbyte);
+
+STATIC void _onewire_writebit(uint pin, int value) {
+    uint32_t i = disable_irq();
+    pin_set(pin, 0);
+    DELAY_US(timings[TIMING_WRITE1]);
+    pin_set(pin, value);
+    DELAY_US(timings[TIMING_WRITE2]);
+    pin_set(pin, 1);
+    DELAY_US(timings[TIMING_WRITE3]);
+    enable_irq(i);
+}
+
+STATIC mp_obj_t onewire_writebit(mp_obj_t pin_in, mp_obj_t value_in) {
+    _onewire_writebit(mp_obj_get_pin(pin_in), mp_obj_get_int(value_in));
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(onewire_writebit_obj, onewire_writebit);
+
+STATIC mp_obj_t onewire_writebyte(mp_obj_t pin_in, mp_obj_t value_in) {
+    uint pin = mp_obj_get_pin(pin_in);
+    int value = mp_obj_get_int(value_in);
+    for (int i = 0; i < 8; ++i) {
+        _onewire_writebit(pin, value & 1);
+        value >>= 1;
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(onewire_writebyte_obj, onewire_writebyte);
+
+STATIC mp_obj_t onewire_crc8(mp_obj_t data) {
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(data, &bufinfo, MP_BUFFER_READ);
+    uint8_t crc = 0;
+    for (size_t i = 0; i < bufinfo.len; ++i) {
+        uint8_t byte = ((uint8_t*)bufinfo.buf)[i];
+        for (int b = 0; b < 8; ++b) {
+            uint8_t fb_bit = (crc ^ byte) & 0x01;
+            if (fb_bit == 0x01) {
+                crc = crc ^ 0x18;
+            }
+            crc = (crc >> 1) & 0x7f;
+            if (fb_bit == 0x01) {
+                crc = crc | 0x80;
+            }
+            byte = byte >> 1;
+        }
+    }
+    return MP_OBJ_NEW_SMALL_INT(crc);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(onewire_crc8_obj, onewire_crc8);
+
+STATIC const mp_map_elem_t onewire_module_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_onewire) },
+
+    { MP_ROM_QSTR(MP_QSTR_timings), MP_ROM_PTR((mp_obj_t)&onewire_timings_obj) },
+    { MP_ROM_QSTR(MP_QSTR_reset), MP_ROM_PTR((mp_obj_t)&onewire_reset_obj) },
+    { MP_ROM_QSTR(MP_QSTR_readbit), MP_ROM_PTR((mp_obj_t)&onewire_readbit_obj) },
+    { MP_ROM_QSTR(MP_QSTR_readbyte), MP_ROM_PTR((mp_obj_t)&onewire_readbyte_obj) },
+    { MP_ROM_QSTR(MP_QSTR_writebit), MP_ROM_PTR((mp_obj_t)&onewire_writebit_obj) },
+    { MP_ROM_QSTR(MP_QSTR_writebyte), MP_ROM_PTR((mp_obj_t)&onewire_writebyte_obj) },
+    { MP_ROM_QSTR(MP_QSTR_crc8), MP_ROM_PTR((mp_obj_t)&onewire_crc8_obj) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(onewire_module_globals, onewire_module_globals_table);
+
+const mp_obj_module_t onewire_module = {
+    .base = { &mp_type_module },
+    .name = MP_QSTR_onewire,
+    .globals = (mp_obj_dict_t*)&onewire_module_globals,
+};

esp8266/modpyb.c

@@ -77,23 +77,6 @@ STATIC mp_obj_t pyb_info(mp_uint_t n_args, const mp_obj_t *args) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_info_obj, 0, 1, pyb_info);
 
-STATIC mp_obj_t pyb_freq(mp_uint_t n_args, const mp_obj_t *args) {
-    if (n_args == 0) {
-        // get
-        return mp_obj_new_int(system_get_cpu_freq() * 1000000);
-    } else {
-        // set
-        mp_int_t freq = mp_obj_get_int(args[0]) / 1000000;
-        if (freq != 80 && freq != 160) {
-            nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError,
-                    "frequency can only be either 80Mhz or 160MHz"));
-        }
-        system_update_cpu_freq(freq);
-        return mp_const_none;
-    }
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_freq_obj, 0, 1, pyb_freq);
-
 STATIC mp_obj_t pyb_sync(void) {
     //storage_flush();
     return mp_const_none;
@@ -142,23 +125,10 @@ STATIC mp_obj_t pyb_udelay(mp_obj_t usec_in) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_udelay_obj, pyb_udelay);
 
-STATIC mp_obj_t pyb_hard_reset(void) {
-    system_restart();
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_0(pyb_hard_reset_obj, pyb_hard_reset);
-
-STATIC mp_obj_t pyb_unique_id(void) {
-    uint32_t id = system_get_chip_id();
-    return mp_obj_new_bytes((byte *)&id, sizeof(id));
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_0(pyb_unique_id_obj, pyb_unique_id);
-
 STATIC const mp_map_elem_t pyb_module_globals_table[] = {
     { MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_pyb) },
 
     { MP_OBJ_NEW_QSTR(MP_QSTR_info), (mp_obj_t)&pyb_info_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_freq), (mp_obj_t)&pyb_freq_obj },
 
     { MP_OBJ_NEW_QSTR(MP_QSTR_millis), (mp_obj_t)&pyb_millis_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_elapsed_millis), (mp_obj_t)&pyb_elapsed_millis_obj },
@@ -167,7 +137,6 @@ STATIC const mp_map_elem_t pyb_module_globals_table[] = {
     { MP_OBJ_NEW_QSTR(MP_QSTR_delay), (mp_obj_t)&pyb_delay_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_udelay), (mp_obj_t)&pyb_udelay_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_sync), (mp_obj_t)&pyb_sync_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_hard_reset), (mp_obj_t)&pyb_hard_reset_obj },
 
     { MP_OBJ_NEW_QSTR(MP_QSTR_Pin), (mp_obj_t)&pyb_pin_type },
     { MP_OBJ_NEW_QSTR(MP_QSTR_ADC), (mp_obj_t)&pyb_adc_type },

esp8266/modpyb.h

@@ -1,3 +1,20 @@
 extern const mp_obj_type_t pyb_pin_type;
+extern const mp_obj_type_t pyb_pwm_type;
 extern const mp_obj_type_t pyb_adc_type;
 extern const mp_obj_type_t pyb_rtc_type;
+extern const mp_obj_type_t pyb_uart_type;
+extern const mp_obj_type_t pyb_i2c_type;
+extern const mp_obj_type_t pyb_spi_type;
+
+typedef struct _pyb_pin_obj_t {
+    mp_obj_base_t base;
+    uint16_t pin_id;
+    uint16_t phys_port;
+    uint32_t periph;
+    uint16_t func;
+} pyb_pin_obj_t;
+
+uint mp_obj_get_pin(mp_obj_t pin_in);
+pyb_pin_obj_t *mp_obj_get_pin_obj(mp_obj_t pin_in);
+int pin_get(uint pin);
+void pin_set(uint pin, int value);

esp8266/modpybadc.c

@@ -42,7 +42,7 @@ typedef struct _pyb_adc_obj_t {
 STATIC pyb_adc_obj_t pyb_adc_vdd3 = {{&pyb_adc_type}, true};
 STATIC pyb_adc_obj_t pyb_adc_adc = {{&pyb_adc_type}, false};
 
-STATIC mp_obj_t pyb_adc_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw,
+STATIC mp_obj_t pyb_adc_make_new(const mp_obj_type_t *type_in, mp_uint_t n_args, mp_uint_t n_kw,
     const mp_obj_t *args) {
     mp_arg_check_num(n_args, n_kw, 1, 1, false);
 

esp8266/modpybi2c.c

@@ -0,0 +1,323 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2016 Damien P. George
+ *
+ * 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.
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "ets_sys.h"
+#include "etshal.h"
+#include "osapi.h"
+#include "gpio.h"
+
+#include "py/runtime.h"
+#include "modpyb.h"
+
+typedef struct _pyb_i2c_obj_t {
+    mp_obj_base_t base;
+    pyb_pin_obj_t *scl;
+    pyb_pin_obj_t *sda;
+} pyb_i2c_obj_t;
+
+// these set the frequency of SCL
+#define mphal_i2c_wait_a() os_delay_us(2)
+#define mphal_i2c_wait_b() os_delay_us(1)
+
+STATIC void mphal_i2c_set_sda(pyb_i2c_obj_t *self, uint8_t sda) {
+    uint32_t port = self->sda->phys_port;
+    sda &= 0x01;
+    gpio_output_set(sda << port, (1 - sda) << port, 1 << port, 0);
+}
+
+STATIC void mphal_i2c_set_scl(pyb_i2c_obj_t *self, uint8_t scl) {
+    uint32_t port = self->scl->phys_port;
+    scl &= 0x01;
+    gpio_output_set(scl << port, (1 - scl) << port, 1 << port, 0);
+}
+
+STATIC int mphal_i2c_get_sda(pyb_i2c_obj_t *self) {
+    return GPIO_INPUT_GET(GPIO_ID_PIN(self->sda->phys_port));
+}
+
+STATIC void mphal_i2c_start(pyb_i2c_obj_t *self) {
+    mphal_i2c_set_sda(self, 1);
+    mphal_i2c_wait_a();
+    mphal_i2c_set_scl(self, 1);
+    mphal_i2c_wait_a();
+    mphal_i2c_set_sda(self, 0);
+    mphal_i2c_wait_a();
+}
+
+STATIC void mphal_i2c_stop(pyb_i2c_obj_t *self) {
+    mphal_i2c_wait_a();
+    mphal_i2c_set_sda(self, 0);
+    mphal_i2c_wait_a();
+    mphal_i2c_set_scl(self, 1);
+    mphal_i2c_wait_a();
+    mphal_i2c_set_sda(self, 1);
+    mphal_i2c_wait_a();
+}
+
+STATIC void mphal_i2c_init(pyb_i2c_obj_t *self, uint32_t freq) {
+    pyb_pin_obj_t *scl = self->scl;
+    pyb_pin_obj_t *sda = self->sda;
+
+    ETS_GPIO_INTR_DISABLE();
+    //ETS_INTR_LOCK();
+
+    PIN_FUNC_SELECT(sda->periph, sda->func);
+    PIN_FUNC_SELECT(scl->periph, scl->func);
+
+    GPIO_REG_WRITE(GPIO_PIN_ADDR(GPIO_ID_PIN(sda->phys_port)),
+        GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(sda->phys_port)))
+        | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_ENABLE)); // open drain
+    GPIO_REG_WRITE(GPIO_ENABLE_ADDRESS,
+        GPIO_REG_READ(GPIO_ENABLE_ADDRESS) | (1 << sda->phys_port));
+    GPIO_REG_WRITE(GPIO_PIN_ADDR(GPIO_ID_PIN(scl->phys_port)),
+        GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(scl->phys_port)))
+        | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_ENABLE)); // open drain
+    GPIO_REG_WRITE(GPIO_ENABLE_ADDRESS,
+        GPIO_REG_READ(GPIO_ENABLE_ADDRESS) | (1 << scl->phys_port));
+
+    mphal_i2c_set_scl(self, 1);
+    mphal_i2c_set_sda(self, 1);
+
+    ETS_GPIO_INTR_ENABLE();
+    //ETS_INTR_UNLOCK();
+
+    mphal_i2c_set_scl(self, 0);
+    mphal_i2c_wait_a();
+
+    // when SCL = 0, toggle SDA to clear up
+    mphal_i2c_set_sda(self, 0);
+    mphal_i2c_wait_a();
+    mphal_i2c_set_sda(self, 1);
+    mphal_i2c_wait_a();
+
+    // set data_cnt to max value
+    for (uint8_t i = 0; i < 28; i++) {
+        mphal_i2c_set_scl(self, 0);
+        mphal_i2c_wait_a();
+        mphal_i2c_set_scl(self, 1);
+        mphal_i2c_wait_a();
+    }
+
+    // reset all
+    mphal_i2c_stop(self);
+}
+
+STATIC int mphal_i2c_write_byte(pyb_i2c_obj_t *self, uint8_t val) {
+    uint8_t dat;
+    sint8 i;
+
+    mphal_i2c_wait_a();
+
+    mphal_i2c_set_scl(self, 0);
+    mphal_i2c_wait_a();
+
+    for (i = 7; i >= 0; i--) {
+        dat = val >> i;
+        mphal_i2c_set_sda(self, dat);
+        mphal_i2c_wait_a();
+        mphal_i2c_set_scl(self, 1);
+        mphal_i2c_wait_a();
+
+        if (i == 0) {
+            mphal_i2c_wait_b();
+        }
+
+        mphal_i2c_set_scl(self, 0);
+        mphal_i2c_wait_a();
+    }
+
+    mphal_i2c_set_sda(self, 1);
+    mphal_i2c_wait_a();
+    mphal_i2c_set_scl(self, 1);
+    mphal_i2c_wait_a();
+
+    int ret = mphal_i2c_get_sda(self);
+    mphal_i2c_wait_a();
+    mphal_i2c_set_scl(self, 0);
+    mphal_i2c_wait_a();
+
+    return !ret;
+}
+
+STATIC void mphal_i2c_write(pyb_i2c_obj_t *self, uint8_t addr, uint8_t *data, size_t len, bool stop) {
+    mphal_i2c_start(self);
+    if (!mphal_i2c_write_byte(self, addr << 1)) {
+        goto er;
+    }
+    while (len--) {
+        if (!mphal_i2c_write_byte(self, *data++)) {
+            goto er;
+        }
+    }
+    if (stop) {
+        mphal_i2c_stop(self);
+    }
+    return;
+
+er:
+    mphal_i2c_stop(self);
+    nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "I2C bus error"));
+}
+
+STATIC int mphal_i2c_read_byte(pyb_i2c_obj_t *self, uint8_t *val) {
+    mphal_i2c_wait_a();
+    mphal_i2c_set_scl(self, 0);
+    mphal_i2c_wait_a();
+
+    uint8_t dat = 0;
+    for (int i = 7; i >= 0; i--) {
+        mphal_i2c_set_scl(self, 1);
+        mphal_i2c_wait_a();
+        dat = (dat << 1) | mphal_i2c_get_sda(self);
+        mphal_i2c_wait_a();
+        mphal_i2c_set_scl(self, 0);
+        mphal_i2c_wait_a();
+    }
+    *val = dat;
+
+    mphal_i2c_wait_a();
+    mphal_i2c_set_scl(self, 1);
+    mphal_i2c_wait_a();
+    mphal_i2c_wait_b();
+    mphal_i2c_set_scl(self, 0);
+    mphal_i2c_wait_a();
+
+    return 1; // success
+}
+
+STATIC void mphal_i2c_read(pyb_i2c_obj_t *self, uint8_t addr, uint8_t *data, size_t len, bool stop) {
+    mphal_i2c_start(self);
+    if (!mphal_i2c_write_byte(self, (addr << 1) | 1)) {
+        goto er;
+    }
+    while (len--) {
+        if (!mphal_i2c_read_byte(self, data++)) {
+            goto er;
+        }
+    }
+    if (stop) {
+        mphal_i2c_stop(self);
+    }
+    return;
+
+er:
+    mphal_i2c_stop(self);
+    nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "I2C bus error"));
+}
+
+/******************************************************************************/
+// MicroPython bindings for I2C
+
+STATIC void pyb_i2c_obj_init_helper(pyb_i2c_obj_t *self, mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_scl, ARG_sda, ARG_freq };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_scl, MP_ARG_REQUIRED | MP_ARG_OBJ },
+        { MP_QSTR_sda, MP_ARG_REQUIRED | MP_ARG_OBJ },
+        { MP_QSTR_freq, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 400000} },
+    };
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+    self->scl = mp_obj_get_pin_obj(args[ARG_scl].u_obj);
+    self->sda = mp_obj_get_pin_obj(args[ARG_sda].u_obj);
+    mphal_i2c_init(self, args[ARG_freq].u_int);
+}
+
+STATIC mp_obj_t pyb_i2c_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+    mp_arg_check_num(n_args, n_kw, 0, MP_OBJ_FUN_ARGS_MAX, true);
+    pyb_i2c_obj_t *self = m_new_obj(pyb_i2c_obj_t);
+    self->base.type = &pyb_i2c_type;
+    mp_map_t kw_args;
+    mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
+    pyb_i2c_obj_init_helper(self, n_args, args, &kw_args);
+    return (mp_obj_t)self;
+}
+
+STATIC mp_obj_t pyb_i2c_obj_init(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
+    pyb_i2c_obj_init_helper(args[0], n_args - 1, args + 1, kw_args);
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_init_obj, 1, pyb_i2c_obj_init);
+
+STATIC mp_obj_t pyb_i2c_readfrom(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_addr, ARG_n, ARG_stop };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_addr, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_n,    MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_stop, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = true} },
+    };
+    pyb_i2c_obj_t *self = pos_args[0];
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    // do the I2C transfer
+    vstr_t vstr;
+    vstr_init_len(&vstr, args[ARG_n].u_int);
+    mphal_i2c_read(self, args[ARG_addr].u_int, (uint8_t*)vstr.buf, vstr.len, args[ARG_stop].u_bool);
+
+    return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
+}
+MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_readfrom_obj, 1, pyb_i2c_readfrom);
+
+STATIC mp_obj_t pyb_i2c_writeto(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_addr, ARG_buf, ARG_stop };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_addr, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_buf,  MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_stop, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = true} },
+    };
+    pyb_i2c_obj_t *self = pos_args[0];
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    // get the buffer to write from
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(args[ARG_buf].u_obj, &bufinfo, MP_BUFFER_READ);
+
+    // do the I2C transfer
+    mphal_i2c_write(self, args[ARG_addr].u_int, bufinfo.buf, bufinfo.len, args[ARG_stop].u_bool);
+
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_writeto_obj, 1, pyb_i2c_writeto);
+
+STATIC const mp_rom_map_elem_t pyb_i2c_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_init),    MP_ROM_PTR(&pyb_i2c_init_obj) },
+    { MP_ROM_QSTR(MP_QSTR_readfrom), MP_ROM_PTR(&pyb_i2c_readfrom_obj) },
+    { MP_ROM_QSTR(MP_QSTR_writeto), MP_ROM_PTR(&pyb_i2c_writeto_obj) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(pyb_i2c_locals_dict, pyb_i2c_locals_dict_table);
+
+const mp_obj_type_t pyb_i2c_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_I2C,
+    .make_new = pyb_i2c_make_new,
+    .locals_dict = (mp_obj_dict_t*)&pyb_i2c_locals_dict,
+};

esp8266/modpybpin.c

@@ -38,19 +38,12 @@
 
 #define GPIO_MODE_INPUT (0)
 #define GPIO_MODE_OUTPUT (1)
+#define GPIO_MODE_OPEN_DRAIN (2) // synthesised
 #define GPIO_PULL_NONE (0)
 #define GPIO_PULL_UP (1)
 // Removed in SDK 1.1.0
 //#define GPIO_PULL_DOWN (2)
 
-typedef struct _pyb_pin_obj_t {
-    mp_obj_base_t base;
-    uint16_t pin_id;
-    uint16_t phys_port;
-    uint32_t periph;
-    uint16_t func;
-} pyb_pin_obj_t;
-
 STATIC const pyb_pin_obj_t pyb_pin_obj[] = {
     {{&pyb_pin_type}, 0, 0, PERIPHS_IO_MUX_GPIO0_U, FUNC_GPIO0},
     {{&pyb_pin_type}, 1, 1, PERIPHS_IO_MUX_U0TXD_U, FUNC_GPIO1},
@@ -64,8 +57,75 @@ STATIC const pyb_pin_obj_t pyb_pin_obj[] = {
     {{&pyb_pin_type}, 13, 13, PERIPHS_IO_MUX_MTCK_U, FUNC_GPIO13},
     {{&pyb_pin_type}, 14, 14, PERIPHS_IO_MUX_MTMS_U, FUNC_GPIO14},
     {{&pyb_pin_type}, 15, 15, PERIPHS_IO_MUX_MTDO_U, FUNC_GPIO15},
+    // GPIO16 is special, belongs to different register set, and
+    // otherwise handled specially.
+    {{&pyb_pin_type}, 16, 16, -1, -1},
 };
 
+STATIC uint8_t pin_mode[16 + 1];
+
+pyb_pin_obj_t *mp_obj_get_pin_obj(mp_obj_t pin_in) {
+    if (mp_obj_get_type(pin_in) != &pyb_pin_type) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, "expecting a pin"));
+    }
+    pyb_pin_obj_t *self = pin_in;
+    return self;
+}
+
+uint mp_obj_get_pin(mp_obj_t pin_in) {
+    return mp_obj_get_pin_obj(pin_in)->phys_port;
+}
+
+int pin_get(uint pin) {
+    if (pin == 16) {
+        return READ_PERI_REG(RTC_GPIO_IN_DATA) & 1;
+    }
+    return GPIO_INPUT_GET(pin);
+}
+
+void pin_set(uint pin, int value) {
+    if (pin == 16) {
+        int out_en = (pin_mode[pin] == GPIO_MODE_OUTPUT);
+        WRITE_PERI_REG(PAD_XPD_DCDC_CONF, (READ_PERI_REG(PAD_XPD_DCDC_CONF) & 0xffffffbc) | 1);
+        WRITE_PERI_REG(RTC_GPIO_CONF, READ_PERI_REG(RTC_GPIO_CONF) & ~1);
+        WRITE_PERI_REG(RTC_GPIO_ENABLE, (READ_PERI_REG(RTC_GPIO_ENABLE) & ~1) | out_en);
+        WRITE_PERI_REG(RTC_GPIO_OUT, (READ_PERI_REG(RTC_GPIO_OUT) & ~1) | value);
+        return;
+    }
+
+    uint32_t enable = 0;
+    uint32_t disable = 0;
+    switch (pin_mode[pin]) {
+        case GPIO_MODE_INPUT:
+            value = -1;
+            disable = 1;
+            break;
+
+        case GPIO_MODE_OUTPUT:
+            enable = 1;
+            break;
+
+        case GPIO_MODE_OPEN_DRAIN:
+            if (value == -1) {
+                return;
+            } else if (value == 0) {
+                enable = 1;
+            } else {
+                value = -1;
+                disable = 1;
+            }
+            break;
+    }
+
+    enable <<= pin;
+    disable <<= pin;
+    if (value == -1) {
+        gpio_output_set(0, 0, enable, disable);
+    } else {
+        gpio_output_set(value << pin, (1 - value) << pin, enable, disable);
+    }
+}
+
 STATIC void pyb_pin_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
     pyb_pin_obj_t *self = self_in;
 
@@ -77,49 +137,65 @@ STATIC void pyb_pin_print(const mp_print_t *print, mp_obj_t self_in, mp_print_ki
 STATIC mp_obj_t pyb_pin_obj_init_helper(pyb_pin_obj_t *self, mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     static const mp_arg_t allowed_args[] = {
         { MP_QSTR_mode, MP_ARG_REQUIRED | MP_ARG_INT },
-        { MP_QSTR_pull,                   MP_ARG_INT, {.u_int = GPIO_PULL_NONE}},
+        { MP_QSTR_pull, MP_ARG_INT, {.u_int = GPIO_PULL_NONE}},
+        { MP_QSTR_value, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL}},
     };
 
     // parse args
-    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
-    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+    struct {
+        mp_arg_val_t mode, pull, value;
+    } args;
+    mp_arg_parse_all(n_args, pos_args, kw_args,
+        MP_ARRAY_SIZE(allowed_args), allowed_args, (mp_arg_val_t*)&args);
 
     // get io mode
-    uint mode = args[0].u_int;
+    uint mode = args.mode.u_int;
 
     // get pull mode
-    uint pull = args[1].u_int;
+    uint pull = args.pull.u_int;
+
+    // get initial value
+    int value;
+    if (args.value.u_obj == MP_OBJ_NULL) {
+        value = -1;
+    } else {
+        value = mp_obj_is_true(args.value.u_obj);
+    }
+
+    // save the mode
+    pin_mode[self->phys_port] = mode;
 
     // configure the GPIO as requested
-    PIN_FUNC_SELECT(self->periph, self->func);
-    #if 0
-    // Removed in SDK 1.1.0
-    if ((pull & GPIO_PULL_DOWN) == 0) {
-        PIN_PULLDWN_DIS(self->periph);
-    }
-    #endif
-    if ((pull & GPIO_PULL_UP) == 0) {
-        PIN_PULLUP_DIS(self->periph);
-    }
-    #if 0
-    if ((pull & GPIO_PULL_DOWN) != 0) {
-        PIN_PULLDWN_EN(self->periph);
-    }
-    #endif
-    if ((pull & GPIO_PULL_UP) != 0) {
-        PIN_PULLUP_EN(self->periph);
+    if (self->phys_port == 16) {
+        // TODO: Set pull up/pull down
+    } else {
+        PIN_FUNC_SELECT(self->periph, self->func);
+        #if 0
+        // Removed in SDK 1.1.0
+        if ((pull & GPIO_PULL_DOWN) == 0) {
+            PIN_PULLDWN_DIS(self->periph);
+        }
+        #endif
+        if ((pull & GPIO_PULL_UP) == 0) {
+            PIN_PULLUP_DIS(self->periph);
+        }
+        #if 0
+        if ((pull & GPIO_PULL_DOWN) != 0) {
+            PIN_PULLDWN_EN(self->periph);
+        }
+        #endif
+        if ((pull & GPIO_PULL_UP) != 0) {
+            PIN_PULLUP_EN(self->periph);
+        }
     }
 
-    // TODO input mode is not working...
-    if ((mode & GPIO_MODE_OUTPUT) == 0) {
-        GPIO_DIS_OUTPUT(self->phys_port);
-    }
+    pin_set(self->phys_port, value);
 
     return mp_const_none;
 }
 
 // constructor(id, ...)
-STATIC mp_obj_t pyb_pin_make_new(mp_obj_t self_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
+STATIC mp_obj_t pyb_pin_make_new(const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
     mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
 
     // Run an argument through the mapper and return the result.
@@ -145,6 +221,20 @@ STATIC mp_obj_t pyb_pin_make_new(mp_obj_t self_in, mp_uint_t n_args, mp_uint_t n
     return (mp_obj_t)pin;
 }
 
+// fast method for getting/setting pin value
+STATIC mp_obj_t pyb_pin_call(mp_obj_t self_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
+    mp_arg_check_num(n_args, n_kw, 0, 1, false);
+    pyb_pin_obj_t *self = self_in;
+    if (n_args == 0) {
+        // get pin
+        return MP_OBJ_NEW_SMALL_INT(GPIO_INPUT_GET(self->phys_port));
+    } else {
+        // set pin
+        pin_set(self->phys_port, mp_obj_is_true(args[0]));
+        return mp_const_none;
+    }
+}
+
 // pin.init(mode, pull)
 STATIC mp_obj_t pyb_pin_obj_init(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
     return pyb_pin_obj_init_helper(args[0], n_args - 1, args + 1, kw_args);
@@ -153,26 +243,14 @@ MP_DEFINE_CONST_FUN_OBJ_KW(pyb_pin_init_obj, 1, pyb_pin_obj_init);
 
 // pin.value([value])
 STATIC mp_obj_t pyb_pin_value(mp_uint_t n_args, const mp_obj_t *args) {
-    pyb_pin_obj_t *self = args[0];
-    if (n_args == 1) {
-        // get pin
-        return MP_OBJ_NEW_SMALL_INT(GPIO_INPUT_GET(self->phys_port));
-    } else {
-        // set pin
-        if (mp_obj_is_true(args[1])) {
-            GPIO_OUTPUT_SET(self->phys_port, 1);
-        } else {
-            GPIO_OUTPUT_SET(self->phys_port, 0);
-        }
-        return mp_const_none;
-    }
+    return pyb_pin_call(args[0], n_args - 1, 0, args + 1);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_pin_value_obj, 1, 2, pyb_pin_value);
 
 // pin.low()
 STATIC mp_obj_t pyb_pin_low(mp_obj_t self_in) {
     pyb_pin_obj_t *self = self_in;
-    GPIO_OUTPUT_SET(self->phys_port, 0);
+    pin_set(self->phys_port, 0);
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_pin_low_obj, pyb_pin_low);
@@ -180,7 +258,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_pin_low_obj, pyb_pin_low);
 // pin.high()
 STATIC mp_obj_t pyb_pin_high(mp_obj_t self_in) {
     pyb_pin_obj_t *self = self_in;
-    GPIO_OUTPUT_SET(self->phys_port, 1);
+    pin_set(self->phys_port, 1);
     return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_pin_high_obj, pyb_pin_high);
@@ -194,7 +272,8 @@ STATIC const mp_map_elem_t pyb_pin_locals_dict_table[] = {
 
     // class constants
     { MP_OBJ_NEW_QSTR(MP_QSTR_IN),        MP_OBJ_NEW_SMALL_INT(GPIO_MODE_INPUT) },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_OUT_PP),    MP_OBJ_NEW_SMALL_INT(GPIO_MODE_OUTPUT) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_OUT),       MP_OBJ_NEW_SMALL_INT(GPIO_MODE_OUTPUT) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_OPEN_DRAIN), MP_OBJ_NEW_SMALL_INT(GPIO_MODE_OPEN_DRAIN) },
     { MP_OBJ_NEW_QSTR(MP_QSTR_PULL_NONE), MP_OBJ_NEW_SMALL_INT(GPIO_PULL_NONE) },
     { MP_OBJ_NEW_QSTR(MP_QSTR_PULL_UP),   MP_OBJ_NEW_SMALL_INT(GPIO_PULL_UP) },
     //{ MP_OBJ_NEW_QSTR(MP_QSTR_PULL_DOWN), MP_OBJ_NEW_SMALL_INT(GPIO_PULL_DOWN) },
@@ -207,5 +286,6 @@ const mp_obj_type_t pyb_pin_type = {
     .name = MP_QSTR_Pin,
     .print = pyb_pin_print,
     .make_new = pyb_pin_make_new,
+    .call = pyb_pin_call,
     .locals_dict = (mp_obj_t)&pyb_pin_locals_dict,
 };

esp8266/modpybpwm.c

@@ -0,0 +1,172 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2016 Damien P. George
+ *
+ * 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.
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+
+#include "esppwm.h"
+
+#include "py/nlr.h"
+#include "py/runtime.h"
+#include "modpyb.h"
+
+typedef struct _pyb_pwm_obj_t {
+    mp_obj_base_t base;
+    pyb_pin_obj_t *pin;
+    uint8_t active;
+    uint8_t channel;
+} pyb_pwm_obj_t;
+
+STATIC bool pwm_inited = false;
+
+/******************************************************************************/
+// MicroPython bindings for PWM
+
+STATIC void pyb_pwm_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    pyb_pwm_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_printf(print, "PWM(%u", self->pin->pin_id);
+    if (self->active) {
+        mp_printf(print, ", freq=%u, duty=%u",
+            pwm_get_freq(self->channel), pwm_get_duty(self->channel));
+    }
+    mp_printf(print, ")");
+}
+
+STATIC void pyb_pwm_init_helper(pyb_pwm_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_freq, ARG_duty };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_freq, MP_ARG_INT, {.u_int = -1} },
+        { MP_QSTR_duty, MP_ARG_INT, {.u_int = -1} },
+    };
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    int channel = pwm_add(self->pin->phys_port, self->pin->periph, self->pin->func);
+    if (channel == -1) {
+        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
+            "PWM not supported on pin %d", self->pin->phys_port));
+    }
+
+    self->channel = channel;
+    self->active = 1;
+    if (args[ARG_freq].u_int != -1) {
+        pwm_set_freq(args[ARG_freq].u_int, self->channel);
+    }
+    if (args[ARG_duty].u_int != -1) {
+        pwm_set_duty(args[ARG_duty].u_int, self->channel);
+    }
+
+    pwm_start();
+}
+
+STATIC mp_obj_t pyb_pwm_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+    mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
+    pyb_pin_obj_t *pin = mp_obj_get_pin_obj(args[0]);
+
+    // create PWM object from the given pin
+    pyb_pwm_obj_t *self = m_new_obj(pyb_pwm_obj_t);
+    self->base.type = &pyb_pwm_type;
+    self->pin = pin;
+    self->active = 0;
+    self->channel = -1;
+
+    // start the PWM subsystem if it's not already running
+    if (!pwm_inited) {
+        pwm_init();
+        pwm_inited = true;
+    }
+
+    // start the PWM running for this channel
+    mp_map_t kw_args;
+    mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
+    pyb_pwm_init_helper(self, n_args - 1, args + 1, &kw_args);
+
+    return MP_OBJ_FROM_PTR(self);
+}
+
+STATIC mp_obj_t pyb_pwm_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
+    pyb_pwm_init_helper(args[0], n_args - 1, args + 1, kw_args);
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_KW(pyb_pwm_init_obj, 1, pyb_pwm_init);
+
+STATIC mp_obj_t pyb_pwm_deinit(mp_obj_t self_in) {
+    pyb_pwm_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    pwm_delete(self->channel);
+    self->active = 0;
+    pwm_start();
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_pwm_deinit_obj, pyb_pwm_deinit);
+
+STATIC mp_obj_t pyb_pwm_freq(size_t n_args, const mp_obj_t *args) {
+    //pyb_pwm_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    if (n_args == 1) {
+        // get
+        return MP_OBJ_NEW_SMALL_INT(pwm_get_freq(0));
+    } else {
+        // set
+        pwm_set_freq(mp_obj_get_int(args[1]), 0);
+        pwm_start();
+        return mp_const_none;
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_pwm_freq_obj, 1, 2, pyb_pwm_freq);
+
+STATIC mp_obj_t pyb_pwm_duty(size_t n_args, const mp_obj_t *args) {
+    pyb_pwm_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    if (!self->active) {
+        pwm_add(self->pin->phys_port, self->pin->periph, self->pin->func);
+        self->active = 1;
+    }
+    if (n_args == 1) {
+        // get
+        return MP_OBJ_NEW_SMALL_INT(pwm_get_duty(self->channel));
+    } else {
+        // set
+        pwm_set_duty(mp_obj_get_int(args[1]), self->channel);
+        pwm_start();
+        return mp_const_none;
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_pwm_duty_obj, 1, 2, pyb_pwm_duty);
+
+STATIC const mp_rom_map_elem_t pyb_pwm_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&pyb_pwm_init_obj) },
+    { MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&pyb_pwm_deinit_obj) },
+    { MP_ROM_QSTR(MP_QSTR_freq), MP_ROM_PTR(&pyb_pwm_freq_obj) },
+    { MP_ROM_QSTR(MP_QSTR_duty), MP_ROM_PTR(&pyb_pwm_duty_obj) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(pyb_pwm_locals_dict, pyb_pwm_locals_dict_table);
+
+const mp_obj_type_t pyb_pwm_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_PWM,
+    .print = pyb_pwm_print,
+    .make_new = pyb_pwm_make_new,
+    .locals_dict = (mp_obj_dict_t*)&pyb_pwm_locals_dict,
+};

esp8266/modpybrtc.c

@@ -49,7 +49,21 @@ typedef struct _pyb_rtc_obj_t {
 // singleton RTC object
 STATIC const pyb_rtc_obj_t pyb_rtc_obj = {{&pyb_rtc_type}};
 
-STATIC mp_obj_t pyb_rtc_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
+void mp_hal_rtc_init(void) {
+    uint32_t magic;
+
+    system_rtc_mem_read(MEM_USER_MAGIC_ADDR, &magic, sizeof(magic));
+    if (magic != MEM_MAGIC) {
+        magic = MEM_MAGIC;
+        system_rtc_mem_write(MEM_USER_MAGIC_ADDR, &magic, sizeof(magic));
+        uint32_t cal = system_rtc_clock_cali_proc();
+        int64_t delta = 0;
+        system_rtc_mem_write(MEM_CAL_ADDR, &cal, sizeof(cal));
+        system_rtc_mem_write(MEM_DELTA_ADDR, &delta, sizeof(delta));
+    }
+}
+
+STATIC mp_obj_t pyb_rtc_make_new(const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
     // check arguments
     mp_arg_check_num(n_args, n_kw, 0, 0, false);
 
@@ -58,7 +72,7 @@ STATIC mp_obj_t pyb_rtc_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n
 }
 
 STATIC uint64_t pyb_rtc_raw_us(uint64_t cal) {
-    return system_get_rtc_time() * ((cal >> 12) * 1000 + (cal & 0xfff) / 4) / 1000;
+    return (system_get_rtc_time() * cal) >> 12;
 };
 
 void pyb_rtc_set_us_since_2000(uint64_t nowus) {
@@ -146,7 +160,7 @@ STATIC mp_obj_t pyb_rtc_memory(mp_uint_t n_args, const mp_obj_t *args) {
         }
 
         magic = MEM_MAGIC;
-        system_rtc_mem_write(MEM_USER_MAGIC_ADDR, &magic, sizeof(len));
+        system_rtc_mem_write(MEM_USER_MAGIC_ADDR, &magic, sizeof(magic));
         len = bufinfo.len;
         system_rtc_mem_write(MEM_USER_LEN_ADDR, &len, sizeof(len));
 

esp8266/modpybspi.c

@@ -0,0 +1,217 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2016 Damien P. George
+ *
+ * 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.
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <errno.h>
+
+#include "ets_sys.h"
+#include "etshal.h"
+#include "ets_alt_task.h"
+
+#include "py/runtime.h"
+#include "py/stream.h"
+#include "modpyb.h"
+
+typedef struct _pyb_spi_obj_t {
+    mp_obj_base_t base;
+    uint32_t baudrate;
+    uint8_t polarity;
+    uint8_t phase;
+    pyb_pin_obj_t *sck;
+    pyb_pin_obj_t *mosi;
+    pyb_pin_obj_t *miso;
+} pyb_spi_obj_t;
+
+STATIC void mp_hal_spi_transfer(pyb_spi_obj_t *self, size_t src_len, const uint8_t *src_buf, size_t dest_len, uint8_t *dest_buf) {
+    // only MSB transfer is implemented
+    uint32_t delay_half = 500000 / self->baudrate + 1;
+    for (size_t i = 0; i < src_len || i < dest_len; ++i) {
+        uint8_t data_out;
+        if (src_len == 1) {
+            data_out = src_buf[0];
+        } else {
+            data_out = src_buf[i];
+        }
+        uint8_t data_in = 0;
+        for (int j = 0; j < 8; ++j, data_out <<= 1) {
+            pin_set(self->mosi->phys_port, (data_out >> 7) & 1);
+            if (self->phase == 0) {
+                ets_delay_us(delay_half);
+                pin_set(self->sck->phys_port, 1 - self->polarity);
+            } else {
+                pin_set(self->sck->phys_port, 1 - self->polarity);
+                ets_delay_us(delay_half);
+            }
+            data_in = (data_in << 1) | pin_get(self->miso->phys_port);
+            if (self->phase == 0) {
+                ets_delay_us(delay_half);
+                pin_set(self->sck->phys_port, self->polarity);
+            } else {
+                pin_set(self->sck->phys_port, self->polarity);
+                ets_delay_us(delay_half);
+            }
+        }
+        if (dest_len != 0) {
+            dest_buf[i] = data_in;
+        }
+        // make sure pending tasks have a chance to run
+        ets_loop_iter();
+    }
+}
+
+/******************************************************************************/
+// MicroPython bindings for SPI
+
+STATIC void pyb_spi_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    pyb_spi_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_printf(print, "SPI(baudrate=%u, polarity=%u, phase=%u, sck=%u, mosi=%u, miso=%u)",
+        self->baudrate, self->polarity, self->phase, self->sck->phys_port, self->mosi->phys_port, self->miso->phys_port);
+}
+
+STATIC void pyb_spi_init_helper(pyb_spi_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    enum { ARG_baudrate, ARG_polarity, ARG_phase, ARG_sck, ARG_mosi, ARG_miso };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_baudrate, MP_ARG_INT, {.u_int = -1} },
+        { MP_QSTR_polarity, MP_ARG_INT, {.u_int = -1} },
+        { MP_QSTR_phase, MP_ARG_INT, {.u_int = -1} },
+        { MP_QSTR_sck, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_mosi, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_miso, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+    };
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    if (args[ARG_baudrate].u_int != -1) {
+        self->baudrate = args[ARG_baudrate].u_int;
+    }
+    if (args[ARG_polarity].u_int != -1) {
+        self->polarity = args[ARG_polarity].u_int;
+    }
+    if (args[ARG_phase].u_int != -1) {
+        self->phase = args[ARG_phase].u_int;
+    }
+    if (args[ARG_sck].u_obj != MP_OBJ_NULL) {
+        self->sck = mp_obj_get_pin_obj(args[ARG_sck].u_obj);
+    }
+    if (args[ARG_mosi].u_obj != MP_OBJ_NULL) {
+        self->mosi = mp_obj_get_pin_obj(args[ARG_mosi].u_obj);
+    }
+    if (args[ARG_miso].u_obj != MP_OBJ_NULL) {
+        self->miso = mp_obj_get_pin_obj(args[ARG_miso].u_obj);
+    }
+}
+
+STATIC mp_obj_t pyb_spi_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+    mp_arg_check_num(n_args, n_kw, 0, MP_OBJ_FUN_ARGS_MAX, true);
+    pyb_spi_obj_t *self = m_new_obj(pyb_spi_obj_t);
+    self->base.type = &pyb_spi_type;
+    // set defaults
+    self->baudrate = 500000;
+    self->polarity = 0;
+    self->phase = 0;
+    self->sck = NULL;
+    self->mosi = NULL;
+    self->miso = NULL;
+    mp_map_t kw_args;
+    mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
+    pyb_spi_init_helper(self, n_args, args, &kw_args);
+    return MP_OBJ_FROM_PTR(self);
+}
+
+STATIC mp_obj_t pyb_spi_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
+    pyb_spi_init_helper(args[0], n_args - 1, args + 1, kw_args);
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_KW(pyb_spi_init_obj, 1, pyb_spi_init);
+
+STATIC mp_obj_t pyb_spi_read(size_t n_args, const mp_obj_t *args) {
+    pyb_spi_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    uint8_t write_byte = 0;
+    if (n_args == 3) {
+        write_byte = mp_obj_get_int(args[2]);
+    }
+    vstr_t vstr;
+    vstr_init_len(&vstr, mp_obj_get_int(args[1]));
+    mp_hal_spi_transfer(self, 1, &write_byte, vstr.len, (uint8_t*)vstr.buf);
+    return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
+}
+MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_spi_read_obj, 2, 3, pyb_spi_read);
+
+STATIC mp_obj_t pyb_spi_readinto(size_t n_args, const mp_obj_t *args) {
+    pyb_spi_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    mp_buffer_info_t bufinfo;
+    mp_get_buffer_raise(args[1], &bufinfo, MP_BUFFER_WRITE);
+    uint8_t write_byte = 0;
+    if (n_args == 3) {
+        write_byte = mp_obj_get_int(args[2]);
+    }
+    mp_hal_spi_transfer(self, 1, &write_byte, bufinfo.len, (uint8_t*)bufinfo.buf);
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_spi_readinto_obj, 2, 3, pyb_spi_readinto);
+
+STATIC mp_obj_t pyb_spi_write(mp_obj_t self_in, mp_obj_t wr_buf_in) {
+    pyb_spi_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_buffer_info_t src_buf;
+    mp_get_buffer_raise(wr_buf_in, &src_buf, MP_BUFFER_READ);
+    mp_hal_spi_transfer(self, src_buf.len, (const uint8_t*)src_buf.buf, 0, NULL);
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(pyb_spi_write_obj, pyb_spi_write);
+
+STATIC mp_obj_t pyb_spi_write_readinto(mp_obj_t self_in, mp_obj_t wr_buf_in, mp_obj_t rd_buf_in) {
+    pyb_spi_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_buffer_info_t src_buf;
+    mp_get_buffer_raise(wr_buf_in, &src_buf, MP_BUFFER_READ);
+    mp_buffer_info_t dest_buf;
+    mp_get_buffer_raise(rd_buf_in, &dest_buf, MP_BUFFER_WRITE);
+    if (src_buf.len != dest_buf.len) {
+        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "buffers must be the same length"));
+    }
+    mp_hal_spi_transfer(self, src_buf.len, (const uint8_t*)src_buf.buf, dest_buf.len, (uint8_t*)dest_buf.buf);
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_3(pyb_spi_write_readinto_obj, pyb_spi_write_readinto);
+
+STATIC const mp_rom_map_elem_t pyb_spi_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&pyb_spi_init_obj) },
+    { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&pyb_spi_read_obj) },
+    { MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&pyb_spi_readinto_obj) },
+    { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&pyb_spi_write_obj) },
+    { MP_ROM_QSTR(MP_QSTR_write_readinto), MP_ROM_PTR(&pyb_spi_write_readinto_obj) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(pyb_spi_locals_dict, pyb_spi_locals_dict_table);
+
+const mp_obj_type_t pyb_spi_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_SPI,
+    .print = pyb_spi_print,
+    .make_new = pyb_spi_make_new,
+    .locals_dict = (mp_obj_dict_t*)&pyb_spi_locals_dict,
+};

esp8266/modpybuart.c

@@ -0,0 +1,157 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2016 Damien P. George
+ *
+ * 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.
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <errno.h>
+
+#include "ets_sys.h"
+#include "uart.h"
+
+#include "py/runtime.h"
+#include "py/stream.h"
+#include "modpyb.h"
+
+typedef struct _pyb_uart_obj_t {
+    mp_obj_base_t base;
+    uint8_t uart_id;
+} pyb_uart_obj_t;
+
+/******************************************************************************/
+// MicroPython bindings for UART
+
+STATIC void pyb_uart_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    pyb_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    mp_printf(print, "UART(%u)", self->uart_id);
+}
+
+STATIC void pyb_uart_init_helper(pyb_uart_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    /*
+    enum { ARG_baudrate, ARG_bits, ARG_parity, ARG_stop };
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_baudrate, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 9600} },
+        { MP_QSTR_bits, MP_ARG_INT, {.u_int = 8} },
+        { MP_QSTR_parity, MP_ARG_OBJ, {.u_obj = mp_const_none} },
+        { MP_QSTR_stop, MP_ARG_INT, {.u_int = 1} },
+        { MP_QSTR_tx, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_rx, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+    };
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+    */
+    // not implemented
+}
+
+STATIC mp_obj_t pyb_uart_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
+    mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
+
+    // get uart id
+    mp_int_t uart_id = mp_obj_get_int(args[0]);
+    if (uart_id != 0 && uart_id != 1) {
+        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "UART(%d) does not exist", uart_id));
+    }
+
+    // create instance
+    pyb_uart_obj_t *self = m_new_obj(pyb_uart_obj_t);
+    self->base.type = &pyb_uart_type;
+    self->uart_id = uart_id;
+
+    if (n_args > 1 || n_kw > 0) {
+        // init the peripheral
+        mp_map_t kw_args;
+        mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
+        pyb_uart_init_helper(self, n_args - 1, args + 1, &kw_args);
+    }
+
+    return MP_OBJ_FROM_PTR(self);
+}
+
+STATIC mp_obj_t pyb_uart_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
+    pyb_uart_init_helper(args[0], n_args - 1, args + 1, kw_args);
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_KW(pyb_uart_init_obj, 1, pyb_uart_init);
+
+STATIC const mp_rom_map_elem_t pyb_uart_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR_init), MP_ROM_PTR(&pyb_uart_init_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
+    { MP_ROM_QSTR(MP_QSTR_readall), MP_ROM_PTR(&mp_stream_readall_obj) },
+    { MP_ROM_QSTR(MP_QSTR_readline), MP_ROM_PTR(&mp_stream_unbuffered_readline_obj) },
+    { MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&mp_stream_readinto_obj) },
+    { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(pyb_uart_locals_dict, pyb_uart_locals_dict_table);
+
+STATIC mp_uint_t pyb_uart_read(mp_obj_t self_in, void *buf_in, mp_uint_t size, int *errcode) {
+    mp_not_implemented("reading from UART");
+}
+
+STATIC mp_uint_t pyb_uart_write(mp_obj_t self_in, const void *buf_in, mp_uint_t size, int *errcode) {
+    pyb_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
+    const byte *buf = buf_in;
+
+    /* TODO implement non-blocking
+    // wait to be able to write the first character
+    if (!uart_tx_wait(self, timeout)) {
+        *errcode = EAGAIN;
+        return MP_STREAM_ERROR;
+    }
+    */
+
+    // write the data
+    for (size_t i = 0; i < size; ++i) {
+        uart_tx_one_char(self->uart_id, *buf++);
+    }
+
+    // return number of bytes written
+    return size;
+}
+
+STATIC mp_uint_t pyb_uart_ioctl(mp_obj_t self_in, mp_uint_t request, mp_uint_t arg, int *errcode) {
+    *errcode = EINVAL;
+    return MP_STREAM_ERROR;
+}
+
+STATIC const mp_stream_p_t uart_stream_p = {
+    .read = pyb_uart_read,
+    .write = pyb_uart_write,
+    .ioctl = pyb_uart_ioctl,
+    .is_text = false,
+};
+
+const mp_obj_type_t pyb_uart_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_UART,
+    .print = pyb_uart_print,
+    .make_new = pyb_uart_make_new,
+    .getiter = mp_identity,
+    .iternext = mp_stream_unbuffered_iter,
+    .stream_p = &uart_stream_p,
+    .locals_dict = (mp_obj_dict_t*)&pyb_uart_locals_dict,
+};

esp8266/moduos.c

@@ -25,15 +25,21 @@
  */
 
 #include <string.h>
+#include <errno.h>
 
 #include "py/mpconfig.h"
 #include "py/nlr.h"
 #include "py/obj.h"
 #include "py/objtuple.h"
 #include "py/objstr.h"
+#include "py/runtime.h"
+#include "extmod/misc.h"
 #include "genhdr/mpversion.h"
+#include "etshal.h"
 #include "user_interface.h"
 
+extern const mp_obj_type_t mp_fat_vfs_type;
+
 STATIC const qstr os_uname_info_fields[] = {
     MP_QSTR_sysname, MP_QSTR_nodename,
     MP_QSTR_release, MP_QSTR_version, MP_QSTR_machine
@@ -65,9 +71,52 @@ STATIC mp_obj_t os_uname(void) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_0(os_uname_obj, os_uname);
 
-STATIC const mp_map_elem_t os_module_globals_table[] = {
-    { MP_OBJ_NEW_QSTR(MP_QSTR___name__),        MP_OBJ_NEW_QSTR(MP_QSTR_uos) },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_uname),           (mp_obj_t)&os_uname_obj },
+#if MICROPY_VFS_FAT
+mp_obj_t vfs_proxy_call(qstr method_name, mp_uint_t n_args, const mp_obj_t *args) {
+    if (MP_STATE_PORT(fs_user_mount)[0] == NULL) {
+        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(ENODEV)));
+    }
+
+    mp_obj_t meth[n_args + 2];
+    mp_load_method(MP_STATE_PORT(fs_user_mount)[0], method_name, meth);
+    memcpy(meth + 2, args, n_args * sizeof(*args));
+    return mp_call_method_n_kw(n_args, 0, meth);
+}
+
+STATIC mp_obj_t os_listdir(mp_uint_t n_args, const mp_obj_t *args) {
+    return vfs_proxy_call(MP_QSTR_listdir, n_args, args);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(os_listdir_obj, 0, 1, os_listdir);
+
+STATIC mp_obj_t os_remove(mp_obj_t path_in) {
+    return vfs_proxy_call(MP_QSTR_remove, 1, &path_in);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(os_remove_obj, os_remove);
+#endif
+
+STATIC mp_obj_t os_urandom(mp_obj_t num) {
+    mp_int_t n = mp_obj_get_int(num);
+    vstr_t vstr;
+    vstr_init_len(&vstr, n);
+    for (int i = 0; i < n; i++) {
+        vstr.buf[i] = *WDEV_HWRNG;
+    }
+    return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(os_urandom_obj, os_urandom);
+
+STATIC const mp_rom_map_elem_t os_module_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_uos) },
+    { MP_ROM_QSTR(MP_QSTR_uname), MP_ROM_PTR(&os_uname_obj) },
+    { MP_ROM_QSTR(MP_QSTR_urandom), MP_ROM_PTR(&os_urandom_obj) },
+    #if MICROPY_PY_OS_DUPTERM
+    { MP_ROM_QSTR(MP_QSTR_dupterm), MP_ROM_PTR(&mp_uos_dupterm_obj) },
+    #endif
+    #if MICROPY_VFS_FAT
+    { MP_ROM_QSTR(MP_QSTR_VfsFat), MP_ROM_PTR(&mp_fat_vfs_type) },
+    { MP_ROM_QSTR(MP_QSTR_listdir), MP_ROM_PTR(&os_listdir_obj) },
+    { MP_ROM_QSTR(MP_QSTR_remove), MP_ROM_PTR(&os_remove_obj) },
+    #endif
 };
 
 STATIC MP_DEFINE_CONST_DICT(os_module_globals, os_module_globals_table);

esp8266/modutime.c

@@ -33,6 +33,7 @@
 #include "py/gc.h"
 #include "py/runtime.h"
 #include "py/mphal.h"
+#include "py/smallint.h"
 #include "modpyb.h"
 #include "modpybrtc.h"
 #include "timeutils.h"
@@ -101,11 +102,51 @@ MP_DEFINE_CONST_FUN_OBJ_1(time_mktime_obj, time_mktime);
 /// \function sleep(seconds)
 /// Sleep for the given number of seconds.
 STATIC mp_obj_t time_sleep(mp_obj_t seconds_o) {
+    #if MICROPY_PY_BUILTINS_FLOAT
+    mp_hal_delay_ms(1000 * mp_obj_get_float(seconds_o));
+    #else
     mp_hal_delay_ms(1000 * mp_obj_get_int(seconds_o));
+    #endif
     return mp_const_none;
 }
 MP_DEFINE_CONST_FUN_OBJ_1(time_sleep_obj, time_sleep);
 
+STATIC mp_obj_t time_sleep_ms(mp_obj_t arg) {
+    mp_hal_delay_ms(mp_obj_get_int(arg));
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(time_sleep_ms_obj, time_sleep_ms);
+
+STATIC mp_obj_t time_sleep_us(mp_obj_t arg) {
+    mp_hal_delay_us(mp_obj_get_int(arg));
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(time_sleep_us_obj, time_sleep_us);
+
+STATIC mp_obj_t time_ticks_ms(void) {
+    return MP_OBJ_NEW_SMALL_INT(mp_hal_ticks_ms() & MP_SMALL_INT_POSITIVE_MASK);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(time_ticks_ms_obj, time_ticks_ms);
+
+STATIC mp_obj_t time_ticks_us(void) {
+    return MP_OBJ_NEW_SMALL_INT(mp_hal_ticks_us() & MP_SMALL_INT_POSITIVE_MASK);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(time_ticks_us_obj, time_ticks_us);
+
+STATIC mp_obj_t time_ticks_cpu(void) {
+    // TODO
+    return MP_OBJ_NEW_SMALL_INT(0 & MP_SMALL_INT_POSITIVE_MASK);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(time_ticks_cpu_obj, time_ticks_cpu);
+
+STATIC mp_obj_t time_ticks_diff(mp_obj_t start_in, mp_obj_t end_in) {
+    // we assume that the arguments come from ticks_xx so are small ints
+    uint32_t start = MP_OBJ_SMALL_INT_VALUE(start_in);
+    uint32_t end = MP_OBJ_SMALL_INT_VALUE(end_in);
+    return MP_OBJ_NEW_SMALL_INT((end - start) & MP_SMALL_INT_POSITIVE_MASK);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(time_ticks_diff_obj, time_ticks_diff);
+
 /// \function time()
 /// Returns the number of seconds, as an integer, since 1/1/2000.
 STATIC mp_obj_t time_time(void) {
@@ -120,6 +161,12 @@ STATIC const mp_map_elem_t time_module_globals_table[] = {
     { MP_OBJ_NEW_QSTR(MP_QSTR_localtime), (mp_obj_t)&time_localtime_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_mktime), (mp_obj_t)&time_mktime_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_sleep), (mp_obj_t)&time_sleep_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_sleep_ms), (mp_obj_t)&time_sleep_ms_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_sleep_us), (mp_obj_t)&time_sleep_us_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_ticks_ms), (mp_obj_t)&time_ticks_ms_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_ticks_us), (mp_obj_t)&time_ticks_us_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_ticks_cpu), (mp_obj_t)&time_ticks_cpu_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_ticks_diff), (mp_obj_t)&time_ticks_diff_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_time), (mp_obj_t)&time_time_obj },
 };