py: Add MP_LIKELY(), MP_UNLIKELY() macros to help branch prediction.

This allows to pring either absolute addresses or relative offsets in jumps
and code references.

.travis.yml

@@ -8,6 +8,8 @@ before_script:
   - sudo add-apt-repository -y ppa:terry.guo/gcc-arm-embedded
   - sudo apt-get update -qq
   - sudo apt-get install -y python3.3 python3 gcc-4.7 gcc-arm-none-eabi qemu-system mingw32
+  # For teensy build
+  - sudo apt-get install realpath
 
 script:
   - make -C unix CC=gcc-4.7
@@ -15,6 +17,7 @@ script:
   - make -C bare-arm
   - make -C qemu-arm
   - make -C stmhal
+  - make -C stmhal -B MICROPY_PY_WIZNET5K=1 MICROPY_PY_CC3K=1
   - make -C stmhal BOARD=STM32F4DISC
   - make -C teensy
   - make -C windows CROSS_COMPILE=i586-mingw32msvc-

README.md

@@ -5,7 +5,7 @@
 The Micro Python project
 ========================
 <p align="center">
-  <img src="https://raw2.github.com/micropython/micropython/master/logo/upython-with-micro.jpg" alt="MicroPython Logo"/>
+  <img src="https://raw.githubusercontent.com/micropython/micropython/master/logo/upython-with-micro.jpg" alt="MicroPython Logo"/>
 </p>
 
 This is the Micro Python project, which aims to put an implementation
@@ -49,23 +49,28 @@ The Unix version
 
 The "unix" port requires a standard Unix environment with gcc and GNU make.
 x86 and x64 architectures are supported (i.e. x86 32- and 64-bit), as well
-as ARMv7. Porting to other architectures require writing some assembly code
-for the exception handling.
+as ARM and MIPS. Making full-featured port to another architecture requires
+writing some assembly code for the exception handling and garbage collection.
+Alternatively, fallback implementation based on setjmp/longjmp can be used.
 
 To build:
 
     $ cd unix
     $ make
 
-Then to test it:
+Then to give it a try:
 
     $ ./micropython
     >>> list(5 * x + y for x in range(10) for y in [4, 2, 1])
 
+Run complete testsuite:
+
+    $ make test
+
 Debian/Ubuntu/Mint derivative Linux distros will require build-essentials and
 libreadline-dev packages installed. To build FFI (Foreign Function Interface)
-module, libffi-dev package is required. If you have problems with some
-dependencies, they can be disabled in unix/mpconfigport.mk .
+module, libffi-dev and pkg-config packages are required. If you have problems
+with some dependencies, they can be disabled in unix/mpconfigport.mk .
 
 The STM version
 ---------------
@@ -93,3 +98,18 @@ 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
+
+Building the documentation locally
+----------------------------------
+
+Install Sphinx, and optionally (for the RTD-styling), sphinx_rtd_theme,
+preferably in a virtualenv:
+
+     pip install sphinx
+     pip install sphinx_rtd_theme
+
+In `micropython/docs`, build the docs:
+
+    make html
+
+You'll find the index page at `micropython/docs/build/html/index.html`.

bare-arm/Makefile

@@ -9,6 +9,7 @@ include ../py/py.mk
 CROSS_COMPILE = arm-none-eabi-
 
 INC =  -I.
+INC += -I..
 INC += -I$(PY_SRC)
 INC += -I$(BUILD)
 

bare-arm/main.c

@@ -14,6 +14,7 @@
 #include "runtime0.h"
 #include "runtime.h"
 #include "repl.h"
+#include "pfenv.h"
 
 void do_str(const char *src) {
     mp_lexer_t *lex = mp_lexer_new_from_str_len(MP_QSTR__lt_stdin_gt_, src, strlen(src), 0);
@@ -32,12 +33,13 @@ void do_str(const char *src) {
     }
 
     // parse okay
-    qstr source_name = mp_lexer_source_name(lex);
+    qstr source_name = lex->source_name;
     mp_lexer_free(lex);
     mp_obj_t module_fun = mp_compile(pn, source_name, MP_EMIT_OPT_NONE, true);
 
-    if (module_fun == mp_const_none) {
+    if (mp_obj_is_exception_instance(module_fun)) {
         // compile error
+        mp_obj_print_exception(printf_wrapper, NULL, module_fun);
         return;
     }
 
@@ -47,7 +49,7 @@ void do_str(const char *src) {
         nlr_pop();
     } else {
         // uncaught exception
-        mp_obj_print_exception((mp_obj_t)nlr.ret_val);
+        mp_obj_print_exception(printf_wrapper, NULL, (mp_obj_t)nlr.ret_val);
     }
 }
 
@@ -69,14 +71,25 @@ 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_obj_t mp_builtin_open(uint n_args, const mp_obj_t *args, mp_map_t *kwargs) {
     return mp_const_none;
 }
-MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_builtin_open_obj, 1, 2, mp_builtin_open);
+MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_open_obj, 1, mp_builtin_open);
 
 void nlr_jump_fail(void *val) {
 }
 
+void NORETURN __fatal_error(const char *msg) {
+    while (1);
+}
+
+#ifndef NDEBUG
+void MP_WEAK __assert_func(const char *file, int line, const char *func, const char *expr) {
+    printf("Assertion '%s' failed, at file %s:%d\n", expr, file, line);
+    __fatal_error("Assertion failed");
+}
+#endif
+
 /*
 int _lseek() {return 0;}
 int _read() {return 0;}

bare-arm/mpconfigport.h

@@ -12,7 +12,10 @@
 #define MICROPY_HELPER_REPL         (0)
 #define MICROPY_HELPER_LEXER_UNIX   (0)
 #define MICROPY_ENABLE_SOURCE_LINE  (0)
+#define MICROPY_ENABLE_DOC_STRING   (0)
+#define MICROPY_ERROR_REPORTING     (MICROPY_ERROR_REPORTING_TERSE)
 #define MICROPY_PY_BUILTINS_BYTEARRAY (0)
+#define MICROPY_PY_BUILTINS_MEMORYVIEW (0)
 #define MICROPY_PY_BUILTINS_FROZENSET (0)
 #define MICROPY_PY_BUILTINS_SET     (0)
 #define MICROPY_PY_BUILTINS_SLICE   (0)
@@ -30,8 +33,6 @@
 #define MICROPY_LONGINT_IMPL        (MICROPY_LONGINT_IMPL_NONE)
 #define MICROPY_FLOAT_IMPL          (MICROPY_FLOAT_IMPL_NONE)
 
-//#define MICROPY_ERROR_REPORTING     (MICROPY_ERROR_REPORTING_TERSE)
-
 // type definitions for the specific machine
 
 #define BYTES_PER_WORD (4)
@@ -45,6 +46,7 @@ typedef int32_t mp_int_t; // must be pointer size
 typedef uint32_t mp_uint_t; // must be pointer size
 typedef void *machine_ptr_t; // must be of pointer size
 typedef const void *machine_const_ptr_t; // must be of pointer size
+typedef long mp_off_t;
 
 // extra built in names to add to the global namespace
 extern const struct _mp_obj_fun_builtin_t mp_builtin_open_obj;

docs/conf.py

@@ -38,7 +38,7 @@ extensions = [
 ]
 
 # Add any paths that contain templates here, relative to this directory.
-#templates_path = ['templates']
+templates_path = ['templates']
 
 # The suffix of source filenames.
 source_suffix = '.rst'
@@ -60,7 +60,7 @@ copyright = '2014, Damien P. George'
 # The short X.Y version.
 version = '1.3'
 # The full version, including alpha/beta/rc tags.
-release = '1.3.1'
+release = '1.3.7'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
@@ -103,9 +103,19 @@ pygments_style = 'sphinx'
 
 # -- Options for HTML output ----------------------------------------------
 
-# The theme to use for HTML and HTML Help pages.  See the documentation for
-# a list of builtin themes.
-html_theme = 'default'
+# on_rtd is whether we are on readthedocs.org
+on_rtd = os.environ.get('READTHEDOCS', None) == 'True'
+
+if not on_rtd:  # only import and set the theme if we're building docs locally
+    try:
+        import sphinx_rtd_theme
+        html_theme = 'sphinx_rtd_theme'
+        html_theme_path = [sphinx_rtd_theme.get_html_theme_path(), '.']
+    except:
+        html_theme = 'default'
+        html_theme_path = ['.']
+else:
+    html_theme_path = ['.']
 
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the
@@ -113,7 +123,7 @@ html_theme = 'default'
 #html_theme_options = {}
 
 # Add any paths that contain custom themes here, relative to this directory.
-#html_theme_path = []
+# html_theme_path = ['.']
 
 # The name for this set of Sphinx documents.  If None, it defaults to
 # "<project> v<release> documentation".
@@ -124,7 +134,7 @@ html_theme = 'default'
 
 # The name of an image file (relative to this directory) to place at the top
 # of the sidebar.
-#html_logo = None
+#html_logo = '../logo/trans-logo.png'
 
 # The name of an image file (within the static path) to use as favicon of the
 # docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
@@ -134,7 +144,7 @@ html_theme = 'default'
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-#html_static_path = ['static']
+html_static_path = ['static']
 
 # Add any extra paths that contain custom files (such as robots.txt or
 # .htaccess) here, relative to this directory. These files are copied
@@ -143,7 +153,7 @@ html_theme = 'default'
 
 # If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
 # using the given strftime format.
-#html_last_updated_fmt = '%b %d, %Y'
+html_last_updated_fmt = '%d %b %Y'
 
 # If true, SmartyPants will be used to convert quotes and dashes to
 # typographically correct entities.
@@ -154,7 +164,7 @@ html_theme = 'default'
 
 # Additional templates that should be rendered to pages, maps page names to
 # template names.
-#html_additional_pages = {}
+html_additional_pages = {"index": "topindex.html"}
 
 # If false, no module index is generated.
 #html_domain_indices = True
@@ -234,7 +244,7 @@ latex_documents = [
 # (source start file, name, description, authors, manual section).
 man_pages = [
     ('index', 'micropython', 'Micro Python Documentation',
-     ['Damien P. George'], 1)
+     ['Damien P. George'], 1),
 ]
 
 # If true, show URL addresses after external links.

docs/contents.rst

@@ -0,0 +1,11 @@
+Micro Python documentation contents
+===================================
+
+.. toctree::
+
+   quickref.rst
+   general.rst
+   tutorial/index.rst
+   library/index.rst
+   hardware/index.rst
+   license.rst

docs/general.rst

@@ -46,6 +46,9 @@ The modes are:
    filesystem to its factory state, then boots in safe mode.
 
 If your filesystem becomes corrupt, boot into mode 3 to fix it.
+If resetting the filesystem while plugged into your compute doesn't work,
+you can try doing the same procedure while the board is plugged into a USB
+charger, or other USB power supply without data connection.
 
 Errors: flashing LEDs
 ---------------------

docs/hardware/index.rst

@@ -0,0 +1,29 @@
+.. _hardware_index:
+
+The pyboard hardware
+====================
+
+For the pyboard:
+
+* `PYBv1.0 schematics and layout <http://micropython.org/resources/PYBv10b.pdf>`_ (2.4MiB PDF)
+* `PYBv1.0 metric dimensions <http://micropython.org/resources/PYBv10b-metric-dimensions.pdf>`_ (360KiB PDF)
+* `PYBv1.0 imperial dimensions <http://micropython.org/resources/PYBv10b-imperial-dimensions.pdf>`_ (360KiB PDF)
+
+For the official skin modules:
+
+* `LCD32MKv1.0 schematics <http://micropython.org/resources/LCD32MKv10-schematics.pdf>`_ (194KiB PDF)
+* `AMPv1.0 schematics <http://micropython.org/resources/AMPv10-schematics.pdf>`_ (209KiB PDF)
+
+Datasheets for the components on the pyboard
+============================================
+
+* The microcontroller: `STM32F405RGT6 <http://www.st.com/web/catalog/mmc/FM141/SC1169/SS1577/LN1035/PF252144>`_ (link to manufacturer's site)
+* The accelerometer: `Freescale MMA7660 <http://micropython.org/resources/datasheets/MMA7660FC.pdf>`_ (800kiB PDF)
+* The LDO voltage regulator: `Microchip MCP1802 <http://micropython.org/resources/datasheets/MCP1802-22053C.pdf>`_ (400kiB PDF)
+
+Datasheets for other components
+===============================
+
+* The LCD display on the LCD touch-sensor skin: `Newhaven Display NHD-C12832A1Z-FSW-FBW-3V3 <http://micropython.org/resources/datasheets/NHD-C12832A1Z-FSW-FBW-3V3.pdf>`_ (460KiB PDF)
+* The touch sensor chip on the LCD touch-sensor skin: `Freescale MPR121 <http://micropython.org/resources/datasheets/MPR121.pdf>`_ (280KiB PDF)
+* The digital potentiometer on the audio skin: `Microchip MCP4541 <http://micropython.org/resources/datasheets/MCP4541-22107B.pdf>`_ (2.7MiB PDF)

docs/index.rst

@@ -1,38 +1,15 @@
-.. Micro Python documentation master file
-
 Micro Python documentation and references
 =========================================
 
-Here you can find documentation for Micro Python and the pyboard.
-
-Software
---------
-
 .. toctree::
-   :maxdepth: 2
 
+   quickref.rst
    general.rst
    tutorial/index.rst
-
-.. 
-..  - Reference for the [pyb module](module/pyb/ "pyb module").
-..  - Reference for [all modules](module/ "all modules").
-..  - [Guide for setting up the pyboard on Windows](/static/doc/Micro-Python-Windows-setup.pdf), including DFU programming (PDF).
-
-The pyboard hardware
---------------------
-
-..  - PYBv1.0 [schematics and layout](/static/doc/PYBv10b.pdf "PYBv1.0") (2.4MiB PDF).
-..  - PYBv1.0 [metric dimensions](/static/doc/PYBv10b-metric-dimensions.pdf "metric dimensions") (360KiB PDF).
-..  - PYBv1.0 [imperial dimensions](/static/doc/PYBv10b-imperial-dimensions.pdf "imperial dimensions") (360KiB PDF).
-
-Datasheets for the components on the pyboard
---------------------------------------------
-
-..  - The microcontroller: [STM32F405RGT6](http://www.st.com/web/catalog/mmc/FM141/SC1169/SS1577/LN1035/PF252144) (external link).
-..  - The accelerometer: [Freescale MMA7660](/static/doc/MMA7660FC.pdf) (800kiB PDF).
-..  - The LDO voltage regulator: [Microchip MCP1802](/static/doc/MCP1802-22053C.pdf) (400kiB PDF).
-
+   library/index.rst
+   hardware/index.rst
+   license.rst
+   contents.rst
 
 Indices and tables
 ==================
@@ -40,4 +17,3 @@ Indices and tables
 * :ref:`genindex`
 * :ref:`modindex`
 * :ref:`search`
-

docs/library/cmath.rst

@@ -0,0 +1,58 @@
+:mod:`cmath` -- mathematical functions for complex numbers
+==========================================================
+
+.. module:: cmath
+   :synopsis: mathematical functions for complex numbers
+
+The ``cmath`` module provides some basic mathematical funtions for
+working with complex numbers.
+
+Functions
+---------
+
+.. function:: cos(z)
+
+   Return the cosine of ``z``.
+
+.. function:: exp(z)
+
+   Return the exponential of ``z``.
+
+.. function:: log(z)
+
+   Return the natural logarithm of ``z``.  The branch cut is along the negative real axis.
+
+.. function:: log10(z)
+
+   Return the base-10 logarithm of ``z``.  The branch cut is along the negative real axis.
+
+.. function:: phase(z)
+
+   Returns the phase of the number ``z``, in the range (-pi, +pi].
+
+.. function:: polar(z)
+
+   Returns, as a tuple, the polar form of ``z``.
+
+.. function:: rect(r, phi)
+
+   Returns the complex number with modulus ``r`` and phase ``phi``.
+
+.. function:: sin(z)
+
+   Return the sine of ``z``.
+
+.. function:: sqrt(z)
+
+   Return the square-root of ``z``.
+
+Constants
+---------
+
+.. data:: e
+
+   base of the natural logarithm
+
+.. data:: pi
+
+   the ratio of a circle's circumference to its diameter

docs/library/gc.rst

@@ -0,0 +1,29 @@
+:mod:`gc` -- control the garbage collector
+==========================================
+
+.. module:: gc
+   :synopsis: control the garbage collector
+
+Functions
+---------
+
+.. function:: enable()
+
+   Enable automatic garbage collection.
+
+.. function:: disable()
+
+   Disable automatic garbage collection.  Heap memory can still be allocated,
+   and garbage collection can still be initiated manually using :meth:`gc.collect`.
+
+.. function:: collect()
+
+   Run a garbage collection.
+
+.. function:: mem_alloc()
+
+   Return the number of bytes of heap RAM that are allocated.
+
+.. function:: mem_free()
+
+   Return the number of bytes of available heap RAM.

docs/library/index.rst

@@ -0,0 +1,58 @@
+Micro Python libraries
+======================
+
+Python standard libraries
+-------------------------
+
+The following standard Python libraries are built in to Micro Python.
+
+For additional libraries, please download them from the `micropython-lib repository
+<https://github.com/micropython/micropython-lib>`_.
+
+.. toctree::
+   :maxdepth: 1
+
+   cmath.rst
+   gc.rst
+   math.rst
+   os.rst
+   select.rst
+   struct.rst
+   sys.rst
+   time.rst
+
+Python micro-libraries
+----------------------
+
+The following standard Python libraries have been "micro-ified" to fit in with
+the philosophy of Micro Python.  They provide the core functionality of that
+module and are intended to be a drop-in replacement for the standard Python
+library.
+
+The modules are available by their u-name, and also by their non-u-name.  The
+non-u-name can be overridden by a file of that name in your package path.
+For example, ``import json`` will first search for a file ``json.py`` or
+directory ``json`` and load that package if it is found.  If nothing is found,
+it will fallback to loading the built-in ``ujson`` module.
+
+.. toctree::
+   :maxdepth: 1
+
+   ubinascii.rst
+   uhashlib.rst
+   uheapq.rst
+   ujson.rst
+   ure.rst
+   usocket.rst
+   uzlib.rst
+
+Libraries specific to the pyboard
+---------------------------------
+
+The following libraries are specific to the pyboard.
+
+.. toctree::
+   :maxdepth: 2
+
+   pyb.rst
+   network.rst

docs/library/math.rst

@@ -0,0 +1,177 @@
+:mod:`math` -- mathematical functions
+=====================================
+
+.. module:: math
+   :synopsis: mathematical functions
+
+The ``math`` module provides some basic mathematical funtions for
+working with floating-point numbers.
+
+*Note:* On the pyboard, floating-point numbers have 32-bit precision.
+
+Functions
+---------
+
+.. function:: acos(x)
+
+   Return the inverse cosine of ``x``.
+
+.. function:: acosh(x)
+
+   Return the inverse hyperbolic cosine of ``x``.
+
+.. function:: asin(x)
+
+   Return the inverse sine of ``x``.
+
+.. function:: asinh(x)
+
+   Return the inverse hyperbolic sine of ``x``.
+
+.. function:: atan(x)
+
+   Return the inverse tangent of ``x``.
+
+.. function:: atan2(y, x)
+
+   Return the principal value of the inverse tangent of ``y/x``.
+
+.. function:: atanh(x)
+
+   Return the inverse hyperbolic tangent of ``x``.
+
+.. function:: ceil(x)
+
+   Return an integer, being ``x`` rounded towards positive infinity.
+
+.. function:: copysign(x, y)
+
+   Return ``x`` with the sign of ``y``.
+
+.. function:: cos(x)
+
+   Return the cosine of ``x``.
+
+.. function:: cosh(x)
+
+   Return the hyperbolic cosine of ``x``.
+
+.. function:: degrees(x)
+
+   Return radians ``x`` converted to degrees.
+
+.. function:: erf(x)
+
+   Return the error function of ``x``.
+
+.. function:: erfc(x)
+
+   Return the complementary error function of ``x``.
+
+.. function:: exp(x)
+
+   Return the exponential of ``x``.
+
+.. function:: expm1(x)
+
+   Return ``exp(x) - 1``.
+
+.. function:: fabs(x)
+
+   Return the absolute value of ``x``.
+
+.. function:: floor(x)
+
+   Return an integer, being ``x`` rounded towards negative infinity.
+
+.. function:: fmod(x, y)
+
+   Return the remainder of ``x/y``.
+
+.. function:: frexp(x)
+
+   Converts a floating-point number to fractional and integral components.
+
+.. function:: gamma(x)
+
+   Return the gamma function of ``x``.
+
+.. function:: isfinite(x)
+
+   Return ``True`` if ``x`` is finite.
+
+.. function:: isinf(x)
+
+   Return ``True`` if ``x`` is infinite.
+
+.. function:: isnan(x)
+
+   Return ``True`` if ``x`` is not-a-number
+
+.. function:: ldexp(x, exp)
+
+   Return ``x * (2**exp)``.
+
+.. function:: lgamma(x)
+
+   Return the natural logarithm of the gamma function of ``x``.
+
+.. function:: log(x)
+
+   Return the natural logarithm of ``x``.
+
+.. function:: log10(x)
+
+   Return the base-10 logarithm of ``x``.
+
+.. function:: log2(x)
+
+   Return the base-2 logarithm of ``x``.
+
+.. function:: modf(x)
+
+   Return a tuple of two floats, being the fractional and integral parts of
+   ``x``.  Both return values have the same sign as ``x``.
+
+.. function:: pow(x, y)
+
+   Returns ``x`` to the power of ``y``.
+
+.. function:: radians(x)
+
+   Return degrees ``x`` converted to radians.
+
+.. function:: sin(x)
+
+   Return the sine of ``x``.
+
+.. function:: sinh(x)
+
+   Return the hyperbolic sine of ``x``.
+
+.. function:: sqrt(x)
+
+   Return the square root of ``x``.
+
+.. function:: tan(x)
+
+   Return the tangent of ``x``.
+
+.. function:: tanh(x)
+
+   Return the hyperbolic tangent of ``x``.
+
+.. function:: trunc(x)
+
+   Return an integer, being ``x`` rounded towards 0.
+
+Constants
+---------
+
+.. data:: e
+
+   base of the natural logarithm
+
+.. data:: pi
+
+   the ratio of a circle's circumference to its diameter

docs/library/network.rst

@@ -0,0 +1,177 @@
+****************************************
+:mod:`network` --- network configuration
+****************************************
+
+.. module:: network
+   :synopsis: network configuration
+
+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.
+
+For example::
+
+    # configure a specific network interface
+    # see below for examples of specific drivers
+    import network
+    nic = network.Driver(...)
+    print(nic.ifconfig())
+
+    # now use socket as usual
+    import socket
+    addr = socket.getaddrinfo('micropython.org', 80)[0][-1]
+    s = socket.socket()
+    s.connect(addr)
+    s.send(b'GET / HTTP/1.1\r\nHost: micropython.org\r\n\r\n')
+    data = s.recv(1000)
+    s.close()
+
+class CC3K
+==========
+
+This class provides a driver for CC3000 wifi modules.  Example usage::
+
+    import network
+    nic = network.CC3K(pyb.SPI(2), pyb.Pin.board.Y5, pyb.Pin.board.Y4, pyb.Pin.board.Y3)
+    nic.connect('your-ssid', 'your-password')
+    while not nic.isconnected():
+        pyb.delay(50)
+    print(nic.ifconfig())
+
+    # now use socket as usual
+    ...
+
+For this example to work the CC3000 module must have the following connections:
+
+    - MOSI connected to Y8
+    - MISO connected to Y7
+    - CLK connected to Y6
+    - CS connected to Y5
+    - VBEN connected to Y4
+    - IRQ connected to Y3
+
+It is possible to use other SPI busses and other pins for CS, VBEN and IRQ.
+
+Constructors
+------------
+
+.. class:: CC3K(spi, pin_cs, pin_en, pin_irq)
+
+   Create a CC3K driver object, initialise the CC3000 module using the given SPI bus
+   and pins, and return the CC3K object.
+
+   Arguments are:
+
+     - ``spi`` is an :ref:`SPI object <pyb.SPI>` which is the SPI bus that the CC3000 is
+       connected to (the MOSI, MISO and CLK pins).
+     - ``pin_cs`` is a :ref:`Pin object <pyb.Pin>` which is connected to the CC3000 CS pin.
+     - ``pin_en`` is a :ref:`Pin object <pyb.Pin>` which is connected to the CC3000 VBEN pin.
+     - ``pin_irq`` is a :ref:`Pin object <pyb.Pin>` which is connected to the CC3000 IRQ pin.
+
+   All of these objects will be initialised by the driver, so there is no need to
+   initialise them yourself.  For example, you can use::
+
+     nic = network.CC3K(pyb.SPI(2), pyb.Pin.board.Y5, pyb.Pin.board.Y4, pyb.Pin.board.Y3)
+
+Methods
+-------
+
+.. method:: cc3k.connect(ssid, key=None, \*, security=WPA2, bssid=None)
+
+   Connect to a wifi access point using the given SSID, and other security
+   parameters.
+
+.. method:: cc3k.disconnect()
+
+   Disconnect from the wifi access point.
+
+.. method:: cc3k.isconnected()
+
+   Returns True if connected to a wifi access point and has a valid IP address,
+   False otherwise.
+
+.. method:: cc3k.ifconfig()
+
+   Returns a 7-tuple with (ip, subnet mask, gateway, DNS server, DHCP server,
+   MAC address, SSID).
+
+.. method:: cc3k.patch_version()
+
+   Return the version of the patch program (firmware) on the CC3000.
+
+.. method:: cc3k.patch_program('pgm')
+
+   Upload the current firmware to the CC3000.  You must pass 'pgm' as the first
+   argument in order for the upload to proceed.
+
+Constants
+---------
+
+.. data:: CC3K.WEP
+.. data:: CC3K.WPA
+.. data:: CC3K.WPA2
+
+   security type to use
+
+class WIZNET5K
+==============
+
+This class allows you to control WIZnet5x00 Ethernet adaptors based on
+the W5200 and W5500 chipsets (only W5200 tested).
+
+Example usage::
+
+    import network
+    nic = network.WIZNET5K(pyb.SPI(1), pyb.Pin.board.X5, pyb.Pin.board.X4)
+    print(nic.ifconfig())
+
+    # now use socket as usual
+    ...
+
+For this example to work the WIZnet5x00 module must have the following connections:
+
+    - MOSI connected to X8
+    - MISO connected to X7
+    - SCLK connected to X6
+    - nSS connected to X5
+    - nRESET connected to X4
+
+It is possible to use other SPI busses and other pins for nSS and nRESET.
+
+Constructors
+------------
+
+.. class:: WIZNET5K(spi, pin_cs, pin_rst)
+
+   Create a WIZNET5K driver object, initialise the WIZnet5x00 module using the given
+   SPI bus and pins, and return the WIZNET5K object.
+
+   Arguments are:
+
+     - ``spi`` is an :ref:`SPI object <pyb.SPI>` which is the SPI bus that the WIZnet5x00 is
+       connected to (the MOSI, MISO and SCLK pins).
+     - ``pin_cs`` is a :ref:`Pin object <pyb.Pin>` which is connected to the WIZnet5x00 nSS pin.
+     - ``pin_rst`` is a :ref:`Pin object <pyb.Pin>` which is connected to the WIZnet5x00 nRESET pin.
+
+   All of these objects will be initialised by the driver, so there is no need to
+   initialise them yourself.  For example, you can use::
+
+     nic = network.WIZNET5K(pyb.SPI(1), pyb.Pin.board.X5, pyb.Pin.board.X4)
+
+Methods
+-------
+
+.. method:: wiznet5k.ifconfig([(ip, subnet, gateway, dns)])
+
+   Get/set IP address, subnet mask, gateway and DNS.
+
+   When called with no arguments, this method returns a 4-tuple with the above information.
+
+   To set the above values, pass a 4-tuple with the required information.  For example::
+
+    nic.ifconfig(('192.168.0.4', '255.255.255.0', '192.168.0.1', '8.8.8.8'))
+
+.. method:: wiznet5k.regs()
+
+   Dump the WIZnet5x00 registers.  Useful for debugging.

docs/library/os.rst

@@ -0,0 +1,67 @@
+:mod:`os` -- basic "operating system" services
+==============================================
+
+.. module:: os
+   :synopsis: basic "operating system" services
+
+The ``os`` module contains functions for filesystem access and ``urandom``.
+
+Pyboard specifics
+-----------------
+
+The filesystem on the pyboard has ``/`` as the root directory and the
+available physical drives are accessible from here.  They are currently:
+
+    ``/flash``      -- the internal flash filesystem
+
+    ``/sd``         -- the SD card (if it exists)
+
+On boot up, the current directory is ``/flash`` if no SD card is inserted,
+otherwise it is ``/sd``.
+
+Functions
+---------
+
+.. function:: chdir(path)
+
+   Change current directory.
+
+.. function:: getcwd()
+
+   Get the current directory.
+
+.. function:: listdir([dir])
+
+   With no argument, list the current directory.  Otherwise list the given directory.
+
+.. function:: mkdir(path)
+
+   Create a new directory.
+
+.. function:: remove(path)
+
+   Remove a file.
+
+.. function:: rmdir(path)
+
+   Remove a directory.
+
+.. function:: stat(path)
+
+   Get the status of a file or directory.
+
+.. function:: sync()
+
+   Sync all filesystems.
+
+.. function:: urandom(n)
+
+   Return a bytes object with n random bytes, generated by the hardware
+   random number generator.
+
+Constants
+---------
+
+.. data:: sep
+
+   separation character used in paths

docs/library/pyb.ADC.rst

@@ -0,0 +1,52 @@
+.. _pyb.ADC:
+
+class ADC -- analog to digital conversion: read analog values on a pin
+======================================================================
+
+Usage::
+
+    import pyb
+
+    adc = pyb.ADC(pin)              # create an analog object from a pin
+    val = adc.read()                # read an analog value
+
+    adc = pyb.ADCAll(resolution)    # creale an ADCAll object
+    val = adc.read_channel(channel) # read the given channel
+    val = adc.read_core_temp()      # read MCU temperature
+    val = adc.read_core_vbat()      # read MCU VBAT
+    val = adc.read_core_vref()      # read MCU VREF
+
+
+Constructors
+------------
+
+.. class:: pyb.ADC(pin)
+
+   Create an ADC object associated with the given pin.
+   This allows you to then read analog values on that pin.
+
+
+Methods
+-------
+
+.. method:: adc.read()
+
+   Read the value on the analog pin and return it.  The returned value
+   will be between 0 and 4095.
+
+.. method:: adc.read_timed(buf, freq)
+
+   Read analog values into the given buffer at the given frequency. Buffer
+   can be bytearray or array.array for example. If a buffer with 8-bit elements
+   is used, sample resolution will be reduced to 8 bits.
+   
+   Example::
+   
+       adc = pyb.ADC(pyb.Pin.board.X19)    # create an ADC on pin X19
+       buf = bytearray(100)                # create a buffer of 100 bytes
+       adc.read_timed(buf, 10)             # read analog values into buf at 10Hz
+                                           #   this will take 10 seconds to finish
+       for val in buf:                     # loop over all values
+           print(val)                      # print the value out
+   
+   This function does not allocate any memory.

docs/library/pyb.Accel.rst

@@ -0,0 +1,51 @@
+class Accel -- accelerometer control
+====================================
+
+Accel is an object that controls the accelerometer.  Example usage::
+
+    accel = pyb.Accel()
+    for i in range(10):
+        print(accel.x(), accel.y(), accel.z())
+
+Raw values are between -32 and 31.
+
+
+Constructors
+------------
+
+.. class:: pyb.Accel()
+
+   Create and return an accelerometer object.
+   
+   Note: if you read accelerometer values immediately after creating this object
+   you will get 0.  It takes around 20ms for the first sample to be ready, so,
+   unless you have some other code between creating this object and reading its
+   values, you should put a ``pyb.delay(20)`` after creating it.  For example::
+   
+       accel = pyb.Accel()
+       pyb.delay(20)
+       print(accel.x())
+
+
+Methods
+-------
+
+.. method:: accel.filtered_xyz()
+
+   Get a 3-tuple of filtered x, y and z values.
+
+.. method:: accel.tilt()
+
+   Get the tilt register.
+
+.. method:: accel.x()
+
+   Get the x-axis value.
+
+.. method:: accel.y()
+
+   Get the y-axis value.
+
+.. method:: accel.z()
+
+   Get the z-axis value.

docs/library/pyb.CAN.rst

@@ -0,0 +1,154 @@
+class CAN -- controller area network communication bus
+======================================================
+
+CAN implements the standard CAN communications protocol.  At
+the physical level it consists of 2 lines: RX and TX.  Note that
+to connect the pyboard to a CAN bus you must use a CAN transceiver
+to convert the CAN logic signals from the pyboard to the correct
+voltage levels on the bus.
+
+Example usage (works without anything connected)::
+
+    from pyb import CAN
+    can = CAN(1, CAN.LOOPBACK)
+    can.setfilter(0, CAN.LIST16, 0, (123, 124, 125, 126))  # set a filter to receive messages with id=123, 124, 125 and 126
+    can.send('message!', 123)   # send a message with id 123
+    can.recv(0)                 # receive message on FIFO 0
+
+
+Constructors
+------------
+
+.. class:: pyb.CAN(bus, ...)
+
+   Construct a CAN object on the given bus.  ``bus`` can be 1-2, or 'YA' or 'YB'.
+   With no additional parameters, the CAN 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 CAN busses are:
+   
+     - ``CAN(1)`` is on ``YA``: ``(RX, TX) = (Y3, Y4) = (PB8, PB9)``
+     - ``CAN(2)`` is on ``YB``: ``(RX, TX) = (Y5, Y6) = (PB12, PB13)``
+
+Class Methods
+-------------
+.. method:: CAN.initfilterbanks(nr)
+   
+   Reset and disable all filter banks and assign how many banks should be available for CAN(1).
+   
+   STM32F405 has 28 filter banks that are shared between the two available CAN bus controllers.
+   This function configures how many filter banks should be assigned to each. ``nr`` is the number of banks 
+   that will be assigned to CAN(1), the rest of the 28 are assigned to CAN(2). 
+   At boot, 14 banks are assigned to each controller.
+ 
+Methods
+-------
+
+.. method:: can.init(mode, extframe=False, prescaler=100, \*, sjw=1, bs1=6, bs2=8)
+
+   Initialise the CAN bus with the given parameters:
+   
+     - ``mode`` is one of:  NORMAL, LOOPBACK, SILENT, SILENT_LOOPBACK
+     - if ``extframe`` is True then the bus uses extended identifiers in the frames
+       (29 bits); otherwise it uses standard 11 bit identifiers
+     - ``prescaler`` is used to set the duration of 1 time quanta; the time quanta
+       will be the input clock (PCLK1, see :meth:`pyb.freq()`) divided by the prescaler
+     - ``sjw`` is the resynchronisation jump width in units of the time quanta;
+       it can be 1, 2, 3, 4
+     - ``bs1`` defines the location of the sample point in units of the time quanta;
+       it can be between 1 and 1024 inclusive
+     - ``bs2`` defines the location of the transmit point in units of the time quanta;
+       it can be between 1 and 16 inclusive
+
+   The time quanta tq is the basic unit of time for the CAN bus.  tq is the CAN
+   prescaler value divided by PCLK1 (the frequency of internal peripheral bus 1);
+   see :meth:`pyb.freq()` to determine PCLK1.
+
+   A single bit is made up of the synchronisation segment, which is always 1 tq.
+   Then follows bit segment 1, then bit segment 2.  The sample point is after bit
+   segment 1 finishes.  The transmit point is after bit segment 2 finishes.
+   The baud rate will be 1/bittime, where the bittime is 1 + BS1 + BS2 multiplied
+   by the time quanta tq.
+
+   For example, with PCLK1=42MHz, prescaler=100, sjw=1, bs1=6, bs2=8, the value of
+   tq is 2.38 microseconds.  The bittime is 35.7 microseconds, and the baudrate
+   is 28kHz.
+
+   See page 680 of the STM32F405 datasheet for more details.
+
+.. method:: can.deinit()
+
+   Turn off the CAN bus.
+
+.. method:: can.setfilter(bank, mode, fifo, params)
+   
+   Configure a filter bank:
+   
+   - ``bank`` is the filter bank that is to be configured.
+   - ``mode`` is the mode the filter should operate in.
+   - ``fifo`` is which fifo (0 or 1) a message should be stored in, if it is accepted by this filter.   
+   - ``params`` is an array of values the defines the filter. The contents of the array depends on the ``mode`` argument.
+    
+   +-----------+---------------------------------------------------------+
+   |``mode``   |contents of parameter array                              |
+   +===========+=========================================================+
+   |CAN.LIST16 |Four 16 bit ids that will be accepted                    |
+   +-----------+---------------------------------------------------------+
+   |CAN.LIST32 |Two 32 bit ids that will be accepted                     |
+   +-----------+---------------------------------------------------------+
+   |CAN.MASK16 |Two 16 bit id/mask pairs. E.g. (1, 3, 4, 4)              |
+   |           | | The first pair, 1 and 3 will accept all ids           |
+   |           | | that have bit 0 = 1 and bit 1 = 0.                    |
+   |           | | The second pair, 4 and 4, will accept all ids         |
+   |           | | that have bit 2 = 1.                                  |
+   +-----------+---------------------------------------------------------+
+   |CAN.MASK32 |As with CAN.MASK16 but with only one 32 bit id/mask pair.|
+   +-----------+---------------------------------------------------------+
+   
+.. method:: can.clearfilter(bank)
+
+   Clear and disables a filter bank:
+   
+   - ``bank`` is the filter bank that is to be cleared.
+
+.. method:: can.any(fifo)
+
+   Return ``True`` if any message waiting on the FIFO, else ``False``.
+
+.. method:: can.recv(fifo, \*, timeout=5000)
+
+   Receive data on the bus:
+   
+     - ``fifo`` is an integer, which is the FIFO to receive on
+     - ``timeout`` is the timeout in milliseconds to wait for the receive.
+   
+   Return value: buffer of data bytes.
+
+.. method:: can.send(send, addr, \*, timeout=5000)
+
+   Send a message on the bus:
+   
+     - ``send`` is the data to send (an integer to send, or a buffer object).
+     - ``addr`` is the address to send to
+     - ``timeout`` is the timeout in milliseconds to wait for the send.
+   
+   Return value: ``None``.
+
+Constants
+---------
+
+.. data:: CAN.NORMAL
+.. data:: CAN.LOOPBACK
+.. data:: CAN.SILENT
+.. data:: CAN.SILENT_LOOPBACK
+
+   the mode of the CAN bus
+
+.. data:: CAN.LIST16
+.. data:: CAN.MASK16
+.. data:: CAN.LIST32
+.. data:: CAN.MASK32
+
+	the operation mode of a filter

docs/library/pyb.DAC.rst

@@ -0,0 +1,69 @@
+.. _pyb.DAC:
+
+class DAC -- digital to analog conversion
+=========================================
+
+The DAC is used to output analog values (a specific voltage) on pin X5 or pin X6.
+The voltage will be between 0 and 3.3V.
+
+*This module will undergo changes to the API.*
+
+Example usage::
+
+    from pyb import DAC
+
+    dac = DAC(1)            # create DAC 1 on pin X5
+    dac.write(128)          # write a value to the DAC (makes X5 1.65V)
+
+To output a continuous sine-wave::
+
+    import math
+    from pyb import DAC
+
+    # create a buffer containing a sine-wave
+    buf = bytearray(100)
+    for i in range(len(buf)):
+        buf[i] = 128 + int(127 \* math.sin(2 \* math.pi \* i / len(buf)))
+
+    # output the sine-wave at 400Hz
+    dac = DAC(1)
+    dac.write_timed(buf, 400 \* len(buf), mode=DAC.CIRCULAR)
+
+
+Constructors
+------------
+
+.. class:: pyb.DAC(port)
+
+   Construct a new DAC object.
+   
+   ``port`` can be a pin object, or an integer (1 or 2).
+   DAC(1) is on pin X5 and DAC(2) is on pin X6.
+
+
+Methods
+-------
+
+.. method:: dac.noise(freq)
+
+   Generate a pseudo-random noise signal.  A new random sample is written
+   to the DAC output at the given frequency.
+
+.. method:: dac.triangle(freq)
+
+   Generate a triangle wave.  The value on the DAC output changes at
+   the given frequency, and the frequence of the repeating triangle wave
+   itself is 256 (or 1024, need to check) times smaller.
+
+.. method:: dac.write(value)
+
+   Direct access to the DAC output (8 bit only at the moment).
+
+.. method:: dac.write_timed(data, freq, \*, mode=DAC.NORMAL)
+
+   Initiates a burst of RAM to DAC using a DMA transfer.
+   The input data is treated as an array of bytes (8 bit data).
+   
+   ``mode`` can be ``DAC.NORMAL`` or ``DAC.CIRCULAR``.
+   
+   TIM6 is used to control the frequency of the transfer.

docs/library/pyb.ExtInt.rst

@@ -0,0 +1,113 @@
+.. _pyb.ExtInt:
+
+class ExtInt -- configure I/O pins to interrupt on external events
+==================================================================
+
+There are a total of 22 interrupt lines. 16 of these can come from GPIO pins
+and the remaining 6 are from internal sources.
+
+For lines 0 thru 15, a given line can map to the corresponding line from an
+arbitrary port. So line 0 can map to Px0 where x is A, B, C, ... and
+line 1 can map to Px1 where x is A, B, C, ... ::
+
+    def callback(line):
+        print("line =", line)
+
+Note: ExtInt will automatically configure the gpio line as an input. ::
+
+    extint = pyb.ExtInt(pin, pyb.ExtInt.IRQ_FALLING, pyb.Pin.PULL_UP, callback)
+
+Now every time a falling edge is seen on the X1 pin, the callback will be
+called. Caution: mechanical pushbuttons have "bounce" and pushing or
+releasing a switch will often generate multiple edges.
+See: http://www.eng.utah.edu/~cs5780/debouncing.pdf for a detailed
+explanation, along with various techniques for debouncing.
+
+Trying to register 2 callbacks onto the same pin will throw an exception.
+
+If pin is passed as an integer, then it is assumed to map to one of the
+internal interrupt sources, and must be in the range 16 thru 22.
+
+All other pin objects go through the pin mapper to come up with one of the
+gpio pins. ::
+
+    extint = pyb.ExtInt(pin, mode, pull, callback)
+
+Valid modes are pyb.ExtInt.IRQ_RISING, pyb.ExtInt.IRQ_FALLING,
+pyb.ExtInt.IRQ_RISING_FALLING, pyb.ExtInt.EVT_RISING,
+pyb.ExtInt.EVT_FALLING, and pyb.ExtInt.EVT_RISING_FALLING.
+
+Only the IRQ_xxx modes have been tested. The EVT_xxx modes have
+something to do with sleep mode and the WFE instruction.
+
+Valid pull values are pyb.Pin.PULL_UP, pyb.Pin.PULL_DOWN, pyb.Pin.PULL_NONE.
+
+There is also a C API, so that drivers which require EXTI interrupt lines
+can also use this code. See extint.h for the available functions and
+usrsw.h for an example of using this.
+
+
+Constructors
+------------
+
+.. class:: pyb.ExtInt(pin, mode, pull, callback)
+
+   Create an ExtInt object:
+   
+     - ``pin`` is the pin on which to enable the interrupt (can be a pin object or any valid pin name).
+     - ``mode`` can be one of:
+       - ``ExtInt.IRQ_RISING`` - trigger on a rising edge;
+       - ``ExtInt.IRQ_FALLING`` - trigger on a falling edge;
+       - ``ExtInt.IRQ_RISING_FALLING`` - trigger on a rising or falling edge.
+     - ``pull`` can be one of:
+       - ``pyb.Pin.PULL_NONE`` - no pull up or down resistors;
+       - ``pyb.Pin.PULL_UP`` - enable the pull-up resistor;
+       - ``pyb.Pin.PULL_DOWN`` - enable the pull-down resistor.
+     - ``callback`` is the function to call when the interrupt triggers.  The
+       callback function must accept exactly 1 argument, which is the line that
+       triggered the interrupt.
+
+
+Class methods
+-------------
+
+.. method:: ExtInt.regs()
+
+   Dump the values of the EXTI registers.
+
+
+Methods
+-------
+
+.. method:: extint.disable()
+
+   Disable the interrupt associated with the ExtInt object.
+   This could be useful for debouncing.
+
+.. method:: extint.enable()
+
+   Enable a disabled interrupt.
+
+.. method:: extint.line()
+
+   Return the line number that the pin is mapped to.
+
+.. method:: extint.swint()
+
+   Trigger the callback from software.
+
+
+Constants
+---------
+
+.. data:: ExtInt.IRQ_FALLING
+
+   interrupt on a falling edge
+
+.. data:: ExtInt.IRQ_RISING
+
+   interrupt on a rising edge
+
+.. data:: ExtInt.IRQ_RISING_FALLING
+
+   interrupt on a rising or falling edge

docs/library/pyb.I2C.rst

@@ -0,0 +1,153 @@
+.. _pyb.I2C:
+
+class I2C -- a two-wire serial protocol
+=======================================
+
+I2C is a two-wire protocol for communicating between devices.  At the physical
+level it consists of 2 wires: SCL and SDA, the clock and data lines respectively.
+
+I2C objects are created attached to a specific bus.  They can be initialised
+when created, or initialised later on::
+
+    from pyb import I2C
+
+    i2c = I2C(1)                         # create on bus 1
+    i2c = I2C(1, I2C.MASTER)             # create and init as a master
+    i2c.init(I2C.MASTER, baudrate=20000) # init as a master
+    i2c.init(I2C.SLAVE, addr=0x42)       # init as a slave with given address
+    i2c.deinit()                         # turn off the peripheral
+
+Printing the i2c object gives you information about its configuration.
+
+Basic methods for slave are send and recv::
+
+    i2c.send('abc')      # send 3 bytes
+    i2c.send(0x42)       # send a single byte, given by the number
+    data = i2c.recv(3)   # receive 3 bytes
+
+To receive inplace, first create a bytearray::
+
+    data = bytearray(3)  # create a buffer
+    i2c.recv(data)       # receive 3 bytes, writing them into data
+
+You can specify a timeout (in ms)::
+
+    i2c.send(b'123', timeout=2000)   # timout after 2 seconds
+
+A master must specify the recipient's address::
+
+    i2c.init(I2C.MASTER)
+    i2c.send('123', 0x42)        # send 3 bytes to slave with address 0x42
+    i2c.send(b'456', addr=0x42)  # keyword for address
+
+Master also has other methods::
+
+    i2c.is_ready(0x42)           # check if slave 0x42 is ready
+    i2c.scan()                   # scan for slaves on the bus, returning
+                                 #   a list of valid addresses
+    i2c.mem_read(3, 0x42, 2)     # read 3 bytes from memory of slave 0x42,
+                                 #   starting at address 2 in the slave
+    i2c.mem_write('abc', 0x42, 2, timeout=1000)
+
+
+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
+   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:
+   
+     - ``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)``
+
+
+Methods
+-------
+
+.. method:: i2c.deinit()
+
+   Turn off the I2C bus.
+
+.. method:: i2c.init(mode, \*, addr=0x12, baudrate=400000, gencall=False)
+
+   Initialise the I2C bus with the given parameters:
+   
+     - ``mode`` must be either ``I2C.MASTER`` or ``I2C.SLAVE``
+     - ``addr`` is the 7-bit address (only sensible for a slave)
+     - ``baudrate`` is the SCL clock rate (only sensible for a master)
+     - ``gencall`` is whether to support general call mode
+
+.. method:: i2c.is_ready(addr)
+
+   Check if an I2C device responds to the given address.  Only valid when in master mode.
+
+.. method:: i2c.mem_read(data, addr, memaddr, timeout=5000, addr_size=8)
+
+   Read from the memory of an I2C device:
+   
+     - ``data`` can be an integer (number of bytes to read) or a buffer to read into
+     - ``addr`` is the I2C device address
+     - ``memaddr`` is the memory location within the I2C device
+     - ``timeout`` is the timeout in milliseconds to wait for the read
+     - ``addr_size`` selects width of memaddr: 8 or 16 bits
+   
+   Returns the read data.
+   This is only valid in master mode.
+
+.. method:: i2c.mem_write(data, addr, memaddr, timeout=5000, addr_size=8)
+
+   Write to the memory of an I2C device:
+   
+     - ``data`` can be an integer or a buffer to write from
+     - ``addr`` is the I2C device address
+     - ``memaddr`` is the memory location within the I2C device
+     - ``timeout`` is the timeout in milliseconds to wait for the write
+     - ``addr_size`` selects width of memaddr: 8 or 16 bits
+   
+   Returns ``None``.
+   This is only valid in master mode.
+
+.. method:: i2c.recv(recv, addr=0x00, timeout=5000)
+
+   Receive data on the bus:
+   
+     - ``recv`` can be an integer, which is the number of bytes to receive,
+       or a mutable buffer, which will be filled with received bytes
+     - ``addr`` is the address to receive from (only required in master mode)
+     - ``timeout`` is the timeout in milliseconds to wait for the receive
+   
+   Return value: if ``recv`` is an integer then a new buffer of the bytes received,
+   otherwise the same buffer that was passed in to ``recv``.
+
+.. method:: i2c.scan()
+
+   Scan all I2C addresses from 0x01 to 0x7f and return a list of those that respond.
+   Only valid when in master mode.
+
+.. method:: i2c.send(send, addr=0x00, timeout=5000)
+
+   Send data on the bus:
+   
+     - ``send`` is the data to send (an integer to send, or a buffer object)
+     - ``addr`` is the address to send to (only required in master mode)
+     - ``timeout`` is the timeout in milliseconds to wait for the send
+   
+   Return value: ``None``.
+
+
+Constants
+---------
+
+.. data:: I2C.MASTER
+
+   for initialising the bus to master mode
+
+.. data:: I2C.SLAVE
+
+   for initialising the bus to slave mode

docs/library/pyb.LCD.rst

@@ -0,0 +1,94 @@
+class LCD -- LCD control for the LCD touch-sensor pyskin
+========================================================
+
+The LCD class is used to control the LCD on the LCD touch-sensor pyskin,
+LCD32MKv1.0.  The LCD is a 128x32 pixel monochrome screen, part NHD-C12832A1Z.
+
+The pyskin must be connected in either the X or Y positions, and then
+an LCD object is made using::
+
+    lcd = pyb.LCD('X')      # if pyskin is in the X position
+    lcd = pyb.LCD('Y')      # if pyskin is in the Y position
+
+Then you can use::
+
+    lcd.light(True)                 # turn the backlight on
+    lcd.write('Hello world!\n')     # print text to the screen
+
+This driver implements a double buffer for setting/getting pixels.
+For example, to make a bouncing dot, try::
+
+    x = y = 0
+    dx = dy = 1
+    while True:
+        # update the dot's position
+        x += dx
+        y += dy
+
+        # make the dot bounce of the edges of the screen
+        if x <= 0 or x >= 127: dx = -dx
+        if y <= 0 or y >= 31: dy = -dy
+
+        lcd.fill(0)                 # clear the buffer
+        lcd.pixel(x, y, 1)          # draw the dot
+        lcd.show()                  # show the buffer
+        pyb.delay(50)               # pause for 50ms
+
+
+Constructors
+------------
+
+.. class:: pyb.LCD(skin_position)
+
+   Construct an LCD object in the given skin position.  ``skin_position`` can be 'X' or 'Y', and
+   should match the position where the LCD pyskin is plugged in.
+
+
+Methods
+-------
+
+.. method:: lcd.command(instr_data, buf)
+
+   Send an arbitrary command to the LCD.  Pass 0 for ``instr_data`` to send an
+   instruction, otherwise pass 1 to send data.  ``buf`` is a buffer with the
+   instructions/data to send.
+
+.. method:: lcd.contrast(value)
+
+   Set the contrast of the LCD.  Valid values are between 0 and 47.
+
+.. method:: lcd.fill(colour)
+
+   Fill the screen with the given colour (0 or 1 for white or black).
+   
+   This method writes to the hidden buffer.  Use ``show()`` to show the buffer.
+
+.. method:: lcd.get(x, y)
+
+   Get the pixel at the position ``(x, y)``.  Returns 0 or 1.
+   
+   This method reads from the visible buffer.
+
+.. method:: lcd.light(value)
+
+   Turn the backlight on/off.  True or 1 turns it on, False or 0 turns it off.
+
+.. method:: lcd.pixel(x, y, colour)
+
+   Set the pixel at ``(x, y)`` to the given colour (0 or 1).
+   
+   This method writes to the hidden buffer.  Use ``show()`` to show the buffer.
+
+.. method:: lcd.show()
+
+   Show the hidden buffer on the screen.
+
+.. method:: lcd.text(str, x, y, colour)
+
+   Draw the given text to the position ``(x, y)`` using the given colour (0 or 1).
+   
+   This method writes to the hidden buffer.  Use ``show()`` to show the buffer.
+
+.. method:: lcd.write(str)
+
+   Write the string ``str`` to the screen.  It will appear immediately.

docs/library/pyb.LED.rst

@@ -0,0 +1,39 @@
+.. _pyb.LED:
+
+class LED -- LED object
+=======================
+
+The LED object controls an individual LED (Light Emitting Diode).
+
+
+Constructors
+------------
+
+.. class:: pyb.LED(id)
+
+   Create an LED object associated with the given LED:
+   
+     - ``id`` is the LED number, 1-4.
+
+
+Methods
+-------
+
+.. method:: led.intensity([value])
+
+   Get or set the LED intensity.  Intensity ranges between 0 (off) and 255 (full on).
+   If no argument is given, return the LED intensity.
+   If an argument is given, set the LED intensity and return ``None``.
+
+.. method:: led.off()
+
+   Turn the LED off.
+
+.. method:: led.on()
+
+   Turn the LED on, to maximum intensity.
+
+.. method:: led.toggle()
+
+   Toggle the LED between on (maximum intensity) and off.  If the LED is at
+   non-zero intensity then it is considered "on" and toggle will turn it off.

docs/library/pyb.Pin.rst

@@ -0,0 +1,266 @@
+.. _pyb.Pin:
+
+class Pin -- control I/O pins
+=============================
+
+A pin is the basic object to control I/O pins.  It has methods to set
+the mode of the pin (input, output, etc) and methods to get and set the
+digital logic level.  For analog control of a pin, see the ADC class.
+
+Usage Model:
+
+All Board Pins are predefined as pyb.Pin.board.Name ::
+
+    x1_pin = pyb.Pin.board.X1
+
+    g = pyb.Pin(pyb.Pin.board.X1, pyb.Pin.IN)
+
+CPU pins which correspond to the board pins are available
+as ``pyb.cpu.Name``. For the CPU pins, the names are the port letter
+followed by the pin number. On the PYBv1.0, ``pyb.Pin.board.X1`` and
+``pyb.Pin.cpu.B6`` are the same pin.
+
+You can also use strings::
+
+    g = pyb.Pin('X1', pyb.Pin.OUT_PP)
+
+Users can add their own names::
+
+    MyMapperDict = { 'LeftMotorDir' : pyb.Pin.cpu.C12 }
+    pyb.Pin.dict(MyMapperDict)
+    g = pyb.Pin("LeftMotorDir", pyb.Pin.OUT_OD)
+
+and can query mappings ::
+
+    pin = pyb.Pin("LeftMotorDir")
+
+Users can also add their own mapping function::
+
+    def MyMapper(pin_name):
+       if pin_name == "LeftMotorDir":
+           return pyb.Pin.cpu.A0
+
+    pyb.Pin.mapper(MyMapper)
+
+So, if you were to call: ``pyb.Pin("LeftMotorDir", pyb.Pin.OUT_PP)``
+then ``"LeftMotorDir"`` is passed directly to the mapper function.
+
+To summarise, the following order determines how things get mapped into
+an ordinal pin number:
+
+1. Directly specify a pin object
+2. User supplied mapping function
+3. User supplied mapping (object must be usable as a dictionary key)
+4. Supply a string which matches a board pin
+5. Supply a string which matches a CPU port/pin
+
+You can set ``pyb.Pin.debug(True)`` to get some debug information about
+how a particular object gets mapped to a pin.
+
+When a pin has the ``Pin.PULL_UP`` or ``Pin.PULL_DOWN`` pull-mode enabled,
+that pin has an effective 40k Ohm resistor pulling it to 3V3 or GND
+respectively (except pin Y5 which has 11k Ohm resistors).
+
+Constructors
+------------
+
+.. class:: pyb.Pin(id, ...)
+
+   Create a new Pin object associated with the id.  If additional arguments are given,
+   they are used to initialise the pin.  See :meth:`pin.init`.
+
+
+Class methods
+-------------
+
+.. method:: Pin.af_list()
+
+   Returns an array of alternate functions available for this pin.
+
+.. method:: Pin.debug([state])
+
+   Get or set the debugging state (``True`` or ``False`` for on or off).
+
+.. method:: Pin.dict([dict])
+
+   Get or set the pin mapper dictionary.
+
+.. method:: Pin.mapper([fun])
+
+   Get or set the pin mapper function.
+
+
+Methods
+-------
+
+.. method:: pin.init(mode, pull=Pin.PULL_NONE, af=-1)
+
+   Initialise the pin:
+   
+     - ``mode`` can be one of:
+       - ``Pin.IN`` - configure the pin for input;
+       - ``Pin.OUT_PP`` - configure the pin for output, with push-pull control;
+       - ``Pin.OUT_OD`` - configure the pin for output, with open-drain control;
+       - ``Pin.AF_PP`` - configure the pin for alternate function, pull-pull;
+       - ``Pin.AF_OD`` - configure the pin for alternate function, open-drain;
+       - ``Pin.ANALOG`` - configure the pin for analog.
+     - ``pull`` can be one of:
+       - ``Pin.PULL_NONE`` - no pull up or down resistors;
+       - ``Pin.PULL_UP`` - enable the pull-up resistor;
+       - ``Pin.PULL_DOWN`` - enable the pull-down resistor.
+     - when mode is Pin.AF_PP or Pin.AF_OD, then af can be the index or name
+       of one of the alternate functions associated with a pin.
+   
+   Returns: ``None``.
+
+.. method:: pin.high()
+
+   Set the pin to a high logic level.
+
+.. method:: pin.low()
+
+   Set the pin to a low logic level.
+
+.. method:: pin.value([value])
+
+   Get or set the digital logic level of the pin:
+
+     - With no argument, return 0 or 1 depending on the logic level of the pin.
+     - With ``value`` given, set the logic level of the pin.  ``value`` can be
+       anything that converts to a boolean.  If it converts to ``True``, the pin
+       is set high, otherwise it is set low.
+
+.. method:: pin.__str__()
+
+   Return a string describing the pin object.
+
+.. method:: pin.af()
+
+   Returns the currently configured alternate-function of the pin. The
+   integer returned will match one of the allowed constants for the af
+   argument to the init function.
+
+.. method:: pin.gpio()
+
+   Returns the base address of the GPIO block associated with this pin.
+
+.. method:: pin.mode()
+
+   Returns the currently configured mode of the pin. The integer returned
+   will match one of the allowed constants for the mode argument to the init
+   function.
+
+.. method:: pin.name()
+
+   Get the pin name.
+
+.. method:: pin.names()
+
+   Returns the cpu and board names for this pin.
+
+.. method:: pin.pin()
+
+   Get the pin number.
+
+.. method:: pin.port()
+
+   Get the pin port.
+
+.. method:: pin.pull()
+
+   Returns the currently configured pull of the pin. The integer returned
+   will match one of the allowed constants for the pull argument to the init
+   function.
+
+
+Constants
+---------
+
+.. data:: Pin.AF_OD
+
+   initialise the pin to alternate-function mode with an open-drain drive
+
+.. data:: Pin.AF_PP
+
+   initialise the pin to alternate-function mode with a push-pull drive
+
+.. data:: Pin.ANALOG
+
+   initialise the pin to analog mode
+
+.. data:: Pin.IN
+
+   initialise the pin to input mode
+
+.. data:: Pin.OUT_OD
+
+   initialise the pin to output mode with an open-drain drive
+
+.. data:: Pin.OUT_PP
+
+   initialise the pin to output mode with a push-pull drive
+
+.. data:: Pin.PULL_DOWN
+
+   enable the pull-down resistor on the pin
+
+.. data:: Pin.PULL_NONE
+
+   don't enable any pull up or down resistors on the pin
+
+.. data:: Pin.PULL_UP
+
+   enable the pull-up resistor on the pin
+
+
+class PinAF -- Pin Alternate Functions
+======================================
+
+A Pin represents a physical pin on the microcprocessor. Each pin
+can have a variety of functions (GPIO, I2C SDA, etc). Each PinAF
+object represents a particular function for a pin.
+
+Usage Model::
+
+    x3 = pyb.Pin.board.X3
+    x3_af = x3.af_list()
+
+x3_af will now contain an array of PinAF objects which are availble on
+pin X3.
+
+For the pyboard, x3_af would contain:
+    [Pin.AF1_TIM2, Pin.AF2_TIM5, Pin.AF3_TIM9, Pin.AF7_USART2]
+
+Normally, each peripheral would configure the af automatically, but sometimes
+the same function is available on multiple pins, and having more control
+is desired.
+
+To configure X3 to expose TIM2_CH3, you could use::
+
+   pin = pyb.Pin(pyb.Pin.board.X3, mode=pyb.Pin.AF_PP, af=pyb.Pin.AF1_TIM2)
+
+or::
+
+   pin = pyb.Pin(pyb.Pin.board.X3, mode=pyb.Pin.AF_PP, af=1)
+
+
+Methods
+-------
+
+.. method:: pinaf.__str__()
+
+   Return a string describing the alternate function.
+
+.. method:: pinaf.index()
+
+   Return the alternate function index.
+
+.. method:: pinaf.name()
+
+   Return the name of the alternate function.
+
+.. method:: pinaf.reg()
+
+   Return the base register associated with the peripheral assigned to this
+   alternate function. For example, if the alternate function were TIM2_CH3
+   this would return stm.TIM2

docs/library/pyb.RTC.rst

@@ -0,0 +1,48 @@
+class RTC -- real time clock
+============================
+
+The RTC is and independent clock that keeps track of the date
+and time.
+
+Example usage::
+
+    rtc = pyb.RTC()
+    rtc.datetime((2014, 5, 1, 4, 13, 0, 0, 0))
+    print(rtc.datetime())
+
+
+Constructors
+------------
+
+.. class:: pyb.RTC()
+
+   Create an RTC object.
+
+
+Methods
+-------
+
+.. method:: rtc.datetime([datetimetuple])
+
+   Get or set the date and time of the RTC.
+   
+   With no arguments, this method returns an 8-tuple with the current
+   date and time.  With 1 argument (being an 8-tuple) it sets the date
+   and time.
+   
+   The 8-tuple has the following format:
+   
+       (year, month, day, weekday, hours, minutes, seconds, subseconds)
+   
+   ``weekday`` is 1-7 for Monday through Sunday.
+   
+   ``subseconds`` counts down from 255 to 0
+
+.. method:: rtc.info()
+
+   Get information about the startup time and reset source.
+   
+    - The lower 0xffff are the number of milliseconds the RTC took to
+      start up.
+    - Bit 0x10000 is set if a power-on reset occurred.
+    - Bit 0x20000 is set if an external reset occurred

docs/library/pyb.SPI.rst

@@ -0,0 +1,123 @@
+.. _pyb.SPI:
+
+class SPI -- a master-driven serial protocol
+============================================
+
+SPI is a serial protocol that is driven by a master.  At the physical level
+there are 3 lines: SCK, MOSI, MISO.
+
+See usage model of I2C; SPI is very similar.  Main difference is
+parameters to init the SPI bus::
+
+    from pyb import SPI
+    spi = SPI(1, SPI.MASTER, baudrate=600000, polarity=1, phase=0, crc=0x7)
+
+Only required parameter is mode, SPI.MASTER or SPI.SLAVE.  Polarity can be
+0 or 1, and is the level the idle clock line sits at.  Phase can be 0 or 1
+to sample data on the first or second clock edge respectively.  Crc can be
+None for no CRC, or a polynomial specifier.
+
+Additional method for SPI::
+
+    data = spi.send_recv(b'1234')        # send 4 bytes and receive 4 bytes
+    buf = bytearray(4)
+    spi.send_recv(b'1234', buf)          # send 4 bytes and receive 4 into buf
+    spi.send_recv(buf, buf)              # send/recv 4 bytes from/to buf
+
+
+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
+   the bus, if any).  If extra arguments are given, the bus is initialised.
+   See ``init`` for parameters of initialisation.
+   
+   The physical pins of the SPI busses are:
+   
+     - ``SPI(1)`` is on the X position: ``(NSS, SCK, MISO, MOSI) = (X5, X6, X7, X8) = (PA4, PA5, PA6, PA7)``
+     - ``SPI(2)`` is on the Y position: ``(NSS, SCK, MISO, MOSI) = (Y5, Y6, Y7, Y8) = (PB12, PB13, PB14, PB15)``
+   
+   At the moment, the NSS pin is not used by the SPI driver and is free
+   for other use.
+
+
+Methods
+-------
+
+.. method:: spi.deinit()
+
+   Turn off the SPI bus.
+
+.. method:: spi.init(mode, baudrate=328125, \*, prescaler, polarity=1, phase=0, bits=8, firstbit=SPI.MSB, ti=False, crc=None)
+
+   Initialise the SPI bus with the given parameters:
+   
+     - ``mode`` must be either ``SPI.MASTER`` or ``SPI.SLAVE``.
+     - ``baudrate`` is the SCK clock rate (only sensible for a master).
+     - ``prescaler`` is the prescaler to use to derive SCK from the APB bus frequency;
+       use of ``prescaler`` overrides ``baudrate``.
+     - ``polarity`` can be 0 or 1, and is the level the idle clock line sits at.
+     - ``phase`` can be 0 or 1 to sample data on the first or second clock edge
+       respectively.
+     - ``firstbit`` can be ``SPI.MSB`` or ``SPI.LSB``.
+     - ``crc`` can be None for no CRC, or a polynomial specifier.
+
+   Note that the SPI clock frequency will not always be the requested baudrate.
+   The hardware only supports baudrates that are the APB bus frequency
+   (see :meth:`pyb.freq`) divided by a prescaler, which can be 2, 4, 8, 16, 32,
+   64, 128 or 256.  SPI(1) is on AHB2, and SPI(2) is on AHB1.  For precise
+   control over the SPI clock frequency, specify ``prescaler`` instead of
+   ``baudrate``.
+
+   Printing the SPI object will show you the computed baudrate and the chosen
+   prescaler.
+
+.. method:: spi.recv(recv, \*, timeout=5000)
+
+   Receive data on the bus:
+   
+     - ``recv`` can be an integer, which is the number of bytes to receive,
+       or a mutable buffer, which will be filled with received bytes.
+     - ``timeout`` is the timeout in milliseconds to wait for the receive.
+   
+   Return value: if ``recv`` is an integer then a new buffer of the bytes received,
+   otherwise the same buffer that was passed in to ``recv``.
+
+.. method:: spi.send(send, \*, timeout=5000)
+
+   Send data on the bus:
+   
+     - ``send`` is the data to send (an integer to send, or a buffer object).
+     - ``timeout`` is the timeout in milliseconds to wait for the send.
+   
+   Return value: ``None``.
+
+.. method:: spi.send_recv(send, recv=None, \*, timeout=5000)
+
+   Send and receive data on the bus at the same time:
+   
+     - ``send`` is the data to send (an integer to send, or a buffer object).
+     - ``recv`` is a mutable buffer which will be filled with received bytes.
+       It can be the same as ``send``, or omitted.  If omitted, a new buffer will
+       be created.
+     - ``timeout`` is the timeout in milliseconds to wait for the receive.
+   
+   Return value: the buffer with the received bytes.
+
+
+Constants
+---------
+
+.. data:: SPI.MASTER
+.. data:: SPI.SLAVE
+
+   for initialising the SPI bus to master or slave mode
+
+.. data:: SPI.LSB
+.. data:: SPI.MSB
+
+   set the first bit to be the least or most significant bit

docs/library/pyb.Servo.rst

@@ -0,0 +1,38 @@
+class Servo -- 3-wire hobby servo driver
+========================================
+
+Servo controls standard hobby servos with 3-wires (ground, power, signal).
+
+
+Constructors
+------------
+
+.. class:: pyb.Servo(id)
+
+   Create a servo object.  ``id`` is 1-4.
+
+
+Methods
+-------
+
+.. method:: servo.angle([angle, time=0])
+
+   Get or set the angle of the servo.
+   
+     - ``angle`` is the angle to move to in degrees.
+     - ``time`` is the number of milliseconds to take to get to the specified angle.
+
+.. method:: servo.calibration([pulse_min, pulse_max, pulse_centre, [pulse_angle_90, pulse_speed_100]])
+
+   Get or set the calibration of the servo timing.
+
+.. method:: servo.pulse_width([value])
+
+   Get or set the pulse width in milliseconds.
+
+.. method:: servo.speed([speed, time=0])
+
+   Get or set the speed of a continuous rotation servo.
+   
+     - ``speed`` is the speed to move to change to, between -100 and 100.
+     - ``time`` is the number of milliseconds to take to get to the specified speed.

docs/library/pyb.Switch.rst

@@ -0,0 +1,37 @@
+class Switch -- switch object
+=============================
+
+A Switch object is used to control a push-button switch.
+
+Usage::
+
+     sw = pyb.Switch()       # create a switch object
+     sw()                    # get state (True if pressed, False otherwise)
+     sw.callback(f)          # register a callback to be called when the
+                             #   switch is pressed down
+     sw.callback(None)       # remove the callback
+
+Example::
+
+     pyb.Switch().callback(lambda: pyb.LED(1).toggle())
+
+
+Constructors
+------------
+
+.. class:: pyb.Switch()
+
+   Create and return a switch object.
+
+
+Methods
+-------
+
+.. method:: switch()
+
+   Return the switch state: ``True`` if pressed down, ``False`` otherwise.
+
+.. method:: switch.callback(fun)
+
+   Register the given function to be called when the switch is pressed down.
+   If ``fun`` is ``None``, then it disables the callback.

docs/library/pyb.Timer.rst

@@ -0,0 +1,234 @@
+.. _pyb.Timer:
+
+class Timer -- control internal timers
+======================================
+
+Timers can be used for a great variety of tasks.  At the moment, only
+the simplest case is implemented: that of calling a function periodically.
+
+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,
+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(freq=2)                # trigger at 2Hz
+    tim.callback(lambda t:pyb.LED(1).toggle())
+
+Further examples::
+
+    tim = pyb.Timer(4, freq=100)    # freq in Hz
+    tim = pyb.Timer(4, prescaler=0, period=99)
+    tim.counter()                   # get counter (can also set)
+    tim.prescaler(2)                # set prescaler (can also get)
+    tim.period(199)                 # set period (can also get)
+    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.
+
+
+Constructors
+------------
+
+.. class:: pyb.Timer(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 14, excluding 3.
+
+
+Methods
+-------
+
+.. method:: timer.callback(fun)
+
+   Set the function to be called when the timer triggers.
+   ``fun`` is passed 1 argument, the timer object.
+   If ``fun`` is ``None`` then the callback will be disabled.
+
+.. method:: timer.channel(channel, mode, ...)
+
+   If only a channel number is 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.
+   
+   Each channel can be configured to perform pwm, output compare, or
+   input capture. All channels share the same underlying timer, which means
+   that they share the same timer clock.
+   
+   Keyword arguments:
+   
+     - ``mode`` can be one of:
+
+       - ``Timer.PWM`` --- configure the timer in PWM mode (active high).
+       - ``Timer.PWM_INVERTED`` --- configure the timer in PWM mode (active low).
+       - ``Timer.OC_TIMING`` --- indicates that no pin is driven.
+       - ``Timer.OC_ACTIVE`` --- the pin will be made active when a compare match occurs (active is determined by polarity)
+       - ``Timer.OC_INACTIVE`` --- the pin will be made inactive when a compare match occurs.
+       - ``Timer.OC_TOGGLE`` --- the pin will be toggled when an compare match occurs.
+       - ``Timer.OC_FORCED_ACTIVE`` --- the pin is forced active (compare match is ignored).
+       - ``Timer.OC_FORCED_INACTIVE`` --- the pin is forced inactive (compare match is ignored).
+       - ``Timer.IC`` --- configure the timer in Input Capture mode.
+   
+     - ``callback`` - as per TimerChannel.callback()
+   
+     - ``pin`` None (the default) or a Pin object. If specified (and not None)
+       this will cause the alternate function of the the indicated pin
+       to be configured for this timer channel. An error will be raised if
+       the pin doesn't support any alternate functions for this timer channel.
+   
+   Keyword arguments for Timer.PWM modes:
+   
+     - ``pulse_width`` - determines the initial pulse width value to use.
+     - ``pulse_width_percent`` - determines the initial pulse width percentage to use.
+   
+   Keyword arguments for Timer.OC modes:
+   
+     - ``compare`` - determines the initial value of the compare register.
+   
+     - ``polarity`` can be one of:
+       - ``Timer.HIGH`` - output is active high
+       - ``Timer.LOW`` - output is acive low
+   
+   Optional keyword arguments for Timer.IC modes:
+   
+     - ``polarity`` can be one of:
+       - ``Timer.RISING`` - captures on rising edge.
+       - ``Timer.FALLING`` - captures on falling edge.
+       - ``Timer.BOTH`` - captures on both edges.
+   
+     Note that capture only works on the primary channel, and not on the
+     complimentary channels.
+   
+   PWM Example::
+   
+       timer = pyb.Timer(2, freq=1000)
+       ch2 = timer.channel(2, pyb.Timer.PWM, pin=pyb.Pin.board.X2, pulse_width=210000)
+       ch3 = timer.channel(3, pyb.Timer.PWM, pin=pyb.Pin.board.X3, pulse_width=420000)
+
+.. method:: timer.counter([value])
+
+   Get or set the timer counter.
+
+.. method:: timer.deinit()
+
+   Deinitialises the timer.
+   
+   Disables the callback (and the associated irq).
+   Disables any channel callbacks (and the associated irq).
+   Stops the timer, and disables the timer peripheral.
+
+.. method:: timer.freq([value])
+
+   Get or set the frequency for the timer (changes prescaler and period if set).
+
+.. method:: timer.init(\*, freq, prescaler, period)
+
+   Initialise the timer.  Initialisation must be either by frequency (in Hz)
+   or by prescaler and period::
+   
+       tim.init(freq=100)                  # set the timer to trigger at 100Hz
+       tim.init(prescaler=83, period=999)  # set the prescaler and period directly
+   
+   Keyword arguments:
+   
+     - ``freq`` --- specifies the periodic frequency of the timer. You migh also
+       view this as the frequency with which the timer goes through one complete cycle.
+   
+     - ``prescaler`` [0-0xffff] - specifies the value to be loaded into the
+       timer's Prescaler Register (PSC). The timer clock source is divided by
+       (``prescaler + 1``) to arrive at the timer clock. Timers 2-7 and 12-14
+       have a clock source of 84 MHz (pyb.freq()[2] \* 2), and Timers 1, and 8-11
+       have a clock source of 168 MHz (pyb.freq()[3] \* 2).
+   
+     - ``period`` [0-0xffff] for timers 1, 3, 4, and 6-15. [0-0x3fffffff] for timers 2 & 5.
+       Specifies the value to be loaded into the timer's AutoReload
+       Register (ARR). This determines the period of the timer (i.e. when the
+       counter cycles). The timer counter will roll-over after ``period + 1``
+       timer clock cycles.
+   
+     - ``mode`` can be one of:
+
+       - ``Timer.UP`` - configures the timer to count from 0 to ARR (default)
+       - ``Timer.DOWN`` - configures the timer to count from ARR down to 0.
+       - ``Timer.CENTER`` - confgures the timer to count from 0 to ARR and
+         then back down to 0.
+   
+     - ``div`` can be one of 1, 2, or 4. Divides the timer clock to determine
+       the sampling clock used by the digital filters.
+   
+     - ``callback`` - as per Timer.callback()
+   
+     - ``deadtime`` - specifies the amount of "dead" or inactive time between
+       transitions on complimentary channels (both channels will be inactive)
+       for this time). ``deadtime`` may be an integer between 0 and 1008, with
+       the following restrictions: 0-128 in steps of 1. 128-256 in steps of
+       2, 256-512 in steps of 8, and 512-1008 in steps of 16. ``deadime``
+       measures ticks of ``source_freq`` divided by ``div`` clock ticks.
+       ``deadtime`` is only available on timers 1 and 8.
+   
+    You must either specify freq or both of period and prescaler.
+
+.. method:: timer.period([value])
+
+   Get or set the period of the timer.
+
+.. method:: timer.prescaler([value])
+
+   Get or set the prescaler for the timer.
+
+.. method:: timer.source_freq()
+
+   Get the frequency of the source of the timer.
+
+class TimerChannel --- setup a channel for a timer
+==================================================
+
+Timer channels are used to generate/capture a signal using a timer.
+
+TimerChannel objects are created using the Timer.channel() method.
+
+Methods
+-------
+
+.. method:: timerchannel.callback(fun)
+
+   Set the function to be called when the timer channel triggers.
+   ``fun`` is passed 1 argument, the timer object.
+   If ``fun`` is ``None`` then the callback will be disabled.
+
+.. method:: timerchannel.capture([value])
+
+   Get or set the capture value associated with a channel.
+   capture, compare, and pulse_width are all aliases for the same function.
+   capture is the logical name to use when the channel is in input capture mode.
+
+.. method:: timerchannel.compare([value])
+
+   Get or set the compare value associated with a channel.
+   capture, compare, and pulse_width are all aliases for the same function.
+   compare is the logical name to use when the channel is in output compare mode.
+
+.. method:: timerchannel.pulse_width([value])
+
+   Get or set the pulse width value associated with a channel.
+   capture, compare, and pulse_width are all aliases for the same function.
+   pulse_width is the logical name to use when the channel is in PWM mode.
+   
+   In edge aligned mode, a pulse_width of ``period + 1`` corresponds to a duty cycle of 100%
+   In center aligned mode, a pulse width of ``period`` corresponds to a duty cycle of 100%
+
+.. method:: timerchannel.pulse_width_percent([value])
+
+   Get or set the pulse width percentage associated with a channel.  The value
+   is a number between 0 and 100 and sets the percentage of the timer period
+   for which the pulse is active.  The value can be an integer or
+   floating-point number for more accuracy.  For example, a value of 25 gives
+   a duty cycle of 25%.

docs/library/pyb.UART.rst

@@ -0,0 +1,136 @@
+.. _pyb.UART:
+
+class UART -- duplex serial communication bus
+=============================================
+
+UART implements the standard UART/USART duplex serial communications protocol.  At
+the physical level it consists of 2 lines: RX and TX.  The unit of communication
+is a character (not to be confused with a string character) which can be 8 or 9
+bits wide.
+
+UART objects can be created and initialised using::
+
+    from pyb import UART
+
+    uart = UART(1, 9600)                         # init with given baudrate
+    uart.init(9600, bits=8, parity=None, stop=1) # init with given parameters
+
+Bits can be 7, 8 or 9.  Parity can be None, 0 (even) or 1 (odd).  Stop can be 1 or 2.
+
+*Note:* with parity=None, only 8 and 9 bits are supported.  With parity enabled,
+only 7 and 8 bits are supported.
+
+A UART object acts like a stream object and reading and writing is done
+using the standard stream methods::
+
+    uart.read(10)       # read 10 characters, returns a bytes object
+    uart.readall()      # read all available characters
+    uart.readline()     # read a line
+    uart.readinto(buf)  # read and store into the given buffer
+    uart.write('abc')   # write the 3 characters
+
+Individual characters can be read/written using::
+
+    uart.readchar()     # read 1 character and returns it as an integer
+    uart.writechar(42)  # write 1 character
+
+To check if there is anything to be read, use::
+
+    uart.any()               # returns True if any characters waiting
+
+*Note:* The stream functions ``read``, ``write`` etc Are new in Micro Python since v1.3.4.
+Earlier versions use ``uart.send`` and ``uart.recv``.
+
+Constructors
+------------
+
+.. class:: pyb.UART(bus, ...)
+
+   Construct a UART object on the given bus.  ``bus`` can be 1-6, or 'XA', 'XB', 'YA', or 'YB'.
+   With no additional parameters, the UART 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 UART busses are:
+
+     - ``UART(4)`` is on ``XA``: ``(TX, RX) = (X1, X2) = (PA0, PA1)``
+     - ``UART(1)`` is on ``XB``: ``(TX, RX) = (X9, X10) = (PB6, PB7)``
+     - ``UART(6)`` is on ``YA``: ``(TX, RX) = (Y1, Y2) = (PC6, PC7)``
+     - ``UART(3)`` is on ``YB``: ``(TX, RX) = (Y9, Y10) = (PB10, PB11)``
+     - ``UART(2)`` is on: ``(TX, RX) = (X3, X4) = (PA2, PA3)``
+
+Methods
+-------
+
+.. method:: uart.init(baudrate, bits=8, parity=None, stop=1, \*, timeout=1000, timeout_char=0, read_buf_len=64)
+
+   Initialise the UART bus with the given parameters:
+
+     - ``baudrate`` is the clock rate.
+     - ``bits`` is the number of bits per character, 7, 8 or 9.
+     - ``parity`` is the parity, ``None``, 0 (even) or 1 (odd).
+     - ``stop`` is the number of stop bits, 1 or 2.
+     - ``timeout`` is the timeout in milliseconds to wait for the first character.
+     - ``timeout_char`` is the timeout in milliseconds to wait between characters.
+     - ``read_buf_len`` is the character length of the read buffer (0 to disable).
+
+   *Note:* with parity=None, only 8 and 9 bits are supported.  With parity enabled,
+   only 7 and 8 bits are supported.
+
+.. method:: uart.deinit()
+
+   Turn off the UART bus.
+
+.. method:: uart.any()
+
+   Return ``True`` if any characters waiting, else ``False``.
+
+.. method:: uart.read([nbytes])
+
+   Read characters.  If ``nbytes`` is specified then read at most that many bytes.
+
+   *Note:* for 9 bit characters each character takes two bytes, ``nbytes`` must
+   be even, and the number of characters is ``nbytes/2``.
+
+   Return value: a bytes object containing the bytes read in.  Returns ``b''``
+   on timeout.
+
+.. method:: uart.readall()
+
+   Read as much data as possible.
+
+   Return value: a bytes object.
+
+.. method:: uart.readchar()
+
+   Receive a single character on the bus.
+
+   Return value: The character read, as an integer.  Returns -1 on timeout.
+
+.. method:: uart.readinto(buf[, nbytes])
+
+   Read bytes into the ``buf``.  If ``nbytes`` is specified then read at most
+   that many bytes.  Otherwise, read at most ``len(buf)`` bytes.
+
+   Return value: number of bytes read and stored into ``buf``.
+
+.. method:: uart.readline()
+
+   Read a line, ending in a newline character.
+
+   Return value: the line read.
+
+.. method:: uart.write(buf)
+
+   Write the buffer of bytes to the bus.  If characters are 7 or 8 bits wide
+   then each byte is one character.  If characters are 9 bits wide then two
+   bytes are used for each character (little endian), and ``buf`` must contain
+   an even number of bytes.
+
+   Return value: number of bytes written.
+
+.. method:: uart.writechar(char)
+
+   Write a single character on the bus.  ``char`` is an integer to write.
+   Return value: ``None``.

docs/library/pyb.USB_VCP.rst

@@ -0,0 +1,66 @@
+class USB_VCP -- USB virtual comm port
+======================================
+
+The USB_VCP class allows creation of an object representing the USB
+virtual comm port.  It can be used to read and write data over USB to
+the connected host.
+
+
+Constructors
+------------
+
+.. class:: pyb.USB_VCP()
+
+   Create a new USB_VCP object.
+
+
+Methods
+-------
+
+.. method:: usb_vcp.setinterrupt(chr)
+
+   Set the character which interrupts running Python code.  This is set
+   to 3 (CTRL-C) by default, and when a CTRL-C character is received over
+   the USB VCP port, a KeyboardInterrupt exception is raised.
+
+   Set to -1 to disable this interrupt feature.  This is useful when you
+   want to send raw bytes over the USB VCP port.
+
+.. method:: usb_vcp.any()
+
+   Return ``True`` if any characters waiting, else ``False``.
+
+.. method:: usb_vcp.close()
+
+
+.. method:: usb_vcp.read([nbytes])
+
+
+.. method:: usb_vcp.readall()
+
+
+.. method:: usb_vcp.readline()
+
+
+.. method:: usb_vcp.recv(data, \*, timeout=5000)
+
+   Receive data on the bus:
+   
+     - ``data`` can be an integer, which is the number of bytes to receive,
+       or a mutable buffer, which will be filled with received bytes.
+     - ``timeout`` is the timeout in milliseconds to wait for the receive.
+   
+   Return value: if ``data`` is an integer then a new buffer of the bytes received,
+   otherwise the number of bytes read into ``data`` is returned.
+
+.. method:: usb_vcp.send(data, \*, timeout=5000)
+
+   Send data over the USB VCP:
+   
+     - ``data`` is the data to send (an integer to send, or a buffer object).
+     - ``timeout`` is the timeout in milliseconds to wait for the send.
+   
+   Return value: number of bytes sent.
+
+.. method:: usb_vcp.write(buf)
+

docs/library/pyb.rst

@@ -0,0 +1,225 @@
+:mod:`pyb` --- functions related to the pyboard
+===============================================
+
+.. module:: pyb
+   :synopsis: functions related to the pyboard
+
+The ``pyb`` module contains specific functions related to the pyboard.
+
+Time related functions
+----------------------
+
+.. function:: delay(ms)
+
+   Delay for the given number of milliseconds.
+
+.. function:: udelay(us)
+
+   Delay for the given number of microseconds.
+
+.. function:: millis()
+
+   Returns the number of milliseconds since the board was last reset.
+   
+   The result is always a micropython smallint (31-bit signed number), so
+   after 2^30 milliseconds (about 12.4 days) this will start to return
+   negative numbers.
+
+.. function:: micros()
+
+   Returns the number of microseconds since the board was last reset.
+   
+   The result is always a micropython smallint (31-bit signed number), so
+   after 2^30 microseconds (about 17.8 minutes) this will start to return
+   negative numbers.
+
+.. function:: elapsed_millis(start)
+
+   Returns the number of milliseconds which have elapsed since ``start``.
+   
+   This function takes care of counter wrap, and always returns a positive
+   number. This means it can be used to measure periods upto about 12.4 days.
+   
+   Example::
+
+       start = pyb.millis()
+       while pyb.elapsed_millis(start) < 1000:
+           # Perform some operation
+
+.. function:: elapsed_micros(start)
+
+   Returns the number of microseconds which have elapsed since ``start``.
+   
+   This function takes care of counter wrap, and always returns a positive
+   number. This means it can be used to measure periods upto about 17.8 minutes.
+   
+   Example::
+
+       start = pyb.micros()
+       while pyb.elapsed_micros(start) < 1000:
+           # Perform some operation
+           pass
+
+Reset related functions
+-----------------------
+
+.. function:: hard_reset()
+
+   Resets the pyboard in a manner similar to pushing the external RESET
+   button.
+
+.. function:: bootloader()
+
+   Activate the bootloader without BOOT\* pins.
+
+Interrupt related functions
+---------------------------
+
+.. function:: disable_irq()
+
+   Disable interrupt requests.
+   Returns the previous IRQ state: ``False``/``True`` for disabled/enabled IRQs
+   respectively.  This return value can be passed to enable_irq to restore
+   the IRQ to its original state.
+
+.. function:: enable_irq(state=True)
+
+   Enable interrupt requests.
+   If ``state`` is ``True`` (the default value) then IRQs are enabled.
+   If ``state`` is ``False`` then IRQs are disabled.  The most common use of
+   this function is to pass it the value returned by ``disable_irq`` to
+   exit a critical section.
+
+Power related functions
+-----------------------
+
+.. function:: freq([sysclk[, hclk[, pclk1[, pclk2]]]])
+
+   If given no arguments, returns a tuple of clock frequencies:
+   (sysclk, hclk, pclk1, pclk2).
+   These correspond to:
+    - sysclk: frequency of the CPU
+    - hclk: frequency of the AHB bus, core memory and DMA
+    - pclk1: frequency of the APB1 bus
+    - pclk2: frequency of the APB2 bus
+
+   If given any arguments then the function sets the frequency of the CPU,
+   and the busses if additional arguments are given.  Frequencies are given in
+   Hz.  Eg freq(120000000) sets sysclk (the CPU frequency) to 120MHz.  Note that
+   not all values are supported and the largest supported frequency not greater
+   than the given value will be selected.
+
+   Supported sysclk frequencies are (in MHz): 8, 16, 24, 30, 32, 36, 40, 42, 48,
+   54, 56, 60, 64, 72, 84, 96, 108, 120, 144, 168.
+
+   The hclk, pclk1 and pclk2 frequencies are derived from the sysclk frequency
+   using a prescaler (divider).  Supported prescalers for hclk are: 1, 2, 4, 8,
+   16, 64, 128, 256, 512.  Supported prescalers for pclk1 and pclk2 are: 1, 2,
+   4, 8.  A prescaler will be chosen to best match the requested frequency.
+
+   A sysclk frequency of
+   8MHz uses the HSE (external crystal) directly and 16MHz uses the HSI
+   (internal oscillator) directly.  The higher frequencies use the HSE to
+   drive the PLL (phase locked loop), and then use the output of the PLL.
+
+   Note that if you change the frequency while the USB is enabled then
+   the USB may become unreliable.  It is best to change the frequency
+   in boot.py, before the USB peripheral is started.  Also note that sysclk
+   frequencies below 36MHz do not allow the USB to function correctly.
+
+.. function:: wfi()
+
+   Wait for an interrupt.
+   This executies a ``wfi`` instruction which reduces power consumption
+   of the MCU until an interrupt occurs, at which point execution continues.
+
+.. function:: standby()
+
+
+.. function:: stop()
+
+Miscellaneous functions
+-----------------------
+
+.. function:: have_cdc()
+
+   Return True if USB is connected as a serial device, False otherwise.
+
+.. function:: hid((buttons, x, y, z))
+
+   Takes a 4-tuple (or list) and sends it to the USB host (the PC) to
+   signal a HID mouse-motion event.
+
+.. function:: info([dump_alloc_table])
+
+   Print out lots of information about the board.
+
+.. function:: mount(device, mountpoint, \*, readonly=False, mkfs=False)
+
+   Mount a block device and make it available as part of the filesystem.
+   ``device`` must be an object that provides the block protocol:
+
+    - ``readblocks(self, blocknum, buf)``
+    - ``writeblocks(self, blocknum, buf)`` (optional)
+    - ``count(self)``
+    - ``sync(self)`` (optional)
+
+   ``readblocks`` and ``writeblocks`` should copy data between ``buf`` and
+   the block device, starting from block number ``blocknum`` on the device.
+   ``buf`` will be a bytearray with length a multiple of 512.  If
+   ``writeblocks`` is not defined then the device is mounted read-only.
+   The return value of these two functions is ignored.
+
+   ``count`` should return the number of blocks available on the device.
+   ``sync``, if implemented, should sync the data on the device.
+
+   The parameter ``mountpoint`` is the location in the root of the filesystem
+   to mount the device.  It must begin with a forward-slash.
+
+   If ``readonly`` is ``True``, then the device is mounted read-only,
+   otherwise it is mounted read-write.
+
+   If ``mkfs`` is ``True``, then a new filesystem is created if one does not
+   already exist.
+
+   To unmount a device, pass ``None`` as the device and the mount location
+   as ``mountpoint``.
+
+.. function:: repl_uart(uart)
+
+   Get or set the UART object that the REPL is repeated on.
+
+.. function:: rng()
+
+   Return a 30-bit hardware generated random number.
+
+.. function:: sync()
+
+   Sync all file systems.
+
+.. function:: unique_id()
+
+   Returns a string of 12 bytes (96 bits), which is the unique ID for the MCU.
+
+Classes
+-------
+
+.. toctree::
+   :maxdepth: 1
+
+   pyb.Accel.rst
+   pyb.ADC.rst
+   pyb.CAN.rst
+   pyb.DAC.rst
+   pyb.ExtInt.rst
+   pyb.I2C.rst
+   pyb.LCD.rst
+   pyb.LED.rst
+   pyb.Pin.rst
+   pyb.RTC.rst
+   pyb.Servo.rst
+   pyb.SPI.rst
+   pyb.Switch.rst
+   pyb.Timer.rst
+   pyb.UART.rst
+   pyb.USB_VCP.rst

docs/library/select.rst

@@ -0,0 +1,57 @@
+:mod:`select` -- wait for events on a set of streams
+========================================================================
+
+.. module:: select
+   :synopsis: wait for events on a set of streams
+
+This module provides functions to wait for events on streams (select streams
+which are ready for operations).
+
+Pyboard specifics
+-----------------
+
+Polling is an efficient way of waiting for read/write activity on multiple
+objects.  Current objects that support polling are: :class:`pyb.UART`,
+:class:`pyb.USB_VCP`.
+
+Functions
+---------
+
+.. function:: poll()
+
+   Create an instance of the Poll class.
+
+.. function:: select(rlist, wlist, xlist[, timeout])
+
+   Wait for activity on a set of objects.
+
+   This function is provided for compatibility and is not efficient. Usage
+   of :class:`Poll` is recommended instead.
+
+.. _class: Poll
+
+class ``Poll``
+--------------
+
+Methods
+~~~~~~~
+
+.. method:: poll.register(obj[, eventmask])
+
+   Register ``obj`` for polling.  ``eventmask`` is 1 for read, 2 for
+   write, 3 for read-write.
+
+.. method:: poll.unregister(obj)
+
+   Unregister ``obj`` from polling.
+
+.. method:: poll.modify(obj, eventmask)
+
+   Modify the ``eventmask`` for ``obj``.
+
+.. method:: poll.poll([timeout])
+
+   Wait for at least one of the registered objects to become ready. Returns
+   list of ready objects, or empty list on timeout.
+
+   Timeout is in milliseconds.

docs/library/struct.rst

@@ -0,0 +1,25 @@
+:mod:`struct` -- pack and unpack primitive data types
+=====================================================
+
+.. module:: struct
+   :synopsis: pack and unpack primitive data types
+
+See `Python struct <https://docs.python.org/3/library/struct.html>`_ for more
+information.
+
+Functions
+---------
+
+.. function:: calcsize(fmt)
+
+   Return the number of bytes needed to store the given ``fmt``.
+
+.. function:: pack(fmt, v1, v2, ...)
+
+   Pack the values ``v1``, ``v2``, ... according to the format string ``fmt``.
+   The return value is a bytes object encoding the values.
+
+.. function:: unpack(fmt, data)
+
+   Unpack from the ``data`` according to the format string ``fmt``.
+   The return value is a tuple of the unpacked values.

docs/library/sys.rst

@@ -0,0 +1,64 @@
+:mod:`sys` -- system specific functions
+=======================================
+
+.. module:: sys
+   :synopsis: system specific functions
+
+Functions
+---------
+
+.. function:: exit([retval])
+
+   Raise a ``SystemExit`` exception.  If an argument is given, it is the
+   value given to ``SystemExit``.
+
+.. function:: print_exception(exc, [file])
+
+   Print exception with a traceback to a file-like object ``file`` (or
+   ``sys.stdout`` by default).
+
+   .. admonition:: Difference to CPython
+      :class: attention
+
+      This function appears in the ``traceback`` module in CPython.
+
+Constants
+---------
+
+.. data:: argv
+
+   a mutable list of arguments this program started with
+
+.. data:: byteorder
+
+   the byte order of the system ("little" or "big")
+
+.. data:: path
+
+   a mutable list of directories to search for imported modules
+
+.. data:: platform
+
+   The platform that Micro Python is running on.  This is "pyboard" on the
+   pyboard and provides a robust way of determining if a script is running
+   on the pyboard or not.
+
+.. data:: stderr
+
+   standard error (connected to USB VCP, and optional UART object)
+
+.. data:: stdin
+
+   standard input (connected to USB VCP, and optional UART object)
+
+.. data:: stdout
+
+   standard output (connected to USB VCP, and optional UART object)
+
+.. data:: version
+
+   Python language version that this implementation conforms to, as a string
+
+.. data:: version_info
+
+   Python language version that this implementation conforms to, as a tuple of ints

docs/library/time.rst

@@ -0,0 +1,41 @@
+:mod:`time` -- time related functions
+=====================================
+
+.. module:: time
+   :synopsis: time related functions
+
+The ``time`` module provides functions for getting the current time and date,
+and for sleeping.
+
+Functions
+---------
+
+.. function:: localtime([secs])
+
+   Convert a time expressed in seconds since Jan 1, 2000 into an 8-tuple which
+   contains: (year, month, mday, hour, minute, second, weekday, yearday)
+   If secs is not provided or None, then the current time from the RTC is used.
+   year includes the century (for example 2014).
+
+   * month   is 1-12
+   * mday    is 1-31
+   * hour    is 0-23
+   * minute  is 0-59
+   * second  is 0-59
+   * weekday is 0-6 for Mon-Sun
+   * yearday is 1-366
+
+.. function:: mktime()
+
+   This is inverse function of localtime. It's argument is a full 8-tuple
+   which expresses a time as per localtime. It returns an integer which is
+   the number of seconds since Jan 1, 2000.
+
+.. function:: sleep(seconds)
+
+   Sleep for the given number of seconds.  Seconds can be a floating-point number to
+   sleep for a fractional number of seconds.
+
+.. function:: time()
+
+   Returns the number of seconds, as an integer, since 1/1/2000.

docs/library/ubinascii.rst

@@ -0,0 +1,15 @@
+:mod:`ubinascii` -- binary/ASCII conversions
+============================================
+
+.. module:: ubinascii
+   :synopsis: binary/ASCII conversions
+
+This module implements conversions between binary data and various
+encodings of it in ASCII form (in both directions).
+
+Functions
+---------
+
+.. function:: hexlify(data)
+
+   Convert binary data to hexadecimal representation. Return bytes string.

docs/library/uhashlib.rst

@@ -0,0 +1,37 @@
+:mod:`uhashlib` -- hashing algorithm
+====================================
+
+.. module:: uhashlib
+   :synopsis: hashing algorithm
+
+This module implements binary data hashing algorithms. Currently, it
+implements SHA256 algorithm. Choosing SHA256 was a deliberate choice,
+as a modern, cryptographically secure algorithm. This means that a
+single algorithm can cover both usecases of "any hash algorithm" and
+security-related usage, and thus save space omitting legacy algorithms
+like MD5 or SHA1.
+
+Constructors
+------------
+
+.. class:: uhashlib.sha256([data])
+
+   Create a hasher object and optionally feed ``data`` into it.
+
+
+Methods
+-------
+
+.. method:: sha256.update(data)
+
+   Feed more binary data into hash.
+
+.. method:: sha256.digest()
+
+   Return hash for all data passed thru hash, as a bytes object. After this
+   method is called, more data cannot be fed into hash any longer.
+
+.. method:: sha256.hexdigest()
+
+   This method is NOT implemented. Use ``ubinascii.hexlify(sha256.digest())``
+   to achieve similar effect.

docs/library/uheapq.rst

@@ -0,0 +1,25 @@
+:mod:`uheapq` -- heap queue algorithm
+=====================================
+
+.. module:: uheapq
+   :synopsis: heap queue algorithm
+
+This module implements the heap queue algorithm.
+
+A heap queue is simply a list that has its elements stored in a certain way.
+
+Functions
+---------
+
+.. function:: heappush(heap, item)
+
+   Push the ``item`` onto the ``heap``.
+
+.. function:: heappop(heap)
+
+   Pop the first item from the ``heap``, and return it.  Raises IndexError if
+   heap is empty.
+
+.. function:: heapify(x)
+
+   Convert the list ``x`` into a heap.  This is an in-place operation.

docs/library/ujson.rst

@@ -0,0 +1,20 @@
+:mod:`ujson` -- JSON encoding and decoding
+==========================================
+
+.. module:: ujson
+   :synopsis: JSON encoding and decoding
+
+This modules allows to convert between Python objects and the JSON
+data format.
+
+Functions
+---------
+
+.. function:: dumps(obj)
+
+   Return ``obj`` represented as a JSON string.
+
+.. function:: loads(str)
+
+   Parse the JSON ``str`` and return an object.  Raises ValueError if the
+   string is not correctly formed.

docs/library/ure.rst

@@ -0,0 +1,82 @@
+:mod:`ure` -- regular expressions
+=================================
+
+.. module:: ure
+   :synopsis: regular expressions
+
+This module implements regular expression operations. Regular expression
+syntax supported is a subset of CPython ``re`` module (and actually is
+a subset of POSIX extended regular expressions).
+
+Supported operators are:
+
+``'.'``
+   Match any character.
+
+``'[]'``
+   Match set of characters. Individual characters and ranges are supported.
+
+``'^'``
+
+``'$'``
+
+``'?'``
+
+``'*'``
+
+``'+'``
+
+``'??'``
+
+``'*?'``
+
+``'+?'``
+
+Counted repetitions (``{m,n}``), more advanced assertions, names groups,
+etc. are not supported.
+
+
+Functions
+---------
+
+.. function:: compile(regex)
+
+   Compile regular expression, return ``regex`` object.
+
+.. function:: match(regex, string)
+
+   Match ``regex`` against ``string``. Match always happens from starting
+   position in a string.
+
+.. function:: search(regex, string)
+
+   Search ``regex`` in a ``string``. Unlike ``match``, this will search
+   string for first position which matches regex (which still may be
+   0 if regex is anchored).
+
+.. data:: DEBUG
+
+   Flag value, display debug information about compiled expression.
+
+
+Regex objects
+-------------
+
+Compiled regular expression. Instances of this class are created using
+``ure.compile()``.
+
+.. method:: regex.match(string)
+
+.. method:: regex.search(string)
+
+.. method:: regex.split(string, max_split=-1)
+
+
+Match objects
+-------------
+
+Match objects as returned by ``match()`` and ``search()`` methods.
+
+.. method:: match.group([index])
+
+   Only numeric groups are supported.

docs/library/usocket.rst

@@ -0,0 +1,17 @@
+:mod:`usocket` -- socket module
+===============================
+
+.. module:: usocket
+   :synopsis: socket module
+
+Socket functionality.
+
+Functions
+---------
+
+.. function:: getaddrinfo(host, port)
+
+
+.. function:: socket(family=AF_INET, type=SOCK_STREAM, fileno=-1)
+
+   Create a socket.

docs/library/uzlib.rst

@@ -0,0 +1,16 @@
+:mod:`uzlib` -- zlib decompression
+==================================
+
+.. module:: uzlib
+   :synopsis: zlib decompression
+
+This modules allows to decompress binary data compressed with DEFLATE
+algorithm (commonly used in zlib library and gzip archiver). Compression
+is not yet implemented.
+
+Functions
+---------
+
+.. function:: decompress(data)
+
+   Return decompressed data as bytes.

docs/license.rst

@@ -0,0 +1,24 @@
+Micro Python license information
+================================
+
+The MIT License (MIT)
+
+Copyright (c) 2013, 2014 Damien P. George, and others
+
+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.

docs/quickref.rst

@@ -0,0 +1,140 @@
+.. _quickref:
+
+Quick reference for the pyboard
+===============================
+
+.. image:: http://micropython.org/resources/pybv10-pinout.jpg
+    :alt: PYBv1.0 pinout
+    :width: 700px
+
+General board control
+---------------------
+
+See :mod:`pyb`. ::
+
+    import pyb
+
+    pyb.delay(50) # wait 50 milliseconds
+    pyb.millis() # number of milliseconds since bootup
+    pyb.repl_uart(pyb.UART(1, 9600)) # duplicate REPL on UART(1)
+    pyb.wfi() # pause CPU, waiting for interrupt
+    pyb.freq() # get CPU and bus frequencies
+    pyb.freq(60000000) # set CPU freq to 60MHz
+    pyb.stop() # stop CPU, waiting for external interrupt
+
+LEDs
+----
+
+See :ref:`pyb.LED <pyb.LED>`. ::
+
+    from pyb import LED
+
+    led = LED(1) # red led
+    led.toggle()
+    led.on()
+    led.off()
+
+Pins and GPIO
+-------------
+
+See :ref:`pyb.Pin <pyb.Pin>`. ::
+
+    from pyb import Pin
+
+    p_out = Pin('X1', Pin.OUT_PP)
+    p_out.high()
+    p_out.low()
+
+    p_in = Pin('X2', Pin.IN, Pin.PULL_UP)
+    p_in.value() # get value, 0 or 1
+
+External interrupts
+-------------------
+
+See :ref:`pyb.ExtInt <pyb.ExtInt>`. ::
+
+    from pyb import Pin, ExtInt
+
+    callback = lambda e: print("intr")
+    ext = ExtInt(Pin('Y1'), ExtInt.IRQ_RISING, Pin.PULL_NONE, callback)
+
+Timers
+------
+
+See :ref:`pyb.Timer <pyb.Timer>`. ::
+
+    from pyb import Timer
+
+    tim = Timer(1, freq=1000)
+    tim.counter() # get counter value
+    tim.freq(0.5) # 0.5 Hz
+    tim.callback(lambda t: pyb.LED(1).toggle())
+
+PWM (pulse width modulation)
+----------------------------
+
+See :ref:`pyb.Pin <pyb.Pin>` and :ref:`pyb.Timer <pyb.Timer>`. ::
+
+    from pyb import Pin, Timer
+
+    p = Pin('X1') # X1 has TIM2, CH1
+    tim = Timer(2, freq=1000)
+    ch = tim.channel(1, Timer.PWM, pin=p)
+    ch.pulse_width_percent(50)
+
+ADC (analog to digital conversion)
+----------------------------------
+
+See :ref:`pyb.Pin <pyb.Pin>` and :ref:`pyb.ADC <pyb.ADC>`. ::
+
+    from pyb import Pin, ADC
+
+    adc = ADC(Pin('X19'))
+    adc.read() # read value, 0-4095
+
+DAC (digital to analog conversion)
+----------------------------------
+
+See :ref:`pyb.Pin <pyb.Pin>` and :ref:`pyb.DAC <pyb.DAC>`. ::
+
+    from pyb import Pin, DAC
+
+    dac = DAC(Pin('X5'))
+    dac.write(120) # output between 0 and 255
+
+UART (serial bus)
+-----------------
+
+See :ref:`pyb.UART <pyb.UART>`. ::
+
+    from pyb import UART
+
+    uart = UART(1, 9600)
+    uart.write('hello')
+    uart.read(5) # read up to 5 bytes
+
+SPI bus
+-------
+
+See :ref:`pyb.SPI <pyb.SPI>`. ::
+
+    from pyb import SPI
+
+    spi = SPI(1, SPI.MASTER, baudrate=200000, polarity=1, phase=0)
+    spi.send('hello')
+    spi.recv(5) # receive 5 bytes on the bus
+    spi.send_recv('hello') # send a receive 5 bytes
+
+I2C bus
+-------
+
+See :ref:`pyb.I2C <pyb.I2C>`. ::
+
+    from pyb import I2C
+
+    i2c = I2C(1, I2C.MASTER, baudrate=100000)
+    i2c.scan() # returns list of slave addresses
+    i2c.send('hello', 0x42) # send 5 bytes to slave with address 0x42
+    i2c.recv(5, 0x42) # receive 5 bytes from slave
+    i2c.mem_read(2, 0x42, 0x10) # read 2 bytes from slave 0x42, slave memory 0x10
+    i2c.mem_write('xy', 0x42, 0x10) # write 2 bytes to slave 0x42, slave memory 0x10

docs/readthedocs/settings/local_settings.py

@@ -0,0 +1,9 @@
+import os
+
+# Directory that the project lives in, aka ../..
+SITE_ROOT = '/'.join(os.path.dirname(__file__).split('/')[0:-2])
+
+TEMPLATE_DIRS = (
+    "%s/templates/" % SITE_ROOT, # Your custom template directory, before the RTD one to override it.
+    "%s/readthedocs/templates/" % SITE_ROOT, # Default RTD template dir
+)

docs/static/customstyle.css

@@ -0,0 +1,10 @@
+/* custom CSS for Micro Python docs
+ */
+
+.admonition-difference-to-cpython {
+    border: 1px solid black;
+}
+
+.admonition-difference-to-cpython .admonition-title {
+    margin: 4px;
+}

docs/templates/layout.html

@@ -0,0 +1,2 @@
+{% extends "!layout.html" %}
+{% set css_files = css_files + ["_static/customstyle.css"] %}

docs/topindex.html

@@ -0,0 +1,93 @@
+{% extends "defindex.html" %}
+{% block body %}
+
+  <h1>Micro Python documentation</h1>
+
+  <p>
+    {{ _('Welcome! This is the documentation for Micro Python') }}
+    v{{ release|e }}{% if last_updated %}, {{ _('last updated') }} {{ last_updated|e }}{% endif %}.
+  </p>
+
+  <p><strong>Documentation for Micro Python and the pyboard:</strong></p>
+
+  <table class="contentstable"><tr>
+    <td width="40%" style="padding-left:2em;">
+      <p class="biglink">
+        <a class="biglink" href="{{ pathto("quickref") }}">Quick reference for the pyboard</a><br/>
+        <span class="linkdescr">pinout for the pyboard and snippets of useful code</span>
+      </p>
+      <p class="biglink">
+        <a class="biglink" href="{{ pathto("general") }}">General information about the pyboard</a><br/>
+        <span class="linkdescr">read this first for a quick overview</span>
+      </p>
+      <p class="biglink">
+        <a class="biglink" href="{{ pathto("tutorial/index") }}">Tutorials and code examples</a><br/>
+        <span class="linkdescr">start here</span>
+      </p>
+      <p class="biglink">
+        <a class="biglink" href="{{ pathto("library/index") }}">Library Reference</a><br/>
+        <span class="linkdescr">Micro Python libraries, including the <a href="{{ pathto("library/pyb") }}">pyb module</a></span>
+      </p>
+    </td>
+    <td width="40%" style="padding-left:2em;">
+      <p class="biglink">
+        <a class="biglink" href="{{ pathto("hardware/index") }}">The pyboard hardware</a><br/>
+        <span class="linkdescr">schematics, dimensions and component datasheets</span>
+      </p>
+      <p class="biglink">
+        <a class="biglink" href="http://micropython.org/resources/Micro-Python-Windows-setup.pdf">Guide for pyboard on Windows (PDF)</a><br/>
+        <span class="linkdescr">including DFU programming</span>
+      </p>
+      <p class="biglink">
+        <a class="biglink" href="{{ pathto("license") }}">License</a><br/>
+        <span class="linkdescr">Micro Python license information</span>
+      </p>
+    </td>
+  </tr></table>
+
+  <p><strong>Indices and tables:</strong></p>
+  <table class="contentstable"><tr>
+    <td width="40%" style="padding-left:2em;">
+      <p class="biglink">
+        <a class="biglink" href="{{ pathto("py-modindex") }}">Module index</a><br/>
+        <span class="linkdescr">quick access to all modules</span>
+      </p>
+      <p class="biglink">
+        <a class="biglink" href="{{ pathto("genindex") }}">Full index</a><br/>
+        <span class="linkdescr">all functions, classes, constants</span>
+      </p>
+    </td>
+    <td width="40%" style="padding-left:2em;">
+      <p class="biglink">
+        <a class="biglink" href="{{ pathto("contents") }}">Table of contents</a><br/>
+        <span class="linkdescr">a list of all sections and subsections</span>
+      </p>
+      <p class="biglink">
+        <a class="biglink" href="{{ pathto("search") }}">Search page</a><br/>
+        <span class="linkdescr">search this documentation</span>
+      </p>
+    </td></tr>
+  </table>
+
+  <p><strong>External links:</strong></p>
+
+  <table class="contentstable"><tr>
+    <td width="40%" style="padding-left:2em;">
+      <p class="biglink">
+      <a class="biglink" href="http://micropython.org">Micro Python homepage</a><br/>
+        <span class="linkdescr">the official Micro Python site</span>
+      </p>
+      <p class="biglink">
+        <a class="biglink" href="http://forum.micropython.org">Micro Python forum</a><br/>
+        <span class="linkdescr">community discussion for all things related to Micro Python</span>
+      </p>
+    </td>
+    <td width="40%" style="padding-left:2em;">
+      <p class="biglink">
+        <a class="biglink" href="https://github.com/micropython">Micro Python on GitHub</a><br/>
+        <span class="linkdescr">contribute to the source code on GitHub</span>
+      </p>
+    </td>
+  </tr></table>
+
+{% endblock %}

docs/tutorial/amp_skin.rst

@@ -3,11 +3,11 @@ The AMP audio skin
 
 Soldering and using the AMP audio skin.
 
-.. image:: http://micropython.org/static/doc/skin-amp-1.jpg
+.. image:: img/skin_amp_1.jpg
     :alt: AMP skin
     :width: 250px
 
-.. image:: http://micropython.org/static/doc/skin-amp-3.jpg
+.. image:: img/skin_amp_2.jpg
     :alt: AMP skin
     :width: 250px
 
@@ -17,6 +17,8 @@ The following video shows how to solder the headers, microphone and speaker onto
 
     <iframe style="margin-left:3em;" width="560" height="315" src="http://www.youtube.com/embed/fjB1DuZRveo?rel=0" frameborder="0" allowfullscreen></iframe>
 
+For circuit schematics and datasheets for the components on the skin see :ref:`hardware_index`.
+
 Example code
 ------------
 
@@ -26,6 +28,7 @@ potentiometer, which is an I2C device with address 46 on the ``IC2(1)`` bus.
 
 To set the volume, define the following function::
 
+    import pyb
     def volume(val):
         pyb.I2C(1, pyb.I2C.MASTER).mem_write(val, 46, 0)
 
@@ -50,11 +53,11 @@ For example::
     dac.write_timed(buf, 400 * len(buf), mode=DAC.CIRCULAR)
 
 You can also play WAV files using the Python ``wave`` module.  You can get
-the wave module [here](/static/doc/examples/wave.py) and you will also need
-the chunk module available [here](/static/doc/examples/chunk.py).  Put these
+the wave module `here <http://micropython.org/resources/examples/wave.py>`_ and you will also need
+the chunk module available `here <http://micropython.org/resources/examples/chunk.py>`_.  Put these
 on your pyboard (either on the flash or the SD card in the top-level
 directory).  You will need an 8-bit WAV file to play, such as
-[this one](/static/doc/examples/test.wav).  Then you can do::
+`this one <http://micropython.org/resources/examples/test.wav>`_.  Then you can do::
 
     >>> import wave
     >>> from pyb import DAC

docs/tutorial/debounce.rst

@@ -0,0 +1,37 @@
+Debouncing a pin input
+======================
+
+A pin used as input from a switch or other mechanical device can have a lot
+of noise on it, rapidly changing from low to high when the switch is first
+pressed or released.  This noise can be eliminated using a capacitor (a
+debouncing circuit).  It can also be eliminated using a simple function that
+makes sure the value on the pin is stable.
+
+The following function does just this.  It gets the current value of the given
+pin, and then waits for the value to change.  The new pin value must be stable
+for a continuous 20ms for it to register the change.  You can adjust this time
+(to say 50ms) if you still have noise. ::
+
+    import pyb
+
+    def wait_pin_change(pin):
+        # wait for pin to change value
+        # it needs to be stable for a continuous 20ms
+        cur_value = pin.value()
+        active = 0
+        while active < 20:
+            if pin.value() != cur_value:
+                active += 1
+            else:
+                active = 0
+            pyb.delay(1)
+
+
+Use it something like this::
+
+    import pyb
+
+    pin_x1 = pyb.Pin('X1', pyb.Pin.IN, pyb.Pin.PULL_DOWN)
+    while True:
+        wait_pin_change(pin_x1)
+        pyb.LED(4).toggle()

docs/tutorial/fading_led.rst

@@ -0,0 +1,89 @@
+Fading LEDs
+===========
+
+In addition to turning LEDs on and off, it is also possible to control the brightness of an LED using `Pulse-Width Modulation (PWM) <http://en.wikipedia.org/wiki/Pulse-width_modulation>`_, a common technique for obtaining variable output from a digital pin. This allows us to fade an LED:
+
+.. image:: http://upload.wikimedia.org/wikipedia/commons/a/a9/Fade.gif
+
+Components
+----------
+
+You will need:
+
+- Standard 5 or 3 mm LED
+- 100 Ohm resistor
+- Wires
+- `Breadboard <http://en.wikipedia.org/wiki/Breadboard>`_ (optional, but makes things easier)
+
+Connecting Things Up
+--------------------
+
+For this tutorial, we will use the ``X1`` pin. Connect one end of the resistor to ``X1``, and the other end to the **anode** of the LED, which is the longer leg. Connect the **cathode** of the LED to ground.
+
+.. image:: img/fading_leds_breadboard_fritzing.png
+
+Code
+----
+By examining the :ref:`quickref`, we see that ``X1`` is connected to channel 1 of timer 5 (``TIM5 CH1``). Therefore we will first create a ``Timer`` object for timer 5, then create a ``TimerChannel`` object for channel 1::
+    
+    from pyb import Timer
+    from time import sleep
+    
+    # timer 5 will be created with a frequency of 100 Hz
+    tim = pyb.Timer(5, freq=100)
+    tchannel = tim.channel(1, Timer.PWM, pin=pyb.Pin.board.X1, pulse_width=0)
+
+Brightness of the LED in PWM is controlled by controlling the pulse-width, that is the amount of time the LED is on every cycle. With a timer frequency of 100 Hz, each cycle takes 0.01 second, or 10 ms.
+
+To achieve the fading effect shown at the beginning of this tutorial, we want to set the pulse-width to a small value, then slowly increase the pulse-width to brighten the LED, and start over when we reach some maximum brightness::
+
+    # maximum and minimum pulse-width, which corresponds to maximum
+    # and minimum brightness
+    max_width = 200000
+    min_width = 20000
+
+    # how much to change the pulse-width by each step
+    wstep = 1500
+    cur_width = min_width
+    
+    while True:
+      tchannel.pulse_width(cur_width)
+      
+      # this determines how often we change the pulse-width. It is
+      # analogous to frames-per-second
+      sleep(0.01)
+    
+      cur_width += wstep
+    
+      if cur_width > max_width:
+        cur_width = min_width
+
+Breathing Effect
+----------------
+
+If we want to have a breathing effect, where the LED fades from dim to bright then bright to dim, then we simply need to reverse the sign of ``wstep`` when we reach maximum brightness, and reverse it again at minimum brightness. To do this we modify the ``while`` loop to be::
+
+    while True:
+      tchannel.pulse_width(cur_width)
+    
+      sleep(0.01)
+    
+      cur_width += wstep
+    
+      if cur_width > max_width:
+        cur_width = max_width
+        wstep *= -1
+      elif cur_width < min_width:
+        cur_width = min_width
+        wstep *= -1
+
+Advanced Exercise
+-----------------
+
+You may have noticed that the LED brightness seems to fade slowly, but increases quickly. This is because our eyes interprets brightness logarithmically (`Weber's Law <http://www.telescope-optics.net/eye_intensity_response.htm>`_
+), while the LED's brightness changes linearly, that is by the same amount each time. How do you solve this problem? (Hint: what is the opposite of the logarithmic function?)
+
+Addendum
+--------
+
+We could have also used the digital-to-analog converter (DAC) to achieve the same effect. The PWM method has the advantage that it drives the LED with the same current each time, but for different lengths of time. This allows better control over the brightness, because LEDs do not necessarily exhibit a linear relationship between the driving current and brightness.

docs/tutorial/index.rst

@@ -22,6 +22,7 @@ the tutorial through in the order below.
    usb_mouse.rst
    timer.rst
    assembler.rst
+   power_ctrl.rst
 
 Tutorials requiring extra components
 ------------------------------------
@@ -31,5 +32,16 @@ Tutorials requiring extra components
    :numbered:
 
    servo.rst
+   fading_led.rst
    lcd_skin.rst
    amp_skin.rst
+
+Tips, tricks and useful things to know
+--------------------------------------
+
+.. toctree::
+   :maxdepth: 1
+   :numbered:
+
+   debounce.rst
+   pass_through.rst

docs/tutorial/lcd_skin.rst

@@ -3,11 +3,11 @@ The LCD and touch-sensor skin
 
 Soldering and using the LCD and touch-sensor skin.
 
-.. image:: http://micropython.org/static/doc/skin-lcd-3.jpg
+.. image:: img/skin_lcd_1.jpg
     :alt: pyboard with LCD skin
     :width: 250px
 
-.. image:: http://micropython.org/static/doc/skin-lcd-1.jpg
+.. image:: img/skin_lcd_2.jpg
     :alt: pyboard with LCD skin
     :width: 250px
 
@@ -18,18 +18,22 @@ At the end of the video, it shows you how to correctly connect the LCD skin to t
 
     <iframe style="margin-left:3em;" width="560" height="315" src="http://www.youtube.com/embed/PowCzdLYbFM?rel=0" frameborder="0" allowfullscreen></iframe>
 
+For circuit schematics and datasheets for the components on the skin see :ref:`hardware_index`.
+
 Using the LCD
 -------------
 
 To get started using the LCD, try the following at the Micro Python prompt.
 Make sure the LCD skin is attached to the pyboard as pictured at the top of this page. ::
 
+    >>> import pyb
     >>> lcd = pyb.LCD('X')
     >>> lcd.light(True)
     >>> lcd.write('Hello uPy!\n')
 
 You can make a simple animation using the code::
 
+    import pyb
     lcd = pyb.LCD('X')
     lcd.light(True)
     for x in range(-80, 128):
@@ -46,6 +50,7 @@ MPR121 capacitive touch sensor has address 90.
 
 To get started, try::
 
+    >>> import pyb
     >>> i2c = pyb.I2C(1, pyb.I2C.MASTER)
     >>> i2c.mem_write(4, 90, 0x5e)
     >>> touch = i2c.mem_read(1, 90, 0)[0]
@@ -55,7 +60,7 @@ enables the 4 touch sensors.  The third line reads the touch
 status and the ``touch`` variable holds the state of the 4 touch
 buttons (A, B, X, Y).
 
-There is a simple driver [here](/static/doc/examples/mpr121.py)
+There is a simple driver `here <http://micropython.org/resources/examples/mpr121.py>`_
 which allows you to set the threshold and debounce parameters, and
 easily read the touch status and electrode voltage levels.  Copy
 this script to your pyboard (either flash or SD card, in the top
@@ -78,4 +83,4 @@ initialise the I2C bus using::
     >>> m = mpr121.MPR121(pyb.I2C(2, pyb.I2C.MASTER))
 
 There is also a demo which uses the LCD and the touch sensors together,
-and can be found [here](/static/doc/examples/lcddemo.py).
+and can be found `here <http://micropython.org/resources/examples/lcddemo.py>`_.

docs/tutorial/leds.rst

@@ -42,7 +42,7 @@ Next we will set up an infinite loop that cycles through each of the LEDs turnin
       leds[n].toggle()
       pyb.delay(50)
 
-Here, n keeps track of the current LED and every time the loop is executed we cycle to the next n (the % sign is a modulus operator that keeps n between 0 and 4.) Then we access the nth LED and toggle it. If you run this you should see each of the LEDs turning on then all turning off again in sequence.
+Here, n keeps track of the current LED and every time the loop is executed we cycle to the next n (the % sign is a modulus operator that keeps n between 0 and 3.) Then we access the nth LED and toggle it. If you run this you should see each of the LEDs turning on then all turning off again in sequence.
 
 One problem you might find is that if you stop the script and then start it again that the LEDs are stuck on from the previous run, ruining our carefully choreographed disco. We can fix this by turning all the LEDs off when we initialise the script and then using a try/finally block. When you press CTRL-C, Micro Python generates a VCPInterrupt exception. Exceptions normally mean something has gone wrong and you can use a try: command to "catch" an exception. In this case it is just the user interrupting the script, so we don't need to catch the error but just tell Micro Python what to do when we exit. The finally block does this, and we use it to make sure all the LEDs are off. The full code is::
 

docs/tutorial/pass_through.rst

@@ -0,0 +1,18 @@
+Making a UART - USB pass through
+================================
+
+It's as simple as::
+
+    import pyb
+    import select
+
+    def pass_through(usb, uart):
+        usb.setinterrupt(-1)
+        while True:
+            select.select([usb, uart], [], [])
+            if usb.any():
+                uart.write(usb.read(256))
+            if uart.any():
+                usb.write(uart.read(256))
+
+    pass_through(pyb.USB_VCP(), pyb.UART(1, 9600))

docs/tutorial/power_ctrl.rst

@@ -0,0 +1,13 @@
+Power control
+=============
+
+:meth:`pyb.wfi` is used to reduce power consumption while waiting for an
+event such as an interrupt.  You would use it in the following situation::
+
+    while True:
+        do_some_processing()
+        pyb.wfi()
+
+Control the frequency using :meth:`pyb.freq`::
+
+    pyb.freq(30000000) # set CPU frequency to 30MHz

docs/tutorial/repl.rst

@@ -26,7 +26,7 @@ and see which COM port it is (eg COM4).
 
 You now need to run your terminal program.  You can use HyperTerminal if you
 have it installed, or download the free program PuTTY:
-[`putty.exe`](http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html).
+`putty.exe <http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html>`_.
 Using your serial program you must connect to the COM port that you found in the
 previous step.  With PuTTY, click on "Session" in the left-hand panel, then click
 the "Serial" radio button on the right, then enter you COM port (eg COM4) in the
@@ -39,7 +39,7 @@ Open a terminal and run::
 
     screen /dev/tty.usbmodem*
     
-When you are finishend and want to exit screen, type CTRL-A CTRL-\\.
+When you are finished and want to exit screen, type CTRL-A CTRL-\\.
 
 Linux
 -----

docs/tutorial/script.rst

@@ -10,7 +10,7 @@ Connecting your pyboard
 Connect your pyboard to your PC (Windows, Mac or Linux) with a micro USB cable.
 There is only one way that the cable will connect, so you can't get it wrong.
 
-<img src="/static/doc/pyboard-usb-micro.jpg" alt="pyboard with USB micro cable" style="width:200px; border:1px solid black; display:inline-block;"/>
+.. image:: img/pyboard_usb_micro.jpg
 
 When the pyboard is connected to your PC it will power on and enter the start up
 process (the boot process).  The green LED should light up for half a second or
@@ -46,16 +46,16 @@ a window (or command line) should be showing the files on the pyboard drive.
 The drive you are looking at is known as ``/flash`` by the pyboard, and should contain
 the following 4 files:
 
-  - [``boot.py``](/static/doc/fresh-pyboard/boot.py) -- this script is executed when the pyboard boots up.  It sets
+* `boot.py <http://micropython.org/resources/fresh-pyboard/boot.py>`_ -- this script is executed when the pyboard boots up.  It sets
     up various configuration options for the pyboard.
 
-  - [``main.py``](/static/doc/fresh-pyboard/main.py) -- this is the main script that will contain your Python program.
+* `main.py <http://micropython.org/resources/fresh-pyboard/main.py>`_ -- this is the main script that will contain your Python program.
     It is executed after ``boot.py``.
 
-  - [``README.txt``](/static/doc/fresh-pyboard/README.txt) -- this contains some very basic information about getting
+* `README.txt <http://micropython.org/resources/fresh-pyboard/README.txt>`_ -- this contains some very basic information about getting
     started with the pyboard.
 
-  - [``pybcdc.inf``](/static/doc/fresh-pyboard/pybcdc.inf) -- this is a Windows driver file to configure the serial USB
+* `pybcdc.inf <http://micropython.org/resources/fresh-pyboard/pybcdc.inf>`_ -- this is a Windows driver file to configure the serial USB
     device.  More about this in the next tutorial.
 
 Editing ``main.py``

docs/tutorial/servo.rst

@@ -8,7 +8,7 @@ These motors have 3 wires: ground, power and signal.  On the pyboard you
 can connect them in the bottom right corner, with the signal pin on the
 far right.  Pins X1, X2, X3 and X4 are the 4 dedicated servo signal pins.
 
-<img src="/static/doc/pyboard-servo.jpg" alt="pyboard with servo motors" style="width:250px; border:1px solid black; display:inline-block;"/>
+.. image:: img/pyboard_servo.jpg
 
 In this picture there are male-male double adaptors to connect the servos
 to the header pins on the pyboard.

drivers/cc3000/inc/ccspi.h

@@ -65,7 +65,6 @@ extern void SpiClose(void);
 extern void SpiPauseSpi(void);
 extern void SpiResumeSpi(void);
 extern long SpiWrite(unsigned char *pUserBuffer, unsigned short usLength);
-extern void SpiResumeSpi(void);
 extern void SpiConfigureHwMapping(void);
 extern void SpiCleanGPIOISR(void);
 extern void SSIConfigure(unsigned long ulSSIFreq, unsigned long bForceGpioConfiguration, unsigned long uiReconfigureSysClock);

drivers/cc3000/src/ccspi.c

@@ -98,14 +98,12 @@ typedef struct {
     unsigned char *pTxPacket;
     unsigned char *pRxPacket;
 } tSpiInformation;
-tSpiInformation sSpiInformation;
+STATIC tSpiInformation sSpiInformation;
 
-char spi_buffer[CC3000_RX_BUFFER_SIZE];
+STATIC char spi_buffer[CC3000_RX_BUFFER_SIZE];
 unsigned char wlan_tx_buffer[CC3000_TX_BUFFER_SIZE];
 
 STATIC const mp_obj_fun_builtin_t irq_callback_obj;
-void SpiWriteDataSynchronous(unsigned char *data, unsigned short size);
-void SpiReadDataSynchronous(unsigned char *data, unsigned short size);
 
 // set the pins to use to communicate with the CC3000
 // the arguments must be of type pin_obj_t* and SPI_HandleTypeDef*
@@ -185,17 +183,6 @@ void SpiOpen(gcSpiHandleRx pfRxHandler)
     DEBUG_printf("SpiOpen finished; IRQ.pin=%d IRQ_LINE=%d\n", PIN_IRQ->pin, PIN_IRQ->pin);
 }
 
-
-void SpiPauseSpi(void)
-{
-   extint_disable(PIN_IRQ->pin);
-}
-
-void SpiResumeSpi(void)
-{
-   extint_enable(PIN_IRQ->pin);
-}
-
 long ReadWlanInterruptPin(void)
 {
     return HAL_GPIO_ReadPin(PIN_IRQ->gpio, PIN_IRQ->pin_mask);
@@ -207,13 +194,34 @@ void WriteWlanPin(unsigned char val)
             (WLAN_ENABLE)? GPIO_PIN_SET:GPIO_PIN_RESET);
 }
 
-void __delay_cycles(volatile int x)
+STATIC void SpiWriteDataSynchronous(unsigned char *data, unsigned short size)
+{
+    DEBUG_printf("SpiWriteDataSynchronous(data=%p [%x %x %x %x], size=%u)\n", data, data[0], data[1], data[2], data[3], size);
+    __disable_irq();
+    if (HAL_SPI_TransmitReceive(SPI_HANDLE, data, data, size, SPI_TIMEOUT) != HAL_OK) {
+        //BREAK();
+    }
+    __enable_irq();
+    DEBUG_printf(" - rx data = [%x %x %x %x]\n", data[0], data[1], data[2], data[3]);
+}
+
+STATIC void SpiReadDataSynchronous(unsigned char *data, unsigned short size)
+{
+    memset(data, READ, size);
+    __disable_irq();
+    if (HAL_SPI_TransmitReceive(SPI_HANDLE, data, data, size, SPI_TIMEOUT) != HAL_OK) {
+       //BREAK();
+    }
+    __enable_irq();
+}
+
+STATIC void __delay_cycles(volatile int x)
 {
     x *= 6; // for 168 MHz CPU
     while (x--);
 }
 
-long SpiFirstWrite(unsigned char *ucBuf, unsigned short usLength)
+STATIC long SpiFirstWrite(unsigned char *ucBuf, unsigned short usLength)
 {
     DEBUG_printf("SpiFirstWrite %lu\n", sSpiInformation.ulSpiState);
 
@@ -308,28 +316,9 @@ long SpiWrite(unsigned char *pUserBuffer, unsigned short usLength)
     return(0);
 }
 
-void SpiWriteDataSynchronous(unsigned char *data, unsigned short size)
-{
-    DEBUG_printf("SpiWriteDataSynchronous(data=%p [%x %x %x %x], size=%u)\n", data, data[0], data[1], data[2], data[3], size);
-    __disable_irq();
-    if (HAL_SPI_TransmitReceive(SPI_HANDLE, data, data, size, SPI_TIMEOUT) != HAL_OK) {
-        //BREAK();
-    }
-    __enable_irq();
-    DEBUG_printf(" - rx data = [%x %x %x %x]\n", data[0], data[1], data[2], data[3]);
-}
-
-void SpiReadDataSynchronous(unsigned char *data, unsigned short size)
-{
-    memset(data, READ, size);
-    __disable_irq();
-    if (HAL_SPI_TransmitReceive(SPI_HANDLE, data, data, size, SPI_TIMEOUT) != HAL_OK) {
-       //BREAK();
-    }
-    __enable_irq();
-}
-
-void SpiReadPacket(void)
+#if 0
+unused
+STATIC void SpiReadPacket(void)
 {
     int length;
 
@@ -344,13 +333,14 @@ void SpiReadPacket(void)
 
     sSpiInformation.ulSpiState = eSPI_STATE_READ_EOT;
 }
+#endif
 
-void SpiReadHeader(void)
+STATIC void SpiReadHeader(void)
 {
     SpiReadDataSynchronous(sSpiInformation.pRxPacket, 10);
 }
 
-void SpiTriggerRxProcessing(void)
+STATIC void SpiTriggerRxProcessing(void)
 {
     SpiPauseSpi();
     CS_HIGH();
@@ -367,7 +357,7 @@ void SpiTriggerRxProcessing(void)
 }
 
 
-long SpiReadDataCont(void)
+STATIC long SpiReadDataCont(void)
 {
     long data_to_recv=0;
     unsigned char *evnt_buff, type;
@@ -413,7 +403,7 @@ long SpiReadDataCont(void)
     return 0;
 }
 
-void SSIContReadOperation(void)
+STATIC void SSIContReadOperation(void)
 {
     // The header was read - continue with  the payload read
     if (!SpiReadDataCont()) {
@@ -423,8 +413,7 @@ void SSIContReadOperation(void)
     }
 }
 
-STATIC mp_obj_t irq_callback(mp_obj_t line)
-{
+STATIC mp_obj_t irq_callback(mp_obj_t line) {
     DEBUG_printf("<< IRQ; state=%lu >>\n", sSpiInformation.ulSpiState);
     switch (sSpiInformation.ulSpiState) {
         case eSPI_STATE_POWERUP:
@@ -459,3 +448,13 @@ STATIC mp_obj_t irq_callback(mp_obj_t line)
 }
 
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(irq_callback_obj, irq_callback);
+
+void SpiPauseSpi(void) {
+    DEBUG_printf("SpiPauseSpi\n");
+    extint_disable(PIN_IRQ->pin);
+}
+
+void SpiResumeSpi(void) {
+    DEBUG_printf("SpiResumeSpi\n");
+    extint_enable(PIN_IRQ->pin);
+}

drivers/nrf24l01/nrf24l01.py

@@ -0,0 +1,233 @@
+"""NRF24L01 driver for Micro Python
+"""
+
+import pyb
+
+# nRF24L01+ registers
+CONFIG      = const(0x00)
+EN_RXADDR   = const(0x02)
+SETUP_AW    = const(0x03)
+SETUP_RETR  = const(0x04)
+RF_CH       = const(0x05)
+RF_SETUP    = const(0x06)
+STATUS      = const(0x07)
+RX_ADDR_P0  = const(0x0a)
+TX_ADDR     = const(0x10)
+RX_PW_P0    = const(0x11)
+FIFO_STATUS = const(0x17)
+DYNPD	    = const(0x1c)
+
+# CONFIG register
+EN_CRC      = const(0x08) # enable CRC
+CRCO        = const(0x04) # CRC encoding scheme; 0=1 byte, 1=2 bytes
+PWR_UP      = const(0x02) # 1=power up, 0=power down
+PRIM_RX     = const(0x01) # RX/TX control; 0=PTX, 1=PRX
+
+# RF_SETUP register
+POWER_0     = const(0x00) # -18 dBm
+POWER_1     = const(0x02) # -12 dBm
+POWER_2     = const(0x04) # -6 dBm
+POWER_3     = const(0x06) # 0 dBm
+SPEED_1M    = const(0x00)
+SPEED_2M    = const(0x08)
+SPEED_250K  = const(0x20)
+
+# STATUS register
+RX_DR       = const(0x40) # RX data ready; write 1 to clear
+TX_DS       = const(0x20) # TX data sent; write 1 to clear
+MAX_RT      = const(0x10) # max retransmits reached; write 1 to clear
+
+# FIFO_STATUS register
+RX_EMPTY    = const(0x01) # 1 if RX FIFO is empty
+
+# constants for instructions
+R_RX_PL_WID  = const(0x60) # read RX payload width
+R_RX_PAYLOAD = const(0x61) # read RX payload
+W_TX_PAYLOAD = const(0xa0) # write TX payload
+FLUSH_TX     = const(0xe1) # flush TX FIFO
+FLUSH_RX     = const(0xe2) # flush RX FIFO
+NOP          = const(0xff) # use to read STATUS register
+
+class NRF24L01:
+    def __init__(self, spi, cs, ce, channel=46, payload_size=16):
+        assert payload_size <= 32
+
+        # init the SPI bus and pins
+        spi.init(spi.MASTER, baudrate=4000000, polarity=0, phase=1, firstbit=spi.MSB)
+        cs.init(cs.OUT_PP, cs.PULL_NONE)
+        ce.init(ce.OUT_PP, ce.PULL_NONE)
+
+        # store the pins
+        self.spi = spi
+        self.cs = cs
+        self.ce = ce
+
+        # reset everything
+        self.ce.low()
+        self.cs.high()
+        self.payload_size = payload_size
+        self.pipe0_read_addr = None
+        pyb.delay(5)
+
+        # set address width to 5 bytes and check for device present
+        self.reg_write(SETUP_AW, 0b11)
+        if self.reg_read(SETUP_AW) != 0b11:
+            raise OSError("nRF24L01+ Hardware not responding")
+
+        # disable dynamic payloads
+        self.reg_write(DYNPD, 0)
+
+        # auto retransmit delay: 1750us
+        # auto retransmit count: 8
+        self.reg_write(SETUP_RETR, (6 << 4) | 8)
+
+        # set rf power and speed
+        self.set_power_speed(POWER_3, SPEED_250K) # Best for point to point links
+
+        # init CRC
+        self.set_crc(2)
+
+        # clear status flags
+        self.reg_write(STATUS, RX_DR | TX_DS | MAX_RT)
+
+        # set channel
+        self.set_channel(channel)
+
+        # flush buffers
+        self.flush_rx()
+        self.flush_tx()
+
+    def reg_read(self, reg):
+        self.cs.low()
+        self.spi.send_recv(reg)
+        buf = self.spi.recv(1)
+        self.cs.high()
+        return buf[0]
+
+    def reg_write(self, reg, buf):
+        self.cs.low()
+        status = self.spi.send_recv(0x20 | reg)[0]
+        self.spi.send(buf)
+        self.cs.high()
+        return status
+
+    def flush_rx(self):
+        self.cs.low()
+        self.spi.send(FLUSH_RX)
+        self.cs.high()
+
+    def flush_tx(self):
+        self.cs.low()
+        self.spi.send(FLUSH_TX)
+        self.cs.high()
+
+    # power is one of POWER_x defines; speed is one of SPEED_x defines
+    def set_power_speed(self, power, speed):
+        setup = self.reg_read(RF_SETUP) & 0b11010001
+        self.reg_write(RF_SETUP, setup | power | speed)
+
+    # length in bytes: 0, 1 or 2
+    def set_crc(self, length):
+        config = self.reg_read(CONFIG) & ~(CRCO | EN_CRC)
+        if length == 0:
+            pass
+        elif length == 1:
+            config |= EN_CRC
+        else:
+            config |= EN_CRC | CRCO
+        self.reg_write(CONFIG, config)
+
+    def set_channel(self, channel):
+        self.reg_write(RF_CH, min(channel, 125))
+
+    # address should be a bytes object 5 bytes long
+    def open_tx_pipe(self, address):
+        assert len(address) == 5
+        self.reg_write(RX_ADDR_P0, address)
+        self.reg_write(TX_ADDR, address)
+        self.reg_write(RX_PW_P0, self.payload_size)
+
+    # address should be a bytes object 5 bytes long
+    # pipe 0 and 1 have 5 byte address
+    # pipes 2-5 use same 4 most-significant bytes as pipe 1, plus 1 extra byte
+    def open_rx_pipe(self, pipe_id, address):
+        assert len(address) == 5
+        assert 0 <= pipe_id <= 5
+        if pipe_id == 0:
+            self.pipe0_read_addr = address
+        if pipe_id < 2:
+            self.reg_write(RX_ADDR_P0 + pipe_id, address)
+        else:
+            self.reg_write(RX_ADDR_P0 + pipe_id, address[0])
+        self.reg_write(RX_PW_P0 + pipe_id, self.payload_size)
+        self.reg_write(EN_RXADDR, self.reg_read(EN_RXADDR) | (1 << pipe_id))
+
+    def start_listening(self):
+        self.reg_write(CONFIG, self.reg_read(CONFIG) | PWR_UP | PRIM_RX)
+        self.reg_write(STATUS, RX_DR | TX_DS | MAX_RT)
+
+        if self.pipe0_read_addr is not None:
+            self.reg_write(RX_ADDR_P0, self.pipe0_read_addr)
+
+        self.flush_rx()
+        self.flush_tx()
+        self.ce.high()
+        pyb.udelay(130)
+
+    def stop_listening(self):
+        self.ce.low()
+        self.flush_tx()
+        self.flush_rx()
+
+    # returns True if any data available to recv
+    def any(self):
+        return not bool(self.reg_read(FIFO_STATUS) & RX_EMPTY)
+
+    def recv(self):
+        # get the data
+        self.cs.low()
+        self.spi.send(R_RX_PAYLOAD)
+        buf = self.spi.recv(self.payload_size)
+        self.cs.high()
+        # clear RX ready flag
+        self.reg_write(STATUS, RX_DR)
+
+        return buf
+
+    # blocking wait for tx complete
+    def send(self, buf, timeout=500):
+        send_nonblock = self.send_start(buf)
+        start = pyb.millis()
+        result = None
+        while result is None and pyb.elapsed_millis(start) < timeout:
+            result = self.send_done() # 1 == success, 2 == fail
+        if result == 2:
+            raise OSError("send failed")
+
+    # non-blocking tx
+    def send_start(self, buf):
+        # power up
+        self.reg_write(CONFIG, (self.reg_read(CONFIG) | PWR_UP) & ~PRIM_RX)
+        pyb.udelay(150)
+        # send the data
+        self.cs.low()
+        self.spi.send(W_TX_PAYLOAD)
+        self.spi.send(buf)
+        if len(buf) < self.payload_size:
+            self.spi.send(b'\x00' * (self.payload_size - len(buf))) # pad out data
+        self.cs.high()
+
+        # enable the chip so it can send the data
+        self.ce.high()
+        pyb.udelay(15) # needs to be >10us
+        self.ce.low()
+
+    # returns None if send still in progress, 1 for success, 2 for fail
+    def send_done(self):
+        if not (self.reg_read(STATUS) & (TX_DS | MAX_RT)):
+            return None # tx not finished
+
+        # either finished or failed: get and clear status flags, power down
+        status = self.reg_write(STATUS, RX_DR | TX_DS | MAX_RT)
+        self.reg_write(CONFIG, self.reg_read(CONFIG) & ~PWR_UP)
+        return 1 if status & TX_DS else 2

drivers/nrf24l01/nrf24l01test.py

@@ -0,0 +1,100 @@
+"""Test for nrf24l01 module."""
+
+import struct
+import pyb
+from pyb import Pin, SPI
+from nrf24l01 import NRF24L01
+
+pipes = (b'\xf0\xf0\xf0\xf0\xe1', b'\xf0\xf0\xf0\xf0\xd2')
+
+def master():
+    nrf = NRF24L01(SPI(2), Pin('Y5'), Pin('Y4'), payload_size=8)
+
+    nrf.open_tx_pipe(pipes[0])
+    nrf.open_rx_pipe(1, pipes[1])
+    nrf.start_listening()
+
+    num_needed = 16
+    num_successes = 0
+    num_failures = 0
+    led_state = 0
+
+    print('NRF24L01 master mode, sending %d packets...' % num_needed)
+
+    while num_successes < num_needed and num_failures < num_needed:
+        # stop listening and send packet
+        nrf.stop_listening()
+        millis = pyb.millis()
+        led_state = max(1, (led_state << 1) & 0x0f)
+        print('sending:', millis, led_state)
+        try:
+            nrf.send(struct.pack('ii', millis, led_state))
+        except OSError:
+            pass
+
+        # start listening again
+        nrf.start_listening()
+
+        # wait for response, with 250ms timeout
+        start_time = pyb.millis()
+        timeout = False
+        while not nrf.any() and not timeout:
+            if pyb.elapsed_millis(start_time) > 250:
+                timeout = True
+
+        if timeout:
+            print('failed, respones timed out')
+            num_failures += 1
+
+        else:
+            # recv packet
+            got_millis, = struct.unpack('i', nrf.recv())
+
+            # print response and round-trip delay
+            print('got response:', got_millis, '(delay', pyb.millis() - got_millis, 'ms)')
+            num_successes += 1
+
+        # delay then loop
+        pyb.delay(250)
+
+    print('master finished sending; succeses=%d, failures=%d' % (num_successes, num_failures))
+
+def slave():
+    nrf = NRF24L01(SPI(2), Pin('Y5'), Pin('Y4'), payload_size=8)
+
+    nrf.open_tx_pipe(pipes[1])
+    nrf.open_rx_pipe(1, pipes[0])
+    nrf.start_listening()
+
+    print('NRF24L01 slave mode, waiting for packets... (ctrl-C to stop)')
+
+    while True:
+        pyb.wfi()
+        if nrf.any():
+            while nrf.any():
+                buf = nrf.recv()
+                millis, led_state = struct.unpack('ii', buf)
+                print('received:', millis, led_state)
+                for i in range(4):
+                    if led_state & (1 << i):
+                        pyb.LED(i + 1).on()
+                    else:
+                        pyb.LED(i + 1).off()
+                pyb.delay(15)
+
+            nrf.stop_listening()
+            try:
+                nrf.send(struct.pack('i', millis))
+            except OSError:
+                pass
+            print('sent response')
+            nrf.start_listening()
+
+print('NRF24L01 test module loaded')
+print('NRF24L01 pinout for test:')
+print('    CE on Y4')
+print('    CSN on Y5')
+print('    SCK on Y6')
+print('    MISO on Y7')
+print('    MOSI on Y8')
+print('run nrf24l01test.slave() on slave, then nrf24l01test.master() on master')

drivers/sdcard/sdcard.py

@@ -0,0 +1,202 @@
+"""
+Micro Python driver for SD cards using SPI bus.
+
+Requires an SPI bus and a CS pin.  Provides readblocks and writeblocks
+methods so the device can be mounted as a filesystem.
+
+Example usage:
+
+    import pyb, sdcard, os
+    sd = sdcard.SDCard(pyb.SPI(1), pyb.Pin.board.X5)
+    pyb.mount(sd, '/sd2')
+    os.listdir('/')
+
+"""
+
+import pyb
+
+class SDCard:
+    CMD_TIMEOUT = const(100)
+
+    R1_IDLE_STATE = const(1 << 0)
+    #R1_ERASE_RESET = const(1 << 1)
+    R1_ILLEGAL_COMMAND = const(1 << 2)
+    #R1_COM_CRC_ERROR = const(1 << 3)
+    #R1_ERASE_SEQUENCE_ERROR = const(1 << 4)
+    #R1_ADDRESS_ERROR = const(1 << 5)
+    #R1_PARAMETER_ERROR = const(1 << 6)
+
+    def __init__(self, spi, cs):
+        self.spi = spi
+        self.cs = cs
+
+        self.cmdbuf = bytearray(6)
+        self.dummybuf = bytearray(512)
+        for i in range(512):
+            self.dummybuf[i] = 0xff
+        self.dummybuf_memoryview = memoryview(self.dummybuf)
+
+        # initialise the card
+        self.init_card()
+
+    def init_card(self):
+        # init CS pin
+        self.cs.high()
+        self.cs.init(self.cs.OUT_PP)
+
+        # init SPI bus; use low data rate for initialisation
+        self.spi.init(self.spi.MASTER, baudrate=100000, phase=0, polarity=0)
+
+        # clock card at least 100 cycles with cs high
+        for i in range(16):
+            self.spi.send(0xff)
+
+        # CMD0: init card; should return R1_IDLE_STATE (allow 2 attempts)
+        if self.cmd(0, 0, 0x95) != R1_IDLE_STATE:
+            if self.cmd(0, 0, 0x95) != R1_IDLE_STATE:
+                raise OSError("no SD card")
+
+        # CMD8: determine card version
+        r = self.cmd(8, 0x01aa, 0x87, 4)
+        if r == R1_IDLE_STATE:
+            self.init_card_v2()
+        elif r == (R1_IDLE_STATE | R1_ILLEGAL_COMMAND):
+            self.init_card_v1()
+        else:
+            raise OSError("couldn't determine SD card version")
+
+        # get the number of sectors
+        # CMD9: response R2 (R1 byte + 16-byte block read)
+        if self.cmd(9, 0, 0, 0, False) != 0:
+            raise OSError("no response from SD card")
+        csd = bytearray(16)
+        self.readinto(csd)
+        if csd[0] & 0xc0 != 0x40:
+            raise OSError("SD card CSD format not supported")
+        self.sectors = ((csd[8] << 8 | csd[9]) + 1) * 2014
+        #print('sectors', self.sectors)
+
+        # CMD16: set block length to 512 bytes
+        if self.cmd(16, 512, 0) != 0:
+            raise OSError("can't set 512 block size")
+
+        # set to high data rate now that it's initialised
+        self.spi.init(self.spi.MASTER, baudrate=1320000, phase=0, polarity=0)
+
+    def init_card_v1(self):
+        for i in range(CMD_TIMEOUT):
+            self.cmd(55, 0, 0)
+            if self.cmd(41, 0, 0) == 0:
+                self.cdv = 512
+                #print("[SDCard] v1 card")
+                return
+        raise OSError("timeout waiting for v1 card")
+
+    def init_card_v2(self):
+        for i in range(CMD_TIMEOUT):
+            pyb.delay(50)
+            self.cmd(58, 0, 0, 4)
+            self.cmd(55, 0, 0)
+            if self.cmd(41, 0x40000000, 0) == 0:
+                self.cmd(58, 0, 0, 4)
+                self.cdv = 1
+                #print("[SDCard] v2 card")
+                return
+        raise OSError("timeout waiting for v2 card")
+
+    def cmd(self, cmd, arg, crc, final=0, release=True):
+        self.cs.low()
+
+        # create and send the command
+        buf = self.cmdbuf
+        buf[0] = 0x40 | cmd
+        buf[1] = arg >> 24
+        buf[2] = arg >> 16
+        buf[3] = arg >> 8
+        buf[4] = arg
+        buf[5] = crc
+        self.spi.send(buf)
+
+        # wait for the repsonse (response[7] == 0)
+        for i in range(CMD_TIMEOUT):
+            response = self.spi.send_recv(0xff)[0]
+            if not (response & 0x80):
+                # this could be a big-endian integer that we are getting here
+                for j in range(final):
+                    self.spi.send(0xff)
+                if release:
+                    self.cs.high()
+                    self.spi.send(0xff)
+                return response
+
+        # timeout
+        self.cs.high()
+        self.spi.send(0xff)
+        return -1
+
+    def readinto(self, buf):
+        self.cs.low()
+
+        # read until start byte (0xff)
+        while self.spi.send_recv(0xff)[0] != 0xfe:
+            pass
+
+        # read data
+        mv = self.dummybuf_memoryview[:len(buf)]
+        self.spi.send_recv(mv, recv=buf)
+
+        # read checksum
+        self.spi.send(0xff)
+        self.spi.send(0xff)
+
+        self.cs.high()
+        self.spi.send(0xff)
+
+    def write(self, buf):
+        self.cs.low()
+
+        # send: start of block, data, checksum
+        self.spi.send(0xfe)
+        self.spi.send(buf)
+        self.spi.send(0xff)
+        self.spi.send(0xff)
+
+        # check the response
+        if (self.spi.send_recv(0xff)[0] & 0x1f) != 0x05:
+            self.cs.high()
+            self.spi.send(0xff)
+            return
+
+        # 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)
+        return 0
+
+    def writeblocks(self, block_num, buf):
+        # TODO support multiple block writes
+        assert len(buf) == 512
+
+        # 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)
+        return 0

drivers/wiznet5k/ethernet/socket.c

@@ -49,6 +49,9 @@
 //! THE POSSIBILITY OF SUCH DAMAGE.
 //
 //*****************************************************************************
+
+#include <string.h>
+
 #include "socket.h"
 
 extern void HAL_Delay(uint32_t);
@@ -85,7 +88,19 @@ static uint8_t  sock_pack_info[_WIZCHIP_SOCK_NUM_] = {0,};
       if(len == 0) return SOCKERR_DATALEN;   \
    }while(0);              \
 
+void WIZCHIP_EXPORT(socket_reset)(void) {
+    sock_any_port = SOCK_ANY_PORT_NUM;
+    sock_io_mode = 0;
+    sock_is_sending = 0;
+    /*
+    memset(sock_remained_size, 0, _WIZCHIP_SOCK_NUM_ * sizeof(uint16_t));
+    memset(sock_pack_info, 0, _WIZCHIP_SOCK_NUM_ * sizeof(uint8_t));
+    */
 
+#if _WIZCHIP_ == 5200
+    memset(sock_next_rd, 0, _WIZCHIP_SOCK_NUM_ * sizeof(uint16_t));
+#endif
+}
 
 int8_t WIZCHIP_EXPORT(socket)(uint8_t sn, uint8_t protocol, uint16_t port, uint8_t flag)
 {
@@ -336,8 +351,13 @@ int32_t WIZCHIP_EXPORT(recv)(uint8_t sn, uint8_t * buf, uint16_t len)
             if(recvsize != 0) break;
             else if(getSn_TX_FSR(sn) == getSn_TxMAX(sn))
             {
+               // dpgeorge: Getting here seems to be an orderly shutdown of the
+               // socket, and trying to get POSIX behaviour we return 0 because:
+               // "If no messages are available to be received and the peer has per‐
+               //  formed an orderly shutdown, recv() shall return 0".
+               // TODO this return value clashes with SOCK_BUSY in non-blocking mode.
                WIZCHIP_EXPORT(close)(sn);
-               return SOCKERR_SOCKSTATUS;
+               return 0;
             }
          }
          else

drivers/wiznet5k/ethernet/socket.h

@@ -133,6 +133,9 @@
 #define PACK_REMAINED            0x01              ///< In Non-TCP packet, It indicates to remain a packet to be received.
 #define PACK_COMPLETED           0x00              ///< In Non-TCP packet, It indicates to complete to receive a packet.
 
+// resets all global state associated with the socket interface
+void WIZCHIP_EXPORT(socket_reset)(void);
+
 /**
  * @ingroup WIZnet_socket_APIs
  * @brief Open a socket.

drivers/wiznet5k/ethernet/wizchip_conf.c

@@ -49,6 +49,8 @@
 //
 
 #include "wizchip_conf.h"
+#include "socket.h"
+
 /**
  * @brief Default function to enable interrupt.
  * @note This function help not to access wrong address. If you do not describe this function or register any functions,
@@ -328,6 +330,9 @@ int8_t wizchip_init(uint8_t* txsize, uint8_t* rxsize)
       for(i = 0 ; i < _WIZCHIP_SOCK_NUM_; i++)
          setSn_RXBUF_SIZE(i, rxsize[i]);
    }
+
+   WIZCHIP_EXPORT(socket_reset)();
+
    return 0;
 }
 

esp8266/Makefile

@@ -0,0 +1,113 @@
+include ../py/mkenv.mk
+
+# qstr definitions (must come before including py.mk)
+QSTR_DEFS = qstrdefsport.h #$(BUILD)/pins_qstr.h
+
+# include py core make definitions
+include ../py/py.mk
+
+PORT = /dev/ttyACM0
+CROSS_COMPILE = xtensa-lx106-elf-
+ESP_SDK = $(shell $(CC) -print-sysroot)/usr
+
+INC =  -I.
+INC += -I$(PY_SRC)
+INC += -I../stmhal
+INC += -I$(BUILD)
+INC += -I$(ESP_SDK)/include
+
+CFLAGS_XTENSA = -fsingle-precision-constant -Wdouble-promotion \
+	-D__ets__ -DICACHE_FLASH \
+	-fno-inline-functions \
+	-Wl,-EL -mlongcalls -mtext-section-literals \
+
+CFLAGS = $(INC) -Wall -Wpointer-arith -Werror -ansi -std=gnu99 -nostdlib $(CFLAGS_XTENSA) $(COPT)
+
+LDFLAGS = -nostdlib -T esp8266.ld -Map=$(@:.elf=.map) --cref
+LIBS = -L$(ESP_SDK)/lib -lmain -ljson -llwip -lpp -lnet80211 -lwpa -lphy -lnet80211
+
+LIBGCC_FILE_NAME = $(shell $(CC) $(CFLAGS) -print-libgcc-file-name)
+LIBS += -L$(dir $(LIBGCC_FILE_NAME)) -lgcc
+
+# Debugging/Optimization
+ifeq ($(DEBUG), 1)
+CFLAGS += -g
+COPT = -O0
+else
+CFLAGS += -fdata-sections -ffunction-sections
+COPT += -Os -DNDEBUG
+LDFLAGS += --gc-sections
+endif
+
+SRC_C = \
+	strtoll.c \
+	main.c \
+	esp_mphal.c \
+	gccollect.c \
+	pybstdio.c \
+	uart.c \
+	modpyb.c \
+
+STM_SRC_C = $(addprefix stmhal/,\
+	printf.c \
+	string0.c \
+	pyexec.c \
+	readline.c \
+	)
+
+SRC_S = \
+	gchelper.s \
+
+OBJ =
+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 += $(BUILD)/pins_$(BOARD).o
+
+all: $(BUILD)/firmware-combined.bin
+
+.PHONY: deploy
+
+deploy: $(BUILD)/firmware-combined.bin
+	$(ECHO) "Writing $< to the board"
+	#$(Q)esptool.py --port $(PORT) write_flash 0 $<
+	$(Q)esptool.py --port $(PORT) write_flash 0 $(BUILD)/firmware.elf-0x00000.bin 0x10000 $(BUILD)/firmware.elf-0x10000.bin
+
+$(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 $@
+
+$(BUILD)/firmware.elf: $(OBJ)
+	$(ECHO) "LINK $@"
+	$(Q)$(LD) $(LDFLAGS) -o $@ $(OBJ) $(LIBS)
+	$(Q)$(SIZE) $@
+
+#MAKE_PINS = boards/make-pins.py
+#BOARD_PINS = boards/$(BOARD)/pins.csv
+#AF_FILE = boards/stm32f4xx_af.csv
+#PREFIX_FILE = boards/stm32f4xx_prefix.c
+#GEN_PINS_SRC = $(BUILD)/pins_$(BOARD).c
+#GEN_PINS_HDR = $(HEADER_BUILD)/pins.h
+#GEN_PINS_QSTR = $(BUILD)/pins_qstr.h
+#GEN_PINS_AF_CONST = $(HEADER_BUILD)/pins_af_const.h
+#GEN_PINS_AF_PY = $(BUILD)/pins_af.py
+
+# Making OBJ use an order-only depenedency on the generated pins.h file
+# has the side effect of making the pins.h file before we actually compile
+# any of the objects. The normal dependency generation will deal with the
+# case when pins.h is modified. But when it doesn't exist, we don't know
+# which source files might need it.
+#$(OBJ): | $(HEADER_BUILD)/pins.h
+
+# Use a pattern rule here so that make will only call make-pins.py once to make
+# both pins_$(BOARD).c and pins.h
+#$(BUILD)/%_$(BOARD).c $(HEADER_BUILD)/%.h $(HEADER_BUILD)/%_af_const.h $(BUILD)/%_qstr.h: boards/$(BOARD)/%.csv $(MAKE_PINS) $(AF_FILE) $(PREFIX_FILE) | $(HEADER_BUILD)
+#	$(ECHO) "Create $@"
+#	$(Q)$(PYTHON) $(MAKE_PINS) --board $(BOARD_PINS) --af $(AF_FILE) --prefix $(PREFIX_FILE) --hdr $(GEN_PINS_HDR) --qstr $(GEN_PINS_QSTR) --af-const $(GEN_PINS_AF_CONST) --af-py $(GEN_PINS_AF_PY) > $(GEN_PINS_SRC)
+#
+#$(BUILD)/pins_$(BOARD).o: $(BUILD)/pins_$(BOARD).c
+#	$(call compile_c)
+
+include ../py/mkrules.mk

esp8266/README.md

@@ -0,0 +1,51 @@
+Micro Python port to ESP8266
+============================
+
+This is a port of Micro Python to the Espressif ESP8266 wifi module.
+
+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.
+- C long-long type used as bignum implementation (gives 64 signed ints).
+
+Note that floating-point numbers are not supported.
+
+On the TODO list:
+- Wifi support.
+- GPIO support.
+- Internal filesystem using the flash.
+- ...
+
+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.
+
+Then, to build Micro Python for the ESP8266, just run:
+```bash
+$ make
+```
+This should produce binary images in the `build/` subdirectory.  To flash them
+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.
+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
+
+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

esp8266/eagle.rom.addr.v6.ld

@@ -0,0 +1,344 @@
+PROVIDE ( Cache_Read_Disable = 0x400047f0 );
+PROVIDE ( Cache_Read_Enable = 0x40004678 );
+PROVIDE ( FilePacketSendReqMsgProc = 0x400035a0 );
+PROVIDE ( FlashDwnLdParamCfgMsgProc = 0x4000368c );
+PROVIDE ( FlashDwnLdStartMsgProc = 0x40003538 );
+PROVIDE ( FlashDwnLdStopReqMsgProc = 0x40003658 );
+PROVIDE ( GetUartDevice = 0x40003f4c );
+PROVIDE ( MD5Final = 0x40009900 );
+PROVIDE ( MD5Init = 0x40009818 );
+PROVIDE ( MD5Update = 0x40009834 );
+PROVIDE ( MemDwnLdStartMsgProc = 0x400036c4 );
+PROVIDE ( MemDwnLdStopReqMsgProc = 0x4000377c );
+PROVIDE ( MemPacketSendReqMsgProc = 0x400036f0 );
+PROVIDE ( RcvMsg = 0x40003eac );
+PROVIDE ( SHA1Final = 0x4000b648 );
+PROVIDE ( SHA1Init = 0x4000b584 );
+PROVIDE ( SHA1Transform = 0x4000a364 );
+PROVIDE ( SHA1Update = 0x4000b5a8 );
+PROVIDE ( Wait_SPI_Idle = 0x4000448c );
+PROVIDE ( SPIEraseArea = 0x40004b44 );
+PROVIDE ( SPIEraseBlock = 0x400049b4 );
+PROVIDE ( SPIEraseChip = 0x40004984 );
+PROVIDE ( SPIEraseSector = 0x40004a00 );
+PROVIDE ( SPILock = 0x400048a8 );
+PROVIDE ( SPIParamCfg = 0x40004c2c );
+PROVIDE ( SPIRead = 0x40004b1c );
+PROVIDE ( SPIReadModeCnfig = 0x400048ec );
+PROVIDE ( SPIUnlock = 0x40004878 );
+PROVIDE ( SPIWrite = 0x40004a4c );
+PROVIDE ( SelectSpiFunction = 0x40003f58 );
+PROVIDE ( SendMsg = 0x40003cf4 );
+PROVIDE ( UartConnCheck = 0x40003230 );
+PROVIDE ( UartConnectProc = 0x400037a0 );
+PROVIDE ( UartDwnLdProc = 0x40003368 );
+PROVIDE ( UartGetCmdLn = 0x40003ef4 );
+PROVIDE ( UartRegReadProc = 0x4000381c );
+PROVIDE ( UartRegWriteProc = 0x400037ac );
+PROVIDE ( UartRxString = 0x40003c30 );
+PROVIDE ( Uart_Init = 0x40003a14 );
+PROVIDE ( _DebugExceptionVector = 0x40000010 );
+PROVIDE ( _DoubleExceptionVector = 0x40000070 );
+PROVIDE ( _KernelExceptionVector = 0x40000030 );
+PROVIDE ( _NMIExceptionVector = 0x40000020 );
+PROVIDE ( _ResetHandler = 0x400000a4 );
+PROVIDE ( _ResetVector = 0x40000080 );
+PROVIDE ( _UserExceptionVector = 0x40000050 );
+PROVIDE ( __adddf3 = 0x4000c538 );
+PROVIDE ( __addsf3 = 0x4000c180 );
+PROVIDE ( __divdf3 = 0x4000cb94 );
+PROVIDE ( __divdi3 = 0x4000ce60 );
+PROVIDE ( __divsi3 = 0x4000dc88 );
+PROVIDE ( __extendsfdf2 = 0x4000cdfc );
+PROVIDE ( __fixdfsi = 0x4000ccb8 );
+PROVIDE ( __fixunsdfsi = 0x4000cd00 );
+PROVIDE ( __fixunssfsi = 0x4000c4c4 );
+PROVIDE ( __floatsidf = 0x4000e2f0 );
+PROVIDE ( __floatsisf = 0x4000e2ac );
+PROVIDE ( __floatunsidf = 0x4000e2e8 );
+PROVIDE ( __floatunsisf = 0x4000e2a4 );
+PROVIDE ( __muldf3 = 0x4000c8f0 );
+PROVIDE ( __muldi3 = 0x40000650 );
+PROVIDE ( __mulsf3 = 0x4000c3dc );
+PROVIDE ( __subdf3 = 0x4000c688 );
+PROVIDE ( __subsf3 = 0x4000c268 );
+PROVIDE ( __truncdfsf2 = 0x4000cd5c );
+PROVIDE ( __udivdi3 = 0x4000d310 );
+PROVIDE ( __udivsi3 = 0x4000e21c );
+PROVIDE ( __umoddi3 = 0x4000d770 );
+PROVIDE ( __umodsi3 = 0x4000e268 );
+PROVIDE ( __umulsidi3 = 0x4000dcf0 );
+PROVIDE ( _rom_store = 0x4000e388 );
+PROVIDE ( _rom_store_table = 0x4000e328 );
+PROVIDE ( _start = 0x4000042c );
+PROVIDE ( _xtos_alloca_handler = 0x4000dbe0 );
+PROVIDE ( _xtos_c_wrapper_handler = 0x40000598 );
+PROVIDE ( _xtos_cause3_handler = 0x40000590 );
+PROVIDE ( _xtos_ints_off = 0x4000bda4 );
+PROVIDE ( _xtos_ints_on = 0x4000bd84 );
+PROVIDE ( _xtos_l1int_handler = 0x4000048c );
+PROVIDE ( _xtos_p_none = 0x4000dbf8 );
+PROVIDE ( _xtos_restore_intlevel = 0x4000056c );
+PROVIDE ( _xtos_return_from_exc = 0x4000dc54 );
+PROVIDE ( _xtos_set_exception_handler = 0x40000454 );
+PROVIDE ( _xtos_set_interrupt_handler = 0x4000bd70 );
+PROVIDE ( _xtos_set_interrupt_handler_arg = 0x4000bd28 );
+PROVIDE ( _xtos_set_intlevel = 0x4000dbfc );
+PROVIDE ( _xtos_set_min_intlevel = 0x4000dc18 );
+PROVIDE ( _xtos_set_vpri = 0x40000574 );
+PROVIDE ( _xtos_syscall_handler = 0x4000dbe4 );
+PROVIDE ( _xtos_unhandled_exception = 0x4000dc44 );
+PROVIDE ( _xtos_unhandled_interrupt = 0x4000dc3c );
+PROVIDE ( aes_decrypt = 0x400092d4 );
+PROVIDE ( aes_decrypt_deinit = 0x400092e4 );
+PROVIDE ( aes_decrypt_init = 0x40008ea4 );
+PROVIDE ( aes_unwrap = 0x40009410 );
+PROVIDE ( base64_decode = 0x40009648 );
+PROVIDE ( base64_encode = 0x400094fc );
+PROVIDE ( bzero = 0x4000de84 );
+PROVIDE ( cmd_parse = 0x40000814 );
+PROVIDE ( conv_str_decimal = 0x40000b24 );
+PROVIDE ( conv_str_hex = 0x40000cb8 );
+PROVIDE ( convert_para_str = 0x40000a60 );
+PROVIDE ( dtm_get_intr_mask = 0x400026d0 );
+PROVIDE ( dtm_params_init = 0x4000269c );
+PROVIDE ( dtm_set_intr_mask = 0x400026c8 );
+PROVIDE ( dtm_set_params = 0x400026dc );
+PROVIDE ( eprintf = 0x40001d14 );
+PROVIDE ( eprintf_init_buf = 0x40001cb8 );
+PROVIDE ( eprintf_to_host = 0x40001d48 );
+PROVIDE ( est_get_printf_buf_remain_len = 0x40002494 );
+PROVIDE ( est_reset_printf_buf_len = 0x4000249c );
+PROVIDE ( ets_bzero = 0x40002ae8 );
+PROVIDE ( ets_char2xdigit = 0x40002b74 );
+PROVIDE ( ets_delay_us = 0x40002ecc );
+PROVIDE ( ets_enter_sleep = 0x400027b8 );
+PROVIDE ( ets_external_printf = 0x40002578 );
+PROVIDE ( ets_get_cpu_frequency = 0x40002f0c );
+PROVIDE ( ets_getc = 0x40002bcc );
+PROVIDE ( ets_install_external_printf = 0x40002450 );
+PROVIDE ( ets_install_putc1 = 0x4000242c );
+PROVIDE ( ets_install_putc2 = 0x4000248c );
+PROVIDE ( ets_install_uart_printf = 0x40002438 );
+PROVIDE ( ets_intr_lock = 0x40000f74 );
+PROVIDE ( ets_intr_unlock = 0x40000f80 );
+PROVIDE ( ets_isr_attach = 0x40000f88 );
+PROVIDE ( ets_isr_mask = 0x40000f98 );
+PROVIDE ( ets_isr_unmask = 0x40000fa8 );
+PROVIDE ( ets_memcmp = 0x400018d4 );
+PROVIDE ( ets_memcpy = 0x400018b4 );
+PROVIDE ( ets_memmove = 0x400018c4 );
+PROVIDE ( ets_memset = 0x400018a4 );
+PROVIDE ( ets_post = 0x40000e24 );
+PROVIDE ( ets_printf = 0x400024cc );
+PROVIDE ( ets_putc = 0x40002be8 );
+PROVIDE ( ets_rtc_int_register = 0x40002a40 );
+PROVIDE ( ets_run = 0x40000e04 );
+PROVIDE ( ets_set_idle_cb = 0x40000dc0 );
+PROVIDE ( ets_set_user_start = 0x40000fbc );
+PROVIDE ( ets_str2macaddr = 0x40002af8 );
+PROVIDE ( ets_strcmp = 0x40002aa8 );
+PROVIDE ( ets_strcpy = 0x40002a88 );
+PROVIDE ( ets_strlen = 0x40002ac8 );
+PROVIDE ( ets_strncmp = 0x40002ab8 );
+PROVIDE ( ets_strncpy = 0x40002a98 );
+PROVIDE ( ets_strstr = 0x40002ad8 );
+PROVIDE ( ets_task = 0x40000dd0 );
+PROVIDE ( ets_timer_arm = 0x40002cc4 );
+PROVIDE ( ets_timer_disarm = 0x40002d40 );
+PROVIDE ( ets_timer_done = 0x40002d80 );
+PROVIDE ( ets_timer_handler_isr = 0x40002da8 );
+PROVIDE ( ets_timer_init = 0x40002e68 );
+PROVIDE ( ets_timer_setfn = 0x40002c48 );
+PROVIDE ( ets_uart_printf = 0x40002544 );
+PROVIDE ( ets_update_cpu_frequency = 0x40002f04 );
+PROVIDE ( ets_vprintf = 0x40001f00 );
+PROVIDE ( ets_wdt_disable = 0x400030f0 );
+PROVIDE ( ets_wdt_enable = 0x40002fa0 );
+PROVIDE ( ets_wdt_get_mode = 0x40002f34 );
+PROVIDE ( ets_wdt_init = 0x40003170 );
+PROVIDE ( ets_wdt_restore = 0x40003158 );
+PROVIDE ( ets_write_char = 0x40001da0 );
+PROVIDE ( get_first_seg = 0x4000091c );
+PROVIDE ( gpio_init = 0x40004c50 );
+PROVIDE ( gpio_input_get = 0x40004cf0 );
+PROVIDE ( gpio_intr_ack = 0x40004dcc );
+PROVIDE ( gpio_intr_handler_register = 0x40004e28 );
+PROVIDE ( gpio_intr_pending = 0x40004d88 );
+PROVIDE ( gpio_intr_test = 0x40004efc );
+PROVIDE ( gpio_output_set = 0x40004cd0 );
+PROVIDE ( gpio_pin_intr_state_set = 0x40004d90 );
+PROVIDE ( gpio_pin_wakeup_disable = 0x40004ed4 );
+PROVIDE ( gpio_pin_wakeup_enable = 0x40004e90 );
+PROVIDE ( gpio_register_get = 0x40004d5c );
+PROVIDE ( gpio_register_set = 0x40004d04 );
+PROVIDE ( hmac_md5 = 0x4000a2cc );
+PROVIDE ( hmac_md5_vector = 0x4000a160 );
+PROVIDE ( hmac_sha1 = 0x4000ba28 );
+PROVIDE ( hmac_sha1_vector = 0x4000b8b4 );
+PROVIDE ( lldesc_build_chain = 0x40004f40 );
+PROVIDE ( lldesc_num2link = 0x40005050 );
+PROVIDE ( lldesc_set_owner = 0x4000507c );
+PROVIDE ( main = 0x40000fec );
+PROVIDE ( md5_vector = 0x400097ac );
+PROVIDE ( mem_calloc = 0x40001c2c );
+PROVIDE ( mem_free = 0x400019e0 );
+PROVIDE ( mem_init = 0x40001998 );
+PROVIDE ( mem_malloc = 0x40001b40 );
+PROVIDE ( mem_realloc = 0x40001c6c );
+PROVIDE ( mem_trim = 0x40001a14 );
+PROVIDE ( mem_zalloc = 0x40001c58 );
+PROVIDE ( memcmp = 0x4000dea8 );
+PROVIDE ( memcpy = 0x4000df48 );
+PROVIDE ( memmove = 0x4000e04c );
+PROVIDE ( memset = 0x4000e190 );
+PROVIDE ( multofup = 0x400031c0 );
+PROVIDE ( pbkdf2_sha1 = 0x4000b840 );
+PROVIDE ( phy_get_romfuncs = 0x40006b08 );
+PROVIDE ( rand = 0x40000600 );
+PROVIDE ( rc4_skip = 0x4000dd68 );
+PROVIDE ( recv_packet = 0x40003d08 );
+PROVIDE ( remove_head_space = 0x40000a04 );
+PROVIDE ( rijndaelKeySetupDec = 0x40008dd0 );
+PROVIDE ( rijndaelKeySetupEnc = 0x40009300 );
+PROVIDE ( rom_abs_temp = 0x400060c0 );
+PROVIDE ( rom_ana_inf_gating_en = 0x40006b10 );
+PROVIDE ( rom_cal_tos_v50 = 0x40007a28 );
+PROVIDE ( rom_chip_50_set_channel = 0x40006f84 );
+PROVIDE ( rom_chip_v5_disable_cca = 0x400060d0 );
+PROVIDE ( rom_chip_v5_enable_cca = 0x400060ec );
+PROVIDE ( rom_chip_v5_rx_init = 0x4000711c );
+PROVIDE ( rom_chip_v5_sense_backoff = 0x4000610c );
+PROVIDE ( rom_chip_v5_tx_init = 0x4000718c );
+PROVIDE ( rom_dc_iq_est = 0x4000615c );
+PROVIDE ( rom_en_pwdet = 0x400061b8 );
+PROVIDE ( rom_get_bb_atten = 0x40006238 );
+PROVIDE ( rom_get_corr_power = 0x40006260 );
+PROVIDE ( rom_get_fm_sar_dout = 0x400062dc );
+PROVIDE ( rom_get_noisefloor = 0x40006394 );
+PROVIDE ( rom_get_power_db = 0x400063b0 );
+PROVIDE ( rom_i2c_readReg = 0x40007268 );
+PROVIDE ( rom_i2c_readReg_Mask = 0x4000729c );
+PROVIDE ( rom_i2c_writeReg = 0x400072d8 );
+PROVIDE ( rom_i2c_writeReg_Mask = 0x4000730c );
+PROVIDE ( rom_iq_est_disable = 0x40006400 );
+PROVIDE ( rom_iq_est_enable = 0x40006430 );
+PROVIDE ( rom_linear_to_db = 0x40006484 );
+PROVIDE ( rom_mhz2ieee = 0x400065a4 );
+PROVIDE ( rom_pbus_dco___SA2 = 0x40007bf0 );
+PROVIDE ( rom_pbus_debugmode = 0x4000737c );
+PROVIDE ( rom_pbus_enter_debugmode = 0x40007410 );
+PROVIDE ( rom_pbus_exit_debugmode = 0x40007448 );
+PROVIDE ( rom_pbus_force_test = 0x4000747c );
+PROVIDE ( rom_pbus_rd = 0x400074d8 );
+PROVIDE ( rom_pbus_set_rxgain = 0x4000754c );
+PROVIDE ( rom_pbus_set_txgain = 0x40007610 );
+PROVIDE ( rom_pbus_workmode = 0x40007648 );
+PROVIDE ( rom_pbus_xpd_rx_off = 0x40007688 );
+PROVIDE ( rom_pbus_xpd_rx_on = 0x400076cc );
+PROVIDE ( rom_pbus_xpd_tx_off = 0x400076fc );
+PROVIDE ( rom_pbus_xpd_tx_on = 0x40007740 );
+PROVIDE ( rom_pbus_xpd_tx_on__low_gain = 0x400077a0 );
+PROVIDE ( rom_phy_reset_req = 0x40007804 );
+PROVIDE ( rom_restart_cal = 0x4000781c );
+PROVIDE ( rom_rfcal_pwrctrl = 0x40007eb4 );
+PROVIDE ( rom_rfcal_rxiq = 0x4000804c );
+PROVIDE ( rom_rfcal_rxiq_set_reg = 0x40008264 );
+PROVIDE ( rom_rfcal_txcap = 0x40008388 );
+PROVIDE ( rom_rfcal_txiq = 0x40008610 );
+PROVIDE ( rom_rfcal_txiq_cover = 0x400088b8 );
+PROVIDE ( rom_rfcal_txiq_set_reg = 0x40008a70 );
+PROVIDE ( rom_rfpll_reset = 0x40007868 );
+PROVIDE ( rom_rfpll_set_freq = 0x40007968 );
+PROVIDE ( rom_rxiq_cover_mg_mp = 0x40008b6c );
+PROVIDE ( rom_rxiq_get_mis = 0x40006628 );
+PROVIDE ( rom_sar_init = 0x40006738 );
+PROVIDE ( rom_set_ana_inf_tx_scale = 0x4000678c );
+PROVIDE ( rom_set_channel_freq = 0x40006c50 );
+PROVIDE ( rom_set_loopback_gain = 0x400067c8 );
+PROVIDE ( rom_set_noise_floor = 0x40006830 );
+PROVIDE ( rom_set_rxclk_en = 0x40006550 );
+PROVIDE ( rom_set_txbb_atten = 0x40008c6c );
+PROVIDE ( rom_set_txclk_en = 0x4000650c );
+PROVIDE ( rom_set_txiq_cal = 0x40008d34 );
+PROVIDE ( rom_start_noisefloor = 0x40006874 );
+PROVIDE ( rom_start_tx_tone = 0x400068b4 );
+PROVIDE ( rom_stop_tx_tone = 0x4000698c );
+PROVIDE ( rom_tx_mac_disable = 0x40006a98 );
+PROVIDE ( rom_tx_mac_enable = 0x40006ad4 );
+PROVIDE ( rom_txtone_linear_pwr = 0x40006a1c );
+PROVIDE ( rom_write_rfpll_sdm = 0x400078dc );
+PROVIDE ( roundup2 = 0x400031b4 );
+PROVIDE ( rtc_enter_sleep = 0x40002870 );
+PROVIDE ( rtc_get_reset_reason = 0x400025e0 );
+PROVIDE ( rtc_intr_handler = 0x400029ec );
+PROVIDE ( rtc_set_sleep_mode = 0x40002668 );
+PROVIDE ( save_rxbcn_mactime = 0x400027a4 );
+PROVIDE ( save_tsf_us = 0x400027ac );
+PROVIDE ( send_packet = 0x40003c80 );
+PROVIDE ( sha1_prf = 0x4000ba48 );
+PROVIDE ( sha1_vector = 0x4000a2ec );
+PROVIDE ( sip_alloc_to_host_evt = 0x40005180 );
+PROVIDE ( sip_get_ptr = 0x400058a8 );
+PROVIDE ( sip_get_state = 0x40005668 );
+PROVIDE ( sip_init_attach = 0x4000567c );
+PROVIDE ( sip_install_rx_ctrl_cb = 0x4000544c );
+PROVIDE ( sip_install_rx_data_cb = 0x4000545c );
+PROVIDE ( sip_post = 0x400050fc );
+PROVIDE ( sip_post_init = 0x400056c4 );
+PROVIDE ( sip_reclaim_from_host_cmd = 0x4000534c );
+PROVIDE ( sip_reclaim_tx_data_pkt = 0x400052c0 );
+PROVIDE ( sip_send = 0x40005808 );
+PROVIDE ( sip_to_host_chain_append = 0x40005864 );
+PROVIDE ( sip_to_host_evt_send_done = 0x40005234 );
+PROVIDE ( slc_add_credits = 0x400060ac );
+PROVIDE ( slc_enable = 0x40005d90 );
+PROVIDE ( slc_from_host_chain_fetch = 0x40005f24 );
+PROVIDE ( slc_from_host_chain_recycle = 0x40005e94 );
+PROVIDE ( slc_init_attach = 0x40005c50 );
+PROVIDE ( slc_init_credit = 0x4000608c );
+PROVIDE ( slc_pause_from_host = 0x40006014 );
+PROVIDE ( slc_reattach = 0x40005c1c );
+PROVIDE ( slc_resume_from_host = 0x4000603c );
+PROVIDE ( slc_select_tohost_gpio = 0x40005dc0 );
+PROVIDE ( slc_select_tohost_gpio_mode = 0x40005db8 );
+PROVIDE ( slc_send_to_host_chain = 0x40005de4 );
+PROVIDE ( slc_set_host_io_max_window = 0x40006068 );
+PROVIDE ( slc_to_host_chain_recycle = 0x40005f10 );
+PROVIDE ( software_reset = 0x4000264c );
+PROVIDE ( spi_flash_attach = 0x40004644 );
+PROVIDE ( srand = 0x400005f0 );
+PROVIDE ( strcmp = 0x4000bdc8 );
+PROVIDE ( strcpy = 0x4000bec8 );
+PROVIDE ( strlen = 0x4000bf4c );
+PROVIDE ( strncmp = 0x4000bfa8 );
+PROVIDE ( strncpy = 0x4000c0a0 );
+PROVIDE ( strstr = 0x4000e1e0 );
+PROVIDE ( timer_insert = 0x40002c64 );
+PROVIDE ( uartAttach = 0x4000383c );
+PROVIDE ( uart_baudrate_detect = 0x40003924 );
+PROVIDE ( uart_buff_switch = 0x400038a4 );
+PROVIDE ( uart_div_modify = 0x400039d8 );
+PROVIDE ( uart_rx_intr_handler = 0x40003bbc );
+PROVIDE ( uart_rx_one_char = 0x40003b8c );
+PROVIDE ( uart_rx_one_char_block = 0x40003b64 );
+PROVIDE ( uart_rx_readbuff = 0x40003ec8 );
+PROVIDE ( uart_tx_one_char = 0x40003b30 );
+PROVIDE ( wepkey_128 = 0x4000bc40 );
+PROVIDE ( wepkey_64 = 0x4000bb3c );
+PROVIDE ( xthal_bcopy = 0x40000688 );
+PROVIDE ( xthal_copy123 = 0x4000074c );
+PROVIDE ( xthal_get_ccompare = 0x4000dd4c );
+PROVIDE ( xthal_get_ccount = 0x4000dd38 );
+PROVIDE ( xthal_get_interrupt = 0x4000dd58 );
+PROVIDE ( xthal_get_intread = 0x4000dd58 );
+PROVIDE ( xthal_memcpy = 0x400006c4 );
+PROVIDE ( xthal_set_ccompare = 0x4000dd40 );
+PROVIDE ( xthal_set_intclear = 0x4000dd60 );
+PROVIDE ( xthal_spill_registers_into_stack_nw = 0x4000e320 );
+PROVIDE ( xthal_window_spill = 0x4000e324 );
+PROVIDE ( xthal_window_spill_nw = 0x4000e320 );
+
+PROVIDE ( Te0 = 0x3fffccf0 );
+PROVIDE ( UartDev = 0x3fffde10 );
+PROVIDE ( flashchip = 0x3fffc714);

esp8266/esp8266.ld

@@ -0,0 +1,199 @@
+/* GNU linker script for ESP8266 */
+
+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 = 0x40000
+}
+
+/* define the top of RAM */
+_heap_end = ORIGIN(dram0_0_seg) + LENGTH(dram0_0_seg);
+
+PHDRS
+{
+    dport0_0_phdr PT_LOAD;
+    dram0_0_phdr PT_LOAD;
+    dram0_0_bss_phdr PT_LOAD;
+    iram1_0_phdr PT_LOAD;
+    irom0_0_phdr PT_LOAD;
+}
+
+ENTRY(call_user_start)
+
+PROVIDE(_memmap_vecbase_reset = 0x40000000);
+
+/* Various memory-map dependent cache attribute settings: */
+_memmap_cacheattr_wb_base = 0x00000110;
+_memmap_cacheattr_wt_base = 0x00000110;
+_memmap_cacheattr_bp_base = 0x00000220;
+_memmap_cacheattr_unused_mask = 0xFFFFF00F;
+_memmap_cacheattr_wb_trapnull = 0x2222211F;
+_memmap_cacheattr_wba_trapnull = 0x2222211F;
+_memmap_cacheattr_wbna_trapnull = 0x2222211F;
+_memmap_cacheattr_wt_trapnull = 0x2222211F;
+_memmap_cacheattr_bp_trapnull = 0x2222222F;
+_memmap_cacheattr_wb_strict = 0xFFFFF11F;
+_memmap_cacheattr_wt_strict = 0xFFFFF11F;
+_memmap_cacheattr_bp_strict = 0xFFFFF22F;
+_memmap_cacheattr_wb_allvalid = 0x22222112;
+_memmap_cacheattr_wt_allvalid = 0x22222112;
+_memmap_cacheattr_bp_allvalid = 0x22222222;
+PROVIDE(_memmap_cacheattr_reset = _memmap_cacheattr_wb_trapnull);
+
+SECTIONS
+{
+
+    .dport0.rodata : ALIGN(4)
+    {
+        _dport0_rodata_start = ABSOLUTE(.);
+        *(.dport0.rodata)
+        *(.dport.rodata)
+        _dport0_rodata_end = ABSOLUTE(.);
+    } >dport0_0_seg :dport0_0_phdr
+
+    .dport0.literal : ALIGN(4)
+    {
+        _dport0_literal_start = ABSOLUTE(.);
+        *(.dport0.literal)
+        *(.dport.literal)
+        _dport0_literal_end = ABSOLUTE(.);
+    } >dport0_0_seg :dport0_0_phdr
+
+    .dport0.data : ALIGN(4)
+    {
+        _dport0_data_start = ABSOLUTE(.);
+        *(.dport0.data)
+        *(.dport.data)
+        _dport0_data_end = ABSOLUTE(.);
+    } >dport0_0_seg :dport0_0_phdr
+
+    .irom0.text : ALIGN(4)
+    {
+        _irom0_text_start = ABSOLUTE(.);
+        *(.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*)
+        *modpyb.o(.literal*, .text*)
+        *gccollect.o(.literal* .text*)
+        *gchelper.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 */
+
+        _irom0_text_end = ABSOLUTE(.);
+    } >irom0_0_seg :irom0_0_phdr
+
+    .text : ALIGN(4)
+    {
+        _stext = .;
+        _text_start = ABSOLUTE(.);
+        *(.entry.text)
+        *(.init.literal)
+        *(.init)
+        *(.literal .text .literal.* .text.* .stub .gnu.warning .gnu.linkonce.literal.* .gnu.linkonce.t.*.literal .gnu.linkonce.t.*)
+        *(.fini.literal)
+        *(.fini)
+        *(.gnu.version)
+        _text_end = ABSOLUTE(.);
+        _etext = .;
+    } >iram1_0_seg :iram1_0_phdr
+
+    .lit4 : ALIGN(4)
+    {
+        _lit4_start = ABSOLUTE(.);
+        *(*.lit4)
+        *(.lit4.*)
+        *(.gnu.linkonce.lit4.*)
+        _lit4_end = ABSOLUTE(.);
+    } >iram1_0_seg :iram1_0_phdr
+
+    .data : ALIGN(4)
+    {
+        _data_start = ABSOLUTE(.);
+        *(.data)
+        *(.data.*)
+        *(.gnu.linkonce.d.*)
+        *(.data1)
+        *(.sdata)
+        *(.sdata.*)
+        *(.gnu.linkonce.s.*)
+        *(.sdata2)
+        *(.sdata2.*)
+        *(.gnu.linkonce.s2.*)
+        *(.jcr)
+        _data_end = ABSOLUTE(.);
+    } >dram0_0_seg :dram0_0_phdr
+
+    .rodata : ALIGN(4)
+    {
+        _rodata_start = ABSOLUTE(.);
+        *(.rodata)
+        *(.rodata.*)
+        *(.gnu.linkonce.r.*)
+        *(.rodata1)
+        __XT_EXCEPTION_TABLE__ = ABSOLUTE(.);
+        *(.xt_except_table)
+        *(.gcc_except_table)
+        *(.gnu.linkonce.e.*)
+        *(.gnu.version_r)
+        *(.eh_frame)
+        /*  C++ constructor and destructor tables, properly ordered:  */
+        KEEP (*crtbegin.o(.ctors))
+        KEEP (*(EXCLUDE_FILE (*crtend.o) .ctors))
+        KEEP (*(SORT(.ctors.*)))
+        KEEP (*(.ctors))
+        KEEP (*crtbegin.o(.dtors))
+        KEEP (*(EXCLUDE_FILE (*crtend.o) .dtors))
+        KEEP (*(SORT(.dtors.*)))
+        KEEP (*(.dtors))
+        /*  C++ exception handlers table:  */
+        __XT_EXCEPTION_DESCS__ = ABSOLUTE(.);
+        *(.xt_except_desc)
+        *(.gnu.linkonce.h.*)
+        __XT_EXCEPTION_DESCS_END__ = ABSOLUTE(.);
+        *(.xt_except_desc_end)
+        *(.dynamic)
+        *(.gnu.version_d)
+        . = ALIGN(4);        /* this table MUST be 4-byte aligned */
+        _bss_table_start = ABSOLUTE(.);
+        LONG(_bss_start)
+        LONG(_bss_end)
+        _bss_table_end = ABSOLUTE(.);
+        _rodata_end = ABSOLUTE(.);
+    } >dram0_0_seg :dram0_0_phdr
+
+    .bss ALIGN(8) (NOLOAD) : ALIGN(4)
+    {
+        . = ALIGN (8);
+        _bss_start = ABSOLUTE(.);
+        *(.dynsbss)
+        *(.sbss)
+        *(.sbss.*)
+        *(.gnu.linkonce.sb.*)
+        *(.scommon)
+        *(.sbss2)
+        *(.sbss2.*)
+        *(.gnu.linkonce.sb2.*)
+        *(.dynbss)
+        *(.bss)
+        *(.bss.*)
+        *(.gnu.linkonce.b.*)
+        *(COMMON)
+        . = ALIGN (8);
+        _bss_end = ABSOLUTE(.);
+        _heap_start = ABSOLUTE(.);
+    } >dram0_0_seg :dram0_0_bss_phdr
+}
+
+/* get ROM code address */
+INCLUDE "eagle.rom.addr.v6.ld"

esp8266/esp_mphal.c

@@ -0,0 +1,92 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2014 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 "ets_sys.h"
+#include "etshal.h"
+#include "uart.h"
+#include "esp_mphal.h"
+
+extern void ets_wdt_disable(void);
+extern void wdt_feed(void);
+extern void ets_delay_us();
+
+void mp_hal_init(void) {
+    ets_wdt_disable(); // it's a pain while developing
+    uart_init(UART_BIT_RATE_115200, UART_BIT_RATE_115200);
+}
+
+void mp_hal_feed_watchdog(void) {
+    //ets_wdt_disable(); // it's a pain while developing
+    //WRITE_PERI_REG(0x60000914, 0x73);
+    //wdt_feed(); // might also work
+}
+
+void mp_hal_udelay(uint32_t us) {
+    ets_delay_us(us);
+}
+
+int mp_hal_uart0_rx_chr(void) {
+    return uart0_rx();
+}
+
+void mp_hal_uart0_write_str(const char *str) {
+    while (*str) {
+        uart_tx_one_char(UART0, *str++);
+    }
+}
+
+void mp_hal_uart0_write_strn(const char *str, uint32_t len) {
+    while (len--) {
+        uart_tx_one_char(UART0, *str++);
+    }
+}
+
+void mp_hal_uart0_write_strn_cooked(const char *str, uint32_t len) {
+    while (len--) {
+        if (*str == '\n') {
+            uart_tx_one_char(UART0, '\r');
+        }
+        uart_tx_one_char(UART0, *str++);
+    }
+}
+
+uint32_t HAL_GetTick(void) {
+    // TODO
+    return 0;
+}
+
+void HAL_Delay(uint32_t Delay) {
+    mp_hal_udelay(Delay * 1000);
+}
+
+void mp_hal_set_interrupt_char(int c) {
+    // TODO
+}
+
+uint32_t mp_hal_get_cpu_freq(void) {
+    return ets_get_cpu_frequency();
+}

esp8266/esp_mphal.h

@@ -0,0 +1,43 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2014 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.
+ */
+
+#ifndef _INCLUDED_MPHAL_H_
+#define _INCLUDED_MPHAL_H_
+
+void mp_hal_init(void);
+void mp_hal_feed_watchdog(void);
+void mp_hal_udelay(uint32_t);
+int mp_hal_uart0_rx_chr(void);
+void mp_hal_uart0_write_str(const char *str);
+void mp_hal_uart0_write_strn(const char *str, uint32_t len);
+void mp_hal_uart0_write_strn_cooked(const char *str, uint32_t len);
+
+uint32_t HAL_GetTick(void);
+void HAL_Delay(uint32_t Delay);
+void mp_hal_set_interrupt_char(int c);
+uint32_t mp_hal_get_cpu_freq(void);
+
+#endif // _INCLUDED_MPHAL_H_

esp8266/etshal.h

@@ -0,0 +1,10 @@
+#ifndef _INCLUDED_ETSHAL_H_
+#define _INCLUDED_ETSHAL_H_
+
+void ets_isr_unmask();
+void ets_install_putc1();
+void ets_isr_attach();
+void uart_div_modify();
+uint32_t ets_get_cpu_frequency();
+
+#endif // _INCLUDED_ETSHAL_H_

esp8266/gccollect.c

@@ -0,0 +1,65 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2014 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 "mpconfig.h"
+#include "misc.h"
+#include "qstr.h"
+#include "obj.h"
+#include "gc.h"
+#include "gccollect.h"
+
+STATIC uint32_t stack_end;
+
+mp_uint_t gc_helper_get_regs_and_sp(mp_uint_t *regs);
+
+void gc_collect_init(void) {
+    mp_uint_t regs[8];
+    mp_uint_t sp = gc_helper_get_regs_and_sp(regs);
+    stack_end = sp;
+    //printf("stack=%p ram_end=%p %d\n", stack_end, &_ram_end);
+}
+
+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);
+
+    // trace the stack, including the registers (since they live on the stack in this function)
+    gc_collect_root((void**)sp, (stack_end - sp) / sizeof(uint32_t));
+
+    // end the GC
+    gc_collect_end();
+}

esp8266/gccollect.h

@@ -0,0 +1,41 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2014 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.
+ */
+
+extern uint32_t _text_start;
+extern uint32_t _text_end;
+extern uint32_t _irom0_text_start;
+extern uint32_t _irom0_text_end;
+extern uint32_t _data_start;
+extern uint32_t _data_end;
+extern uint32_t _rodata_start;
+extern uint32_t _rodata_end;
+extern uint32_t _bss_start;
+extern uint32_t _bss_end;
+extern uint32_t _heap_start;
+extern uint32_t _heap_end;
+
+void gc_collect_init(void);
+void gc_collect(void);

esp8266/gchelper.s

@@ -0,0 +1,22 @@
+    .file   "gchelper.s"
+    .text
+
+    .align  4
+    .global gc_helper_get_regs_and_sp
+    .type   gc_helper_get_regs_and_sp, @function
+gc_helper_get_regs_and_sp:
+    # store regs into given array
+    s32i.n  a8, a2, 0
+    s32i.n  a9, a2, 4
+    s32i.n  a10, a2, 8
+    s32i.n  a11, a2, 12
+    s32i.n  a12, a2, 16
+    s32i.n  a13, a2, 20
+    s32i.n  a14, a2, 24
+    s32i.n  a15, a2, 28
+
+    # return the sp
+    mov     a2, a1
+    ret.n
+
+    .size   gc_helper_get_regs_and_sp, .-gc_helper_get_regs_and_sp

esp8266/main.c

@@ -0,0 +1,97 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2014 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 <string.h>
+
+#include "mpconfig.h"
+#include "nlr.h"
+#include "misc.h"
+#include "qstr.h"
+#include "lexer.h"
+#include "parse.h"
+#include "obj.h"
+#include "parsehelper.h"
+#include "compile.h"
+#include "runtime0.h"
+#include "runtime.h"
+#include "gc.h"
+#include "pyexec.h"
+#include "gccollect.h"
+#include MICROPY_HAL_H
+
+void user_init(void) {
+soft_reset:
+    //mp_stack_set_limit((char*)&_ram_end - (char*)&_heap_end - 1024);
+    mp_hal_init();
+    gc_init(&_heap_start, &_heap_end);
+    gc_collect_init();
+    mp_init();
+    mp_obj_list_init(mp_sys_path, 0);
+    mp_obj_list_init(mp_sys_argv, 0);
+
+    printf("\n");
+
+    for (;;) {
+        if (pyexec_mode_kind == PYEXEC_MODE_RAW_REPL) {
+            if (pyexec_raw_repl() != 0) {
+                break;
+            }
+        } else {
+            if (pyexec_friendly_repl() != 0) {
+                break;
+            }
+        }
+    }
+
+    goto soft_reset;
+}
+
+mp_lexer_t *mp_lexer_new_from_file(const char *filename) {
+    return NULL;
+}
+
+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) {
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_open_obj, 1, mp_builtin_open);
+
+void nlr_jump_fail(void *val) {
+    printf("NLR jump failed\n");
+    for (;;) {
+    }
+}
+
+//void __assert(const char *file, int line, const char *func, const char *expr) {
+void __assert(const char *file, int line, const char *expr) {
+    printf("Assertion '%s' failed, at file %s:%d\n", expr, file, line);
+    for (;;) {
+    }
+}

esp8266/makeimg.py

@@ -0,0 +1,21 @@
+import sys
+
+assert len(sys.argv) == 4
+
+with open(sys.argv[3], 'wb') as fout:
+
+    with open(sys.argv[1], 'rb') as f:
+        data_flash = f.read()
+        fout.write(data_flash)
+        print('flash    ', len(data_flash))
+
+    pad = b'\xff' * (0x10000 - len(data_flash))
+    fout.write(pad)
+    print('padding  ', len(pad))
+
+    with open(sys.argv[2], 'rb') as f:
+        data_rom = f.read()
+        fout.write(data_rom)
+        print('irom0text', len(data_rom))
+
+    print('total    ', 0x10000 + len(data_rom))

esp8266/modpyb.c

@@ -0,0 +1,164 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2014 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 <stdint.h>
+#include <stdio.h>
+
+#include "mpconfig.h"
+#include "misc.h"
+#include "nlr.h"
+#include "qstr.h"
+#include "obj.h"
+#include "gc.h"
+#include "gccollect.h"
+#include "pyexec.h"
+#include "pybstdio.h"
+#include MICROPY_HAL_H
+
+STATIC mp_obj_t pyb_info(mp_uint_t n_args, const mp_obj_t *args) {
+    // print info about memory
+    {
+        printf("_text_start=%p\n", &_text_start);
+        printf("_text_end=%p\n", &_text_end);
+        printf("_irom0_text_start=%p\n", &_irom0_text_start);
+        printf("_irom0_text_end=%p\n", &_irom0_text_end);
+        printf("_data_start=%p\n", &_data_start);
+        printf("_data_end=%p\n", &_data_end);
+        printf("_rodata_start=%p\n", &_rodata_start);
+        printf("_rodata_end=%p\n", &_rodata_end);
+        printf("_bss_start=%p\n", &_bss_start);
+        printf("_bss_end=%p\n", &_bss_end);
+        printf("_heap_start=%p\n", &_heap_start);
+        printf("_heap_end=%p\n", &_heap_end);
+    }
+
+    // qstr info
+    {
+        mp_uint_t n_pool, n_qstr, n_str_data_bytes, n_total_bytes;
+        qstr_pool_info(&n_pool, &n_qstr, &n_str_data_bytes, &n_total_bytes);
+        printf("qstr:\n  n_pool=" UINT_FMT "\n  n_qstr=" UINT_FMT "\n  n_str_data_bytes=" UINT_FMT "\n  n_total_bytes=" UINT_FMT "\n", n_pool, n_qstr, n_str_data_bytes, n_total_bytes);
+    }
+
+    // GC info
+    {
+        gc_info_t info;
+        gc_info(&info);
+        printf("GC:\n");
+        printf("  " UINT_FMT " total\n", info.total);
+        printf("  " UINT_FMT " : " UINT_FMT "\n", info.used, info.free);
+        printf("  1=" UINT_FMT " 2=" UINT_FMT " m=" UINT_FMT "\n", info.num_1block, info.num_2block, info.max_block);
+    }
+
+    if (n_args == 1) {
+        // arg given means dump gc allocation table
+        gc_dump_alloc_table();
+    }
+
+    return mp_const_none;
+}
+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(mp_hal_get_cpu_freq());
+    } else {
+        // set
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, "can't change freq"));
+    }
+}
+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;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(pyb_sync_obj, pyb_sync);
+
+STATIC mp_obj_t pyb_millis(void) {
+    return MP_OBJ_NEW_SMALL_INT(HAL_GetTick());
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(pyb_millis_obj, pyb_millis);
+
+STATIC mp_obj_t pyb_elapsed_millis(mp_obj_t start) {
+    uint32_t startMillis = mp_obj_get_int(start);
+    uint32_t currMillis = HAL_GetTick();
+    return MP_OBJ_NEW_SMALL_INT((currMillis - startMillis) & 0x3fffffff);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_elapsed_millis_obj, pyb_elapsed_millis);
+
+STATIC mp_obj_t pyb_micros(void) {
+    return MP_OBJ_NEW_SMALL_INT(0);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(pyb_micros_obj, pyb_micros);
+
+STATIC mp_obj_t pyb_elapsed_micros(mp_obj_t start) {
+    uint32_t startMicros = mp_obj_get_int(start);
+    uint32_t currMicros = 0;
+    return MP_OBJ_NEW_SMALL_INT((currMicros - startMicros) & 0x3fffffff);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_elapsed_micros_obj, pyb_elapsed_micros);
+
+STATIC mp_obj_t pyb_delay(mp_obj_t ms_in) {
+    mp_int_t ms = mp_obj_get_int(ms_in);
+    if (ms >= 0) {
+        HAL_Delay(ms);
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_delay_obj, pyb_delay);
+
+STATIC mp_obj_t pyb_udelay(mp_obj_t usec_in) {
+    mp_int_t usec = mp_obj_get_int(usec_in);
+    if (usec >= 0) {
+        mp_hal_udelay(usec);
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_udelay_obj, pyb_udelay);
+
+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 },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_micros), (mp_obj_t)&pyb_micros_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_elapsed_micros), (mp_obj_t)&pyb_elapsed_micros_obj },
+    { 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 },
+};
+
+STATIC MP_DEFINE_CONST_DICT(pyb_module_globals, pyb_module_globals_table);
+
+const mp_obj_module_t pyb_module = {
+    .base = { &mp_type_module },
+    .name = MP_QSTR_pyb,
+    .globals = (mp_obj_dict_t*)&pyb_module_globals,
+};

esp8266/mpconfigport.h

@@ -0,0 +1,71 @@
+#include <stdint.h>
+
+// options to control how Micro Python is built
+
+#define MICROPY_ALLOC_PATH_MAX      (128)
+#define MICROPY_EMIT_X64            (0)
+#define MICROPY_EMIT_THUMB          (0)
+#define MICROPY_EMIT_INLINE_THUMB   (0)
+#define MICROPY_MEM_STATS           (0)
+#define MICROPY_DEBUG_PRINTERS      (0)
+#define MICROPY_ENABLE_GC           (1)
+#define MICROPY_HELPER_REPL         (1)
+#define MICROPY_HELPER_LEXER_UNIX   (0)
+#define MICROPY_ENABLE_SOURCE_LINE  (1)
+#define MICROPY_PY_BUILTINS_STR_UNICODE (1)
+#define MICROPY_PY_BUILTINS_BYTEARRAY (1)
+#define MICROPY_PY_BUILTINS_MEMORYVIEW (1)
+#define MICROPY_PY_BUILTINS_FROZENSET (1)
+#define MICROPY_PY_BUILTINS_SET     (1)
+#define MICROPY_PY_BUILTINS_SLICE   (1)
+#define MICROPY_PY_BUILTINS_PROPERTY (1)
+#define MICROPY_PY___FILE__         (0)
+#define MICROPY_PY_GC               (1)
+#define MICROPY_PY_ARRAY            (1)
+#define MICROPY_PY_COLLECTIONS      (1)
+#define MICROPY_PY_MATH             (0)
+#define MICROPY_PY_CMATH            (0)
+#define MICROPY_PY_IO               (1)
+#define MICROPY_PY_STRUCT           (1)
+#define MICROPY_PY_SYS              (1)
+#define MICROPY_PY_SYS_EXIT         (1)
+#define MICROPY_PY_SYS_STDFILES     (1)
+#define MICROPY_CPYTHON_COMPAT      (0)
+#define MICROPY_LONGINT_IMPL        (MICROPY_LONGINT_IMPL_LONGLONG)
+#define MICROPY_FLOAT_IMPL          (MICROPY_FLOAT_IMPL_NONE)
+#define MICROPY_ERROR_REPORTING     (MICROPY_ERROR_REPORTING_TERSE)
+
+// type definitions for the specific machine
+
+#define BYTES_PER_WORD (4)
+
+#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void*)((mp_uint_t)(p)))
+
+#define UINT_FMT "%u"
+#define INT_FMT "%d"
+
+typedef int32_t mp_int_t; // must be pointer size
+typedef uint32_t mp_uint_t; // must be pointer size
+typedef void *machine_ptr_t; // must be of pointer size
+typedef const void *machine_const_ptr_t; // must be of pointer size
+typedef long mp_off_t;
+
+// extra built in names to add to the global namespace
+extern const struct _mp_obj_fun_builtin_t mp_builtin_open_obj;
+#define MICROPY_PORT_BUILTINS \
+    { MP_OBJ_NEW_QSTR(MP_QSTR_open), (mp_obj_t)&mp_builtin_open_obj },
+
+// extra built in modules to add to the list of known ones
+extern const struct _mp_obj_module_t pyb_module;
+
+#define MICROPY_PORT_BUILTIN_MODULES \
+    { MP_OBJ_NEW_QSTR(MP_QSTR_pyb), (mp_obj_t)&pyb_module }, \
+
+// We need to provide a declaration/definition of alloca()
+#include <alloca.h>
+
+// board specifics
+
+#define MICROPY_HAL_H "esp_mphal.h"
+#define MICROPY_HW_BOARD_NAME "ESP module"
+#define MICROPY_HW_MCU_NAME "ESP8266"

esp8266/pybstdio.c

@@ -0,0 +1,145 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2014 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 "mpconfig.h"
+#include "misc.h"
+#include "qstr.h"
+#include "misc.h"
+#include "obj.h"
+#include "stream.h"
+#include "pybstdio.h"
+#include MICROPY_HAL_H
+
+void stdout_tx_str(const char *str) {
+    stdout_tx_strn(str, strlen(str));
+}
+
+void stdout_tx_strn(const char *str, mp_uint_t len) {
+    mp_hal_uart0_write_strn(str, len);
+}
+
+void stdout_tx_strn_cooked(const char *str, mp_uint_t len) {
+    mp_hal_uart0_write_strn_cooked(str, len);
+}
+
+int stdin_rx_chr(void) {
+    for (;;) {
+        int c = mp_hal_uart0_rx_chr();
+        if (c != -1) {
+            return c;
+        }
+        mp_hal_udelay(1);
+        mp_hal_feed_watchdog();
+    }
+}
+
+/******************************************************************************/
+// Micro Python bindings
+
+#define STDIO_FD_IN  (0)
+#define STDIO_FD_OUT (1)
+#define STDIO_FD_ERR (2)
+
+typedef struct _pyb_stdio_obj_t {
+    mp_obj_base_t base;
+    int fd;
+} pyb_stdio_obj_t;
+
+void stdio_obj_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
+    pyb_stdio_obj_t *self = self_in;
+    print(env, "<io.FileIO %d>", self->fd);
+}
+
+STATIC mp_uint_t stdio_read(mp_obj_t self_in, void *buf, mp_uint_t size, int *errcode) {
+    pyb_stdio_obj_t *self = self_in;
+    if (self->fd == STDIO_FD_IN) {
+        for (uint i = 0; i < size; i++) {
+            int c = stdin_rx_chr();
+            if (c == '\r') {
+                c = '\n';
+            }
+            ((byte*)buf)[i] = c;
+        }
+        return size;
+    } else {
+        *errcode = EPERM;
+        return MP_STREAM_ERROR;
+    }
+}
+
+STATIC mp_uint_t stdio_write(mp_obj_t self_in, const void *buf, mp_uint_t size, int *errcode) {
+    pyb_stdio_obj_t *self = self_in;
+    if (self->fd == STDIO_FD_OUT || self->fd == STDIO_FD_ERR) {
+        stdout_tx_strn_cooked(buf, size);
+        return size;
+    } else {
+        *errcode = EPERM;
+        return MP_STREAM_ERROR;
+    }
+}
+
+STATIC mp_obj_t stdio_obj___exit__(mp_uint_t n_args, const mp_obj_t *args) {
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(stdio_obj___exit___obj, 4, 4, stdio_obj___exit__);
+
+STATIC const mp_map_elem_t stdio_locals_dict_table[] = {
+    { MP_OBJ_NEW_QSTR(MP_QSTR_read), (mp_obj_t)&mp_stream_read_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_readall), (mp_obj_t)&mp_stream_readall_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_readline), (mp_obj_t)&mp_stream_unbuffered_readline_obj},
+    { MP_OBJ_NEW_QSTR(MP_QSTR_write), (mp_obj_t)&mp_stream_write_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_close), (mp_obj_t)&mp_identity_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR___del__), (mp_obj_t)&mp_identity_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR___enter__), (mp_obj_t)&mp_identity_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR___exit__), (mp_obj_t)&stdio_obj___exit___obj },
+};
+
+STATIC MP_DEFINE_CONST_DICT(stdio_locals_dict, stdio_locals_dict_table);
+
+STATIC const mp_stream_p_t stdio_obj_stream_p = {
+    .read = stdio_read,
+    .write = stdio_write,
+    .is_text = true,
+};
+
+STATIC const mp_obj_type_t stdio_obj_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_FileIO,
+    .print = stdio_obj_print,
+    .getiter = mp_identity,
+    .iternext = mp_stream_unbuffered_iter,
+    .stream_p = &stdio_obj_stream_p,
+    .locals_dict = (mp_obj_t)&stdio_locals_dict,
+};
+
+const pyb_stdio_obj_t mp_sys_stdin_obj = {{&stdio_obj_type}, .fd = STDIO_FD_IN};
+const pyb_stdio_obj_t mp_sys_stdout_obj = {{&stdio_obj_type}, .fd = STDIO_FD_OUT};
+const pyb_stdio_obj_t mp_sys_stderr_obj = {{&stdio_obj_type}, .fd = STDIO_FD_ERR};

esp8266/pybstdio.h

@@ -3,7 +3,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2013, 2014 Damien P. George
+ * Copyright (c) 2014 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
@@ -24,5 +24,7 @@
  * THE SOFTWARE.
  */
 
-extern const mp_obj_dict_t mp_builtin_object_dict_obj;
-extern const mp_obj_dict_t mp_builtin_module_dict_obj;
+void stdout_tx_str(const char *str);
+void stdout_tx_strn(const char *str, mp_uint_t len);
+void stdout_tx_strn_cooked(const char *str, mp_uint_t len);
+int stdin_rx_chr(void);

esp8266/qstrdefsport.h

@@ -3,7 +3,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2013, 2014 Damien P. George
+ * Copyright (c) 2014 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
@@ -24,5 +24,18 @@
  * THE SOFTWARE.
  */
 
-void pyb_wlan_init(void);
-void pyb_wlan_start(void);
+// qstrs specific to this port
+
+Q(help)
+
+// pyb module
+Q(pyb)
+Q(info)
+Q(freq)
+Q(millis)
+Q(elapsed_millis)
+Q(micros)
+Q(elapsed_micros)
+Q(delay)
+Q(udelay)
+Q(sync)

esp8266/strtoll.c

@@ -0,0 +1,29 @@
+#include <stdlib.h>
+
+// assumes endptr != NULL
+// doesn't check for sign
+// doesn't check for base-prefix
+long long int strtoll(const char *nptr, char **endptr, int base) {
+    long long val = 0;
+
+    for (; *nptr; nptr++) {
+        int v = *nptr;
+        if ('0' <= v && v <= '9') {
+            v -= '0';
+        } else if ('A' <= v && v <= 'Z') {
+            v -= 'A' - 10;
+        } else if ('a' <= v && v <= 'z') {
+            v -= 'a' - 10;
+        } else {
+            break;
+        }
+        if (v >= base) {
+            break;
+        }
+        val = val * base + v;
+    }
+
+    *endptr = (char*)nptr;
+
+    return val;
+}

esp8266/uart.c

@@ -0,0 +1,191 @@
+/******************************************************************************
+ * Copyright 2013-2014 Espressif Systems (Wuxi)
+ *
+ * FileName: uart.c
+ *
+ * Description: Two UART mode configration and interrupt handler.
+ *              Check your hardware connection while use this mode.
+ *
+ * Modification history:
+ *     2014/3/12, v1.0 create this file.
+*******************************************************************************/
+#include "ets_sys.h"
+#include "osapi.h"
+#include "uart.h"
+#include "osapi.h"
+#include "uart_register.h"
+#include "etshal.h"
+#include "c_types.h"
+
+#define RX_BUF_SIZE (256)
+
+// UartDev is defined and initialized in rom code.
+extern UartDevice UartDev;
+
+// circular buffer for RX buffering
+static uint16_t rx_buf_in;
+static uint16_t rx_buf_out;
+static uint8_t rx_buf[RX_BUF_SIZE];
+
+static void uart0_rx_intr_handler(void *para);
+
+/******************************************************************************
+ * FunctionName : uart_config
+ * Description  : Internal used function
+ *                UART0 used for data TX/RX, RX buffer size is 0x100, interrupt enabled
+ *                UART1 just used for debug output
+ * Parameters   : uart_no, use UART0 or UART1 defined ahead
+ * Returns      : NONE
+*******************************************************************************/
+static void ICACHE_FLASH_ATTR uart_config(uint8 uart_no) {
+    if (uart_no == UART1) {
+        PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO2_U, FUNC_U1TXD_BK);
+    } else {
+        ETS_UART_INTR_ATTACH(uart0_rx_intr_handler, NULL);
+        PIN_PULLUP_DIS(PERIPHS_IO_MUX_U0TXD_U);
+        PIN_FUNC_SELECT(PERIPHS_IO_MUX_U0TXD_U, FUNC_U0TXD);
+        PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDO_U, FUNC_U0RTS);
+    }
+
+    uart_div_modify(uart_no, UART_CLK_FREQ / (UartDev.baut_rate));
+
+    WRITE_PERI_REG(UART_CONF0(uart_no), UartDev.exist_parity
+                 | UartDev.parity
+                 | (UartDev.stop_bits << UART_STOP_BIT_NUM_S)
+                 | (UartDev.data_bits << UART_BIT_NUM_S));
+
+    // clear rx and tx fifo,not ready
+    SET_PERI_REG_MASK(UART_CONF0(uart_no), UART_RXFIFO_RST | UART_TXFIFO_RST);
+    CLEAR_PERI_REG_MASK(UART_CONF0(uart_no), UART_RXFIFO_RST | UART_TXFIFO_RST);
+
+    if (uart_no == UART0) {
+        // set rx fifo trigger
+        WRITE_PERI_REG(UART_CONF1(uart_no),
+                   ((0x10 & UART_RXFIFO_FULL_THRHD) << UART_RXFIFO_FULL_THRHD_S) |
+                   ((0x10 & UART_RX_FLOW_THRHD) << UART_RX_FLOW_THRHD_S) |
+                   UART_RX_FLOW_EN |
+                   (0x02 & UART_RX_TOUT_THRHD) << UART_RX_TOUT_THRHD_S |
+                   UART_RX_TOUT_EN);
+        SET_PERI_REG_MASK(UART_INT_ENA(uart_no), UART_RXFIFO_TOUT_INT_ENA |
+                      UART_FRM_ERR_INT_ENA);
+    } else {
+        WRITE_PERI_REG(UART_CONF1(uart_no),
+                   ((UartDev.rcv_buff.TrigLvl & UART_RXFIFO_FULL_THRHD) << UART_RXFIFO_FULL_THRHD_S));
+    }
+
+    // clear all interrupt
+    WRITE_PERI_REG(UART_INT_CLR(uart_no), 0xffff);
+    // enable rx_interrupt
+    SET_PERI_REG_MASK(UART_INT_ENA(uart_no), UART_RXFIFO_FULL_INT_ENA);
+
+    // init RX buffer
+    rx_buf_in = 0;
+    rx_buf_out = 0;
+}
+
+/******************************************************************************
+ * FunctionName : uart1_tx_one_char
+ * Description  : Internal used function
+ *                Use uart1 interface to transfer one char
+ * Parameters   : uint8 TxChar - character to tx
+ * Returns      : OK
+*******************************************************************************/
+void uart_tx_one_char(uint8 uart, uint8 TxChar) {
+    while (true) {
+        uint32 fifo_cnt = READ_PERI_REG(UART_STATUS(uart)) & (UART_TXFIFO_CNT<<UART_TXFIFO_CNT_S);
+        if ((fifo_cnt >> UART_TXFIFO_CNT_S & UART_TXFIFO_CNT) < 126) {
+            break;
+        }
+    }
+    WRITE_PERI_REG(UART_FIFO(uart), TxChar);
+}
+
+/******************************************************************************
+ * FunctionName : uart1_write_char
+ * Description  : Internal used function
+ *                Do some special deal while tx char is '\r' or '\n'
+ * Parameters   : char c - character to tx
+ * Returns      : NONE
+*******************************************************************************/
+static void ICACHE_FLASH_ATTR
+uart1_write_char(char c) {
+    if (c == '\n') {
+        uart_tx_one_char(UART1, '\r');
+        uart_tx_one_char(UART1, '\n');
+    } else if (c == '\r') {
+    } else {
+        uart_tx_one_char(UART1, c);
+    }
+}
+
+/******************************************************************************
+ * FunctionName : uart0_rx_intr_handler
+ * Description  : Internal used function
+ *                UART0 interrupt handler, add self handle code inside
+ * Parameters   : void *para - point to ETS_UART_INTR_ATTACH's arg
+ * Returns      : NONE
+*******************************************************************************/
+
+static void uart0_rx_intr_handler(void *para) {
+  /* uart0 and uart1 intr combine togther, when interrupt occur, see reg 0x3ff20020, bit2, bit0 represents
+    * uart1 and uart0 respectively
+    */
+
+    uint8 RcvChar;
+    uint8 uart_no = UART0;
+
+    if (UART_FRM_ERR_INT_ST == (READ_PERI_REG(UART_INT_ST(uart_no)) & UART_FRM_ERR_INT_ST)) {
+        // frame error
+        WRITE_PERI_REG(UART_INT_CLR(uart_no), UART_FRM_ERR_INT_CLR);
+    }
+
+    if (UART_RXFIFO_FULL_INT_ST == (READ_PERI_REG(UART_INT_ST(uart_no)) & UART_RXFIFO_FULL_INT_ST)) {
+        // fifo full
+        WRITE_PERI_REG(UART_INT_CLR(uart_no), UART_RXFIFO_FULL_INT_CLR);
+        goto read_chars;
+    } else if (UART_RXFIFO_TOUT_INT_ST == (READ_PERI_REG(UART_INT_ST(uart_no)) & UART_RXFIFO_TOUT_INT_ST)) {
+        WRITE_PERI_REG(UART_INT_CLR(uart_no), UART_RXFIFO_TOUT_INT_CLR);
+        read_chars:
+        while (READ_PERI_REG(UART_STATUS(uart_no)) & (UART_RXFIFO_CNT << UART_RXFIFO_CNT_S)) {
+            RcvChar = READ_PERI_REG(UART_FIFO(uart_no)) & 0xff;
+            uint16_t rx_buf_in_next = (rx_buf_in + 1) % RX_BUF_SIZE;
+            if (rx_buf_in_next != rx_buf_out) {
+                rx_buf[rx_buf_in] = RcvChar;
+                rx_buf_in = rx_buf_in_next;
+            }
+        }
+    }
+}
+
+int uart0_rx(void) {
+  if (rx_buf_out != rx_buf_in) {
+      int chr = rx_buf[rx_buf_out];
+      rx_buf_out = (rx_buf_out + 1) % RX_BUF_SIZE;
+      return chr;
+  } else {
+      return -1;
+  }
+}
+
+/******************************************************************************
+ * FunctionName : uart_init
+ * Description  : user interface for init uart
+ * Parameters   : UartBautRate uart0_br - uart0 bautrate
+ *                UartBautRate uart1_br - uart1 bautrate
+ * Returns      : NONE
+*******************************************************************************/
+void ICACHE_FLASH_ATTR uart_init(UartBautRate uart0_br, UartBautRate uart1_br) {
+    // rom use 74880 baut_rate, here reinitialize
+    UartDev.baut_rate = uart0_br;
+    uart_config(UART0);
+    UartDev.baut_rate = uart1_br;
+    uart_config(UART1);
+    ETS_UART_INTR_ENABLE();
+
+    // install uart1 putc callback
+    os_install_putc1((void *)uart1_write_char);
+}
+
+void ICACHE_FLASH_ATTR uart_reattach() {
+    uart_init(UART_BIT_RATE_74880, UART_BIT_RATE_74880);
+}

esp8266/uart.h

@@ -0,0 +1,96 @@
+#ifndef _INCLUDED_UART_H_
+#define _INCLUDED_UART_H_
+
+#define UART0 (0)
+#define UART1 (1)
+
+typedef enum {
+    UART_FIVE_BITS = 0x0,
+    UART_SIX_BITS = 0x1,
+    UART_SEVEN_BITS = 0x2,
+    UART_EIGHT_BITS = 0x3
+} UartBitsNum4Char;
+
+typedef enum {
+    UART_ONE_STOP_BIT             = 0,
+    UART_ONE_HALF_STOP_BIT        = BIT2,
+    UART_TWO_STOP_BIT             = BIT2
+} UartStopBitsNum;
+
+typedef enum {
+    UART_NONE_BITS = 0,
+    UART_ODD_BITS   = 0,
+    UART_EVEN_BITS = BIT4
+} UartParityMode;
+
+typedef enum {
+    UART_STICK_PARITY_DIS   = 0,
+    UART_STICK_PARITY_EN    = BIT3 | BIT5
+} UartExistParity;
+
+typedef enum {
+    UART_BIT_RATE_9600     = 9600,
+    UART_BIT_RATE_19200   = 19200,
+    UART_BIT_RATE_38400   = 38400,
+    UART_BIT_RATE_57600   = 57600,
+    UART_BIT_RATE_74880   = 74880,
+    UART_BIT_RATE_115200 = 115200,
+    UART_BIT_RATE_230400 = 230400,
+    UART_BIT_RATE_256000 = 256000,
+    UART_BIT_RATE_460800 = 460800,
+    UART_BIT_RATE_921600 = 921600
+} UartBautRate;
+
+typedef enum {
+    UART_NONE_CTRL,
+    UART_HARDWARE_CTRL,
+    UART_XON_XOFF_CTRL
+} UartFlowCtrl;
+
+typedef enum {
+    UART_EMPTY,
+    UART_UNDER_WRITE,
+    UART_WRITE_OVER
+} RcvMsgBuffState;
+
+typedef struct {
+    uint32     RcvBuffSize;
+    uint8     *pRcvMsgBuff;
+    uint8     *pWritePos;
+    uint8     *pReadPos;
+    uint8      TrigLvl; //JLU: may need to pad
+    RcvMsgBuffState  BuffState;
+} RcvMsgBuff;
+
+typedef struct {
+    uint32   TrxBuffSize;
+    uint8   *pTrxBuff;
+} TrxMsgBuff;
+
+typedef enum {
+    UART_BAUD_RATE_DET,
+    UART_WAIT_SYNC_FRM,
+    UART_SRCH_MSG_HEAD,
+    UART_RCV_MSG_BODY,
+    UART_RCV_ESC_CHAR,
+} RcvMsgState;
+
+typedef struct {
+    UartBautRate      baut_rate;
+    UartBitsNum4Char  data_bits;
+    UartExistParity   exist_parity;
+    UartParityMode    parity;    // chip size in byte
+    UartStopBitsNum   stop_bits;
+    UartFlowCtrl      flow_ctrl;
+    RcvMsgBuff        rcv_buff;
+    TrxMsgBuff        trx_buff;
+    RcvMsgState       rcv_state;
+    int               received;
+    int               buff_uart_no;  //indicate which uart use tx/rx buffer
+} UartDevice;
+
+void uart_init(UartBautRate uart0_br, UartBautRate uart1_br);
+int uart0_rx(void);
+void uart_tx_one_char(uint8 uart, uint8 TxChar);
+
+#endif // _INCLUDED_UART_H_

esp8266/uart_register.h

@@ -0,0 +1,128 @@
+//Generated at 2012-07-03 18:44:06
+/*
+ *  Copyright (c) 2010 - 2011 Espressif System
+ *
+ */
+
+#ifndef UART_REGISTER_H_INCLUDED
+#define UART_REGISTER_H_INCLUDED
+#define REG_UART_BASE( i )  (0x60000000+(i)*0xf00)
+//version value:32'h062000
+
+#define UART_FIFO( i )                          (REG_UART_BASE( i ) + 0x0)
+#define UART_RXFIFO_RD_BYTE 0x000000FF
+#define UART_RXFIFO_RD_BYTE_S 0
+
+#define UART_INT_RAW( i )                       (REG_UART_BASE( i ) + 0x4)
+#define UART_RXFIFO_TOUT_INT_RAW (BIT(8))
+#define UART_BRK_DET_INT_RAW (BIT(7))
+#define UART_CTS_CHG_INT_RAW (BIT(6))
+#define UART_DSR_CHG_INT_RAW (BIT(5))
+#define UART_RXFIFO_OVF_INT_RAW (BIT(4))
+#define UART_FRM_ERR_INT_RAW (BIT(3))
+#define UART_PARITY_ERR_INT_RAW (BIT(2))
+#define UART_TXFIFO_EMPTY_INT_RAW (BIT(1))
+#define UART_RXFIFO_FULL_INT_RAW (BIT(0))
+
+#define UART_INT_ST( i )                        (REG_UART_BASE( i ) + 0x8)
+#define UART_RXFIFO_TOUT_INT_ST (BIT(8))
+#define UART_BRK_DET_INT_ST (BIT(7))
+#define UART_CTS_CHG_INT_ST (BIT(6))
+#define UART_DSR_CHG_INT_ST (BIT(5))
+#define UART_RXFIFO_OVF_INT_ST (BIT(4))
+#define UART_FRM_ERR_INT_ST (BIT(3))
+#define UART_PARITY_ERR_INT_ST (BIT(2))
+#define UART_TXFIFO_EMPTY_INT_ST (BIT(1))
+#define UART_RXFIFO_FULL_INT_ST (BIT(0))
+
+#define UART_INT_ENA( i )                       (REG_UART_BASE( i ) + 0xC)
+#define UART_RXFIFO_TOUT_INT_ENA (BIT(8))
+#define UART_BRK_DET_INT_ENA (BIT(7))
+#define UART_CTS_CHG_INT_ENA (BIT(6))
+#define UART_DSR_CHG_INT_ENA (BIT(5))
+#define UART_RXFIFO_OVF_INT_ENA (BIT(4))
+#define UART_FRM_ERR_INT_ENA (BIT(3))
+#define UART_PARITY_ERR_INT_ENA (BIT(2))
+#define UART_TXFIFO_EMPTY_INT_ENA (BIT(1))
+#define UART_RXFIFO_FULL_INT_ENA (BIT(0))
+
+#define UART_INT_CLR( i )                       (REG_UART_BASE( i ) + 0x10)
+#define UART_RXFIFO_TOUT_INT_CLR (BIT(8))
+#define UART_BRK_DET_INT_CLR (BIT(7))
+#define UART_CTS_CHG_INT_CLR (BIT(6))
+#define UART_DSR_CHG_INT_CLR (BIT(5))
+#define UART_RXFIFO_OVF_INT_CLR (BIT(4))
+#define UART_FRM_ERR_INT_CLR (BIT(3))
+#define UART_PARITY_ERR_INT_CLR (BIT(2))
+#define UART_TXFIFO_EMPTY_INT_CLR (BIT(1))
+#define UART_RXFIFO_FULL_INT_CLR (BIT(0))
+
+#define UART_CLKDIV( i )                        (REG_UART_BASE( i ) + 0x14)
+#define UART_CLKDIV_CNT 0x000FFFFF
+#define UART_CLKDIV_S 0
+
+#define UART_AUTOBAUD( i )                      (REG_UART_BASE( i ) + 0x18)
+#define UART_GLITCH_FILT 0x000000FF
+#define UART_GLITCH_FILT_S 8
+#define UART_AUTOBAUD_EN (BIT(0))
+
+#define UART_STATUS( i )                        (REG_UART_BASE( i ) + 0x1C)
+#define UART_TXD (BIT(31))
+#define UART_RTSN (BIT(30))
+#define UART_DTRN (BIT(29))
+#define UART_TXFIFO_CNT 0x000000FF
+#define UART_TXFIFO_CNT_S 16
+#define UART_RXD (BIT(15))
+#define UART_CTSN (BIT(14))
+#define UART_DSRN (BIT(13))
+#define UART_RXFIFO_CNT 0x000000FF
+#define UART_RXFIFO_CNT_S 0
+
+#define UART_CONF0( i )                         (REG_UART_BASE( i ) + 0x20)
+#define UART_TXFIFO_RST (BIT(18))
+#define UART_RXFIFO_RST (BIT(17))
+#define UART_IRDA_EN (BIT(16))
+#define UART_TX_FLOW_EN (BIT(15))
+#define UART_LOOPBACK (BIT(14))
+#define UART_IRDA_RX_INV (BIT(13))
+#define UART_IRDA_TX_INV (BIT(12))
+#define UART_IRDA_WCTL (BIT(11))
+#define UART_IRDA_TX_EN (BIT(10))
+#define UART_IRDA_DPLX (BIT(9))
+#define UART_TXD_BRK (BIT(8))
+#define UART_SW_DTR (BIT(7))
+#define UART_SW_RTS (BIT(6))
+#define UART_STOP_BIT_NUM 0x00000003
+#define UART_STOP_BIT_NUM_S 4
+#define UART_BIT_NUM 0x00000003
+#define UART_BIT_NUM_S 2
+#define UART_PARITY_EN (BIT(1))
+#define UART_PARITY (BIT(0))
+
+#define UART_CONF1( i )                         (REG_UART_BASE( i ) + 0x24)
+#define UART_RX_TOUT_EN (BIT(31))
+#define UART_RX_TOUT_THRHD 0x0000007F
+#define UART_RX_TOUT_THRHD_S 24
+#define UART_RX_FLOW_EN (BIT(23))
+#define UART_RX_FLOW_THRHD 0x0000007F
+#define UART_RX_FLOW_THRHD_S 16
+#define UART_TXFIFO_EMPTY_THRHD 0x0000007F
+#define UART_TXFIFO_EMPTY_THRHD_S 8
+#define UART_RXFIFO_FULL_THRHD 0x0000007F
+#define UART_RXFIFO_FULL_THRHD_S 0
+
+#define UART_LOWPULSE( i )                      (REG_UART_BASE( i ) + 0x28)
+#define UART_LOWPULSE_MIN_CNT         0x000FFFFF
+#define UART_LOWPULSE_MIN_CNT_S     0
+
+#define UART_HIGHPULSE( i )                     (REG_UART_BASE( i ) + 0x2C)
+#define UART_HIGHPULSE_MIN_CNT         0x000FFFFF
+#define UART_HIGHPULSE_MIN_CNT_S     0
+
+#define UART_PULSE_NUM( i )                     (REG_UART_BASE( i ) + 0x30)
+#define UART_PULSE_NUM_CNT                  0x0003FF
+#define UART_PULSE_NUM_CNT_S               0
+
+#define UART_DATE( i )                          (REG_UART_BASE( i ) + 0x78)
+#define UART_ID( i )                            (REG_UART_BASE( i ) + 0x7C)
+#endif // UART_REGISTER_H_INCLUDED

esp8266/user_config.h

@@ -0,0 +1 @@
+// empty

examples/SDdatalogger/datalogger.py

@@ -19,7 +19,7 @@ while True:
     if switch():
         pyb.delay(200)                      # delay avoids detection of multiple presses
         blue.on()                           # blue LED indicates file open
-        log = open('1:/log.csv', 'w')       # open file on SD (SD: '1:/', flash: '0/)
+        log = open('/sd/log.csv', 'w')       # open file on SD (SD: '/sd/', flash: '/flash/)
 
         # until switch is pressed again
         while not switch():

examples/conwaylife.py

@@ -1,7 +1,9 @@
 #import essential libraries
-import lcd
 import pyb
 
+lcd = pyb.LCD('x')
+lcd.light(1)
+
 # do 1 iteration of Conway's Game of Life
 def conway_step():
     for x in range(128):        # loop over x coordinates
@@ -21,26 +23,24 @@ def conway_step():
 
             # apply the rules of life
             if self and not (2 <= num_neighbours <= 3):
-                lcd.reset(x, y) # not enough, or too many neighbours: cell dies
+                lcd.pixel(x, y, 0) # not enough, or too many neighbours: cell dies
             elif not self and num_neighbours == 3:
-                lcd.set(x, y)   # exactly 3 neigbours around an empty cell: cell is born
+                lcd.pixel(x, y, 1)   # exactly 3 neigbours around an empty cell: cell is born
 
 # randomise the start
 def conway_rand():
-    lcd.clear()                 # clear the LCD
+    lcd.fill(0)                 # clear the LCD
     for x in range(128):        # loop over x coordinates
         for y in range(32):     # loop over y coordinates
-            if pyb.rand() & 1:  # get a 1-bit random number
-                lcd.set(x, y)   # set the pixel randomly
+            lcd.pixel(x, y, pyb.rng() & 1)   # set the pixel randomly
 
 # loop for a certain number of frames, doing iterations of Conway's Game of Life
 def conway_go(num_frames):
     for i in range(num_frames):
         conway_step()           # do 1 iteration
         lcd.show()              # update the LCD
-        pyb.delay(300)
+        pyb.delay(50)
 
-# PC testing
-lcd = lcd.LCD(128, 32)
+# testing
 conway_rand()
-conway_go(1000)
+conway_go(100)