docs: Update all WiPy docs to reflect the new API.

cc3200/mods/modmachine.c

@@ -40,18 +40,13 @@
 #include "rom_map.h"
 #include "prcm.h"
 #include "pyexec.h"
-#include "ff.h"
-#include "diskio.h"
-#include "sflash_diskio.h"
 #include "pybuart.h"
 #include "pybpin.h"
 #include "pybrtc.h"
-#include "mpsystick.h"
 #include "simplelink.h"
 #include "modnetwork.h"
 #include "modwlan.h"
 #include "moduos.h"
-#include "telnet.h"
 #include "FreeRTOS.h"
 #include "portable.h"
 #include "task.h"
@@ -67,7 +62,6 @@
 #include "utils.h"
 #include "gccollect.h"
 #include "mperror.h"
-#include "genhdr/mpversion.h"
 
 
 #ifdef DEBUG

cc3200/mods/pybuart.c

@@ -558,7 +558,7 @@ STATIC mp_obj_t pyb_uart_irq (mp_uint_t n_args, const mp_obj_t *pos_args, mp_map
 invalid_args:
     nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_uart_callback_obj, 1, pyb_uart_irq);
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_uart_irq_obj, 1, pyb_uart_irq);
 
 STATIC const mp_map_elem_t pyb_uart_locals_dict_table[] = {
     // instance methods
@@ -566,7 +566,7 @@ STATIC const mp_map_elem_t pyb_uart_locals_dict_table[] = {
     { MP_OBJ_NEW_QSTR(MP_QSTR_deinit),      (mp_obj_t)&pyb_uart_deinit_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_any),         (mp_obj_t)&pyb_uart_any_obj },
     { MP_OBJ_NEW_QSTR(MP_QSTR_sendbreak),   (mp_obj_t)&pyb_uart_sendbreak_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_irq),         (mp_obj_t)&pyb_uart_callback_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_irq),         (mp_obj_t)&pyb_uart_irq_obj },
 
     /// \method read([nbytes])
     { MP_OBJ_NEW_QSTR(MP_QSTR_read),        (mp_obj_t)&mp_stream_read_obj },

docs/conf.py

@@ -300,6 +300,11 @@ html_context = {
 
 # Append the other ports' specific folders/files to the exclude pattern
 exclude_patterns.extend([port + '*' for port in ports if port != micropy_port])
+# Exclude pyb module if the port is the WiPy
+if micropy_port == 'wipy':
+    exclude_patterns.append('library/pyb*')
+else: # exclude machine
+    exclude_patterns.append('library/machine*')
 
 # Specify a custom master document based on the port name
 master_doc = micropy_port + '_' + 'index'

docs/library/index.rst

@@ -89,8 +89,6 @@ it will fallback to loading the built-in ``ujson`` module.
       :maxdepth: 1
 
       ubinascii.rst
-      uhashlib.rst
-      uheapq.rst
       ujson.rst
       ure.rst
       usocket.rst
@@ -105,7 +103,7 @@ it will fallback to loading the built-in ``ujson`` module.
    .. toctree::
       :maxdepth: 2
 
-      pyb.rst
+      machine.rst
       network.rst
 
 

docs/library/machine.ADC.rst

@@ -0,0 +1,73 @@
+.. _machine.ADC:
+
+class ADC -- analog to digital conversion
+=========================================
+
+Usage::
+
+   import machine
+
+   adc = machine.ADC()             # create an ADC object
+   apin = adc.channel(pin='GP3')   # create an analog pin on GP3
+   val = apin()                    # read an analog value
+
+Constructors
+------------
+
+.. class:: machine.ADC(id=0, \*, bits=12)
+
+   Create an ADC object associated with the given pin.
+   This allows you to then read analog values on that pin.
+   For more info check the `pinout and alternate functions
+   table. <https://raw.githubusercontent.com/wipy/wipy/master/docs/PinOUT.png>`_ 
+
+   .. warning:: 
+
+      ADC pin input range is 0-1.4V (being 1.8V the absolute maximum that it 
+      can withstand). When GP2, GP3, GP4 or GP5 are remapped to the 
+      ADC block, 1.8 V is the maximum. If these pins are used in digital mode, 
+      then the maximum allowed input is 3.6V.
+
+Methods
+-------
+
+.. method:: adc.channel(id, \*, pin)
+
+   Create an analog pin. If only channel ID is given, the correct pin will
+   be selected. Alternatively, only the pin can be passed and the correct
+   channel will be selected. Examples::
+
+      # all of these are equivalent and enable ADC channel 1 on GP3
+      apin = adc.channel(1)
+      apin = adc.channel(pin='GP3')
+      apin = adc.channel(id=1, pin='GP3')
+
+.. method:: adc.init()
+
+   Enable the ADC block.
+
+.. method:: adc.deinit()
+
+   Disable the ADC block.
+
+class ADCChannel --- read analog values from internal or external sources
+=========================================================================
+
+ADC channels can be connected to internal points of the MCU or to GPIO pins.
+ADC channels are created using the ADC.channel method.
+
+.. method:: adcchannel()
+
+   Fast method to read the channel value.
+
+.. method:: adcchannel.value()
+
+   Read the channel value.
+
+.. method:: adcchannel.init()
+
+   Re-init (and effectively enable) the ADC channel.
+
+.. method:: adcchannel.deinit()
+
+   Disable the ADC channel.

docs/library/machine.HeartBeat.rst

@@ -1,4 +1,4 @@
-.. _pyb.HeartBeat:
+.. _machine.HeartBeat:
 
 class HeartBeat -- heart beat LED
 =================================
@@ -11,14 +11,14 @@ can be used to control the light intesity of the heart beat LED.
 
 Example usage::
 
-    hb = pyb.HeartBeat()
+    hb = machine.HeartBeat()
     hb.disable()    # disable the heart beat
     hb.enable()     # enable the heart beat
 
 Constructors
 ------------
 
-.. class:: pyb.HeartBeat()
+.. class:: machine.HeartBeat()
 
    Create a HeartBeat object.
 
@@ -35,12 +35,13 @@ Methods
 
    Example::
    
-      import pyb
+      from machine import HeartBeat
+      from machine import Pin
    
       # disable the heart beat
-      pyb.HeartBeat().disable()
+      HeartBeat().disable()
-      # get the GP25 pin object
+      # init GP25 as output
-      hbl = pyb.Pin('GP25')
+      led = Pin('GP25', mode=Pin.OUT)
       # toggle the led
-      hbl.toggle()
+      led.toggle()
       ...

docs/library/machine.I2C.rst

@@ -0,0 +1,117 @@
+.. _machine.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.
+
+.. only:: port_wipy
+
+    Example::
+
+        from machine import I2C
+
+        i2c = I2C(0)                         # create on bus 0
+        i2c = I2C(0, I2C.MASTER)             # create and init as a master
+        i2c.init(I2C.MASTER, baudrate=20000) # init as a master
+        i2c.deinit()                         # turn off the peripheral
+
+Printing the i2c object gives you information about its configuration.
+
+.. only:: port_wipy
+
+    A master must specify the recipient's address::
+
+        i2c.init(I2C.MASTER)
+        i2c.writeto(0x42, '123')        # send 3 bytes to slave with address 0x42
+        i2c.writeto(addr=0x42, b'456')  # keyword for address
+
+    Master also has other methods::
+
+        i2c.scan()                          # scan for slaves on the bus, returning
+                                            #   a list of valid addresses
+        i2c.readfrom_mem(0x42, 2, 3)        # read 3 bytes from memory of slave 0x42,
+                                            #   starting at address 2 in the slave
+        i2c.writeto_mem(0x42, 2, 'abc')     # write 'abc' (3 bytes) to memory of slave 0x42
+                                            # starting at address 2 in the slave, timeout after 1 second
+
+Constructors
+------------
+
+.. only:: port_wipy
+
+    .. class:: machine.I2C(bus, ...)
+
+       Construct an I2C object on the given bus.  `bus` can only be 0.
+       If the bus is not given, the default one will be selected (0).
+
+Methods
+-------
+
+.. method:: i2c.deinit()
+
+   Turn off the I2C bus.
+
+.. only:: port_wipy
+
+    .. method:: i2c.init(mode, \*, baudrate=100000, pins=(SDA, SCL))
+
+      Initialise the I2C bus with the given parameters:
+
+         - ``mode`` must be ``I2C.MASTER``
+         - ``baudrate`` is the SCL clock rate
+         - ``pins`` is an optional tuple with the pins to assign to the I2C bus.
+
+    .. method:: i2c.readfrom(addr, nbytes)
+
+        Read ``nbytes`` from the slave specified by ``addr``.
+        Returns a ``bytes`` object with the data read.
+
+    .. method:: i2c.readfrom_into(addr, buf)
+
+        Read into ``buf`` from the slave specified by ``addr``.
+        Returns the number of bytes read.
+
+    .. method:: i2c.writeto(addr, buf, \*, stop=True)
+
+        Write ``buf`` to the slave specified by ``addr``. Set ``stop`` to ``False``
+        if the transfer should be continued.
+        Returns the number of bytes written.
+
+    .. method:: i2c.readfrom_mem(addr, memaddr, nbytes, \*, addrsize=8)
+
+        Read ``nbytes`` from the slave specified by ``addr`` starting from the memory
+        address specified by ``memaddr``.
+        Param ``addrsize`` specifies the address size in bits.
+        Returns a ``bytes`` object with the data read.
+
+    .. method:: i2c.readfrom_mem_into(addr, memaddr, buf, \*, addrsize=8)
+
+        Read into ``buf`` from the slave specified by ``addr`` starting from the memory
+        address specified by ``memaddr``.
+        Param ``addrsize`` specifies the address size in bits.
+        Returns the number of bytes read.
+
+    .. method:: i2c.writeto_mem(addr, memaddr, buf, \*, addrsize=8)
+
+        Write ``buf`` to the slave specified by ``addr`` starting from the
+        memory address specified by ``memaddr``. Param ``addrsize`` specifies the 
+        address size in bits.
+        Set ``stop`` to ``False`` if the transfer should be continued.
+        Returns the number of bytes written.
+
+.. 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.
+
+Constants
+---------
+
+.. data:: I2C.MASTER
+
+   for initialising the bus to master mode

docs/library/machine.Pin.rst

@@ -0,0 +1,206 @@
+.. _machine.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:
+
+.. only:: port_wipy
+
+    Board pins are identified by their string id::
+
+        g = machine.Pin('GP9', mode=machine.Pin.OUT, pull=None, drive=machine.Pin.MED_POWER, alt=-1)
+
+    You can also configure the Pin to generate interrupts. For instance::
+
+        def pincb(pin):
+            print(pin.id())
+
+        pin_int = machine.Pin('GP10', mode=Pin.IN, pull=machine.Pin.PULL_DOWN)
+        pin_int.irq(mode=machine.Pin.IRQ_RISING, handler=pincb)
+        # the callback can be triggered manually
+        pin_int.irq()()
+        # to disable the callback
+        pin_int.irq().disable()
+
+    Now every time a falling edge is seen on the gpio pin, the callback will be
+    executed. Caution: mechanical push buttons 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.
+
+    All pin objects go through the pin mapper to come up with one of the
+    gpio pins.
+
+Constructors
+------------
+
+.. class:: machine.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`.
+
+Methods
+-------
+
+.. only:: port_wipy
+
+    .. method:: pin.init(mode, pull, \*, drive, alt)
+    
+       Initialise the pin:
+
+         - ``mode`` can be one of:
+
+            - ``Pin.IN``  - input pin.
+            - ``Pin.OUT`` - output pin in push-pull mode.
+            - ``Pin.OPEN_DRAIN`` - output pin in open-drain mode.
+            - ``Pin.ALT`` - pin mapped to an alternate function.
+            - ``Pin.ALT_OPEN_DRAIN`` - pin mapped to an alternate function in open-drain mode.
+
+         - ``pull`` can be one of:
+
+            - ``None`` - no pull up or down resistor.
+            - ``Pin.PULL_UP`` - pull up resistor enabled.
+            - ``Pin.PULL_DOWN`` - pull down resitor enabled.
+
+         - ``drive`` can be one of:
+
+            - ``Pin.LOW_POWER`` - 2mA drive capability.
+            - ``Pin.MED_POWER`` - 4mA drive capability.
+            - ``Pin.HIGH_POWER`` - 6mA drive capability.
+
+         - ``alt`` is the number of the alternate function. Please refer to the
+           `pinout and alternate functions table. <https://raw.githubusercontent.com/wipy/wipy/master/docs/PinOUT.png>`_
+           for the specific alternate functions that each pin supports.
+
+       Returns: ``None``.
+
+    .. method:: pin.id()
+
+       Get the pin id.
+
+.. 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.alt_list()
+
+    Returns a list of the alternate functions supported by the pin. List items are
+    a tuple of the form: ``('ALT_FUN_NAME', ALT_FUN_INDEX)``
+
+.. only:: port_wipy
+
+    .. method:: pin([value])
+
+       Pin objects are callable. The call method provides a (fast) shortcut to set and get the value of the pin.
+       See **pin.value** for more details.
+
+    .. method:: pin.toggle()
+
+        Toggle the value of the pin.
+
+    .. method:: pin.mode([mode])
+
+        Get or set the pin mode.
+
+    .. method:: pin.pull([pull])
+
+        Get or set the pin pull.
+
+    .. method:: pin.drive([drive])
+
+        Get or set the pin drive strength.
+
+    .. method:: pin.irq(\*, trigger, priority=1, handler=None, wake=None)
+
+        Create a callback to be triggered when the input level at the pin changes.
+
+            - ``trigger`` configures the pin level which can generate an interrupt. Possible values are:
+
+                - ``Pin.IRQ_FALLING`` interrupt on falling edge.
+                - ``Pin.IRQ_RISING`` interrupt on rising edge.
+                - ``Pin.IRQ_LOW_LEVEL`` interrupt on low level.
+                - ``Pin.IRQ_HIGH_LEVEL`` interrupt on high level.
+              
+              The values can be *ORed* together, for instance mode=Pin.IRQ_FALLING | Pin.IRQ_RISING
+
+            - ``priority`` level of the interrupt. Can take values in the range 1-7.
+              Higher values represent higher priorities.
+            - ``handler`` is an optional function to be called when new characters arrive.
+            - ``wakes`` selects the power mode in which this interrupt can wake up the
+              board. Please note:
+
+              - If ``wake_from=machine.Sleep.ACTIVE`` any pin can wake the board.
+              - If ``wake_from=machine.Sleep.SUSPENDED`` pins ``GP2``, ``GP4``, ``GP10``,
+                ``GP11``, GP17`` or ``GP24`` can wake the board. Note that only 1
+                of this pins can be enabled as a wake source at the same time, so, only
+                the last enabled pin as a ``machine.Sleep.SUSPENDED`` wake source will have effect.
+              - If ``wake_from=machine.Sleep.SUSPENDED`` pins ``GP2``, ``GP4``, ``GP10``,
+                ``GP11``, ``GP17`` and ``GP24`` can wake the board. In this case all of the
+                6 pins can be enabled as a ``machine.Sleep.HIBERNATE`` wake source at the same time.
+              - Values can be ORed to make a pin generate interrupts in more than one power
+                mode.
+
+            Returns a callback object.
+
+Attributes
+----------
+
+.. class:: Pin.board
+
+    Contains all ``Pin`` objects supported by the board. Examples::
+
+        Pin.board.GP25
+        led = Pin(Pin.board.GP25, mode=Pin.OUT)
+        Pin.board.GP2.alt_list()
+
+
+Constants
+---------
+
+.. only:: port_wipy
+
+    .. data:: Pin.IN
+
+    .. data:: Pin.OUT
+    
+    .. data:: Pin.OPEN_DRAIN
+
+    .. data:: Pin.ALT
+
+    .. data:: Pin.ALT_OPEN_DRAIN
+
+       Selects the pin mode.
+
+    .. data:: Pin.PULL_UP
+
+    .. data:: Pin.PULL_DOWN
+    
+       Selectes the wether there's pull up/down resistor.
+
+    .. data:: Pin.LOW_POWER
+
+    .. data:: Pin.MED_POWER
+
+    .. data:: Pin.HIGH_POWER
+
+        Selects the drive strength.
+
+    .. data:: Pin.IRQ_FALLING
+
+    .. data:: Pin.IRQ_RISING
+
+    .. data:: Pin.IRQ_LOW_LEVEL
+
+    .. data:: Pin.IRQ_HIGH_LEVEL
+
+        Selects the IRQ trigger type.

docs/library/machine.RTC.rst

@@ -0,0 +1,68 @@
+.. _machine.RTC:
+
+class RTC -- real time clock
+============================
+
+The RTC is and independent clock that keeps track of the date
+and time.
+
+Example usage::
+
+    rtc = machine.RTC()
+    rtc.datetime((2014, 5, 1, 4, 13, 0, 0, 0))
+    print(rtc.datetime())
+
+
+Constructors
+------------
+
+.. class:: machine.RTC(id=0, ...)
+
+   Create an RTC object. See init for parameters of initialization.
+
+Methods
+-------
+
+.. method:: rtc.init(id, datetime)
+
+   Initialise the RTC. Datetime is a tuple of the form:
+   
+      ``(year, month, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]])``
+
+.. method:: rtc.now()
+
+   Get get the current datetime tuple.
+
+.. method:: rtc.deinit()
+
+   Resets the RTC to the time of January 1, 2015 and starts running it again.
+
+.. method:: rtc.alarm(id, time, /*, repeat=False)
+
+   Set the RTC alarm. Time might be either a milllisecond value to program the alarm to
+   current time + time_in_ms in the future, or a datetimetuple. If the time passed is in
+   milliseconds, repeat can be set to ``True`` to make the alarm periodic.
+
+.. method:: rtc.alarm_left(alarm_id=0)
+
+   Get the number of milliseconds left before the alarm expires.
+
+.. method:: rtc.cancel(alarm_id=0)
+
+   Cancel a running alarm.
+
+.. method:: rtc.irq(\*, trigger, handler=None, wake=machine.IDLE)
+
+   Create an irq object triggered by a real time clock alarm.
+
+      - ``trigger`` must be ``RTC.ALARM0``
+      - ``handler`` is the function to be called when the callback is triggered.
+      - ``wake`` specifies the sleep mode from where this interrupt can wake
+        up the system.
+
+Constants
+---------
+
+.. data:: RTC.ALARM0
+
+    irq trigger source

docs/library/machine.SD.rst

@@ -1,4 +1,4 @@
-.. _pyb.SD:
+.. _machine.SD:
 
 class SD -- secure digital memory card
 ======================================
@@ -13,36 +13,30 @@ more info regarding the pins which can be remapped to be used with a SD card.
 
 Example usage::
 
-    # data, clk and cmd pins must be passed along with
+    from machine import SD
+    import os
+    # clk cmd and dat0 pins must be passed along with
     # their respective alternate functions
-    sd = pyb.SD(('GP15', 8, 'GP10', 6, 'GP11', 6))
+    sd = machine.SD(pins=('GP10', 'GP11', 'GP15'))
-    sd.mount()
+    os.mount(sd, '/sd')
     # do normal file operations
 
 Constructors
 ------------
 
-.. class:: pyb.SD([pins_tuple])
+.. class:: machine.SD(id,... )
 
-   Create a SD card object. In order to initalize the card, give it a 6-tuple
+   Create a SD card object. See init for parameters if initialization. 
-   ``(dat_pin, dat_af, clk_pin, clk_af, cmd_pin, cmd_af)`` with the data, clock
-   and cmd pins together their respective alternate functions.
 
 Methods
 -------
 
-.. method:: sd.init([pins_tuple])
+.. method:: sd.init(id, pins=('GP10', 'GP11', 'GP15'))
 
    Enable the SD card.
+   In order to initalize the card, give it a 3-tuple ``(clk_pin, cmd_pin, dat0_pin)``
+   ID defaults to zero.
 
 .. method:: sd.deinit()
 
-   Disable the SD card (also unmounts it to avoid file system crashes).
+   Disable the SD card.
-
-.. method:: sd.mount()
-
-   Mount the SD card on the file system. Accesible as ``/sd``.
-
-.. method:: sd.unmount()
-
-   Unmount the SD card from the file system.

docs/library/machine.SPI.rst

@@ -0,0 +1,85 @@
+.. _machine.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.
+
+.. only:: port_wipy
+
+    See usage model of I2C; SPI is very similar.  Main difference is
+    parameters to init the SPI bus::
+
+        from machine import SPI
+        spi = SPI(0, mode=SPI.MASTER, baudrate=1000000, polarity=0, phase=0, firstbit=SPI.MSB)
+
+    Only required parameter is mode, must be SPI.MASTER.  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.
+
+Constructors
+------------
+
+.. only:: port_wipy
+
+    .. class:: machine.SPI(id, ...)
+
+       Construct an SPI object on the given bus.  ``id`` can be only 0.
+       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.
+
+Methods
+-------
+
+.. method:: spi.init(mode, baudrate=1000000, \*, polarity=0, phase=0, bits=8, firstbit=SPI.MSB, pins=(CLK, MOSI, MISO))
+
+   Initialise the SPI bus with the given parameters:
+
+     - ``mode`` must be ``SPI.MASTER``.
+     - ``baudrate`` is the SCK clock rate.
+     - ``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.
+     - ``bits`` is the width of each transfer, accepted values are 8, 16 and 32.
+     - ``firstbit`` can be ``SPI.MSB`` only.
+     - ``pins`` is an optional tupple with the pins to assign to the SPI bus.
+
+.. method:: spi.deinit()
+
+   Turn off the SPI bus.
+
+.. method:: spi.write(buf)
+
+    Write the data contained in ``buf``. 
+    Returns the number of bytes written.
+
+.. method:: spi.read(nbytes, *, write=0x00)
+
+    Read the ``nbytes`` while writing the data specified by ``write``.
+    Return the number of bytes read.
+
+.. method:: spi.readinto(buf, *, write=0x00)
+
+    Read into the buffer specified by ``buf`` while writing the data specified by
+    ``write``.
+    Return the number of bytes read.
+
+.. method:: spi.write_readinto(write_buf, read_buf)
+
+    Write from ``write_buf`` and read into ``read_buf``. Both buffers must have the
+    same length.
+    Returns the number of bytes written
+
+Constants
+---------
+
+.. data:: SPI.MASTER
+
+   for initialising the SPI bus to master
+
+.. data:: SPI.MSB
+
+   set the first bit to be the most significant bit

docs/library/machine.Timer.rst

@@ -0,0 +1,193 @@
+.. _machine.Timer:
+
+class Timer -- control internal timers
+======================================
+
+.. only:: port_wipy
+
+    .. note::
+
+        Contrary with the rest of the API, timer IDs start at 1, not a t zero. This is because
+        the ``Timer`` API is still provisional. A new MicroPython wide API will come soon.
+
+    Timers can be used for a great variety of tasks, calling a function periodically,
+    counting events, and generating a PWM signal are among the most common use cases.
+    Each timer consists of 2 16-bit channels and this channels can be tied together to
+    form 1 32-bit timer. The operating mode needs to be configured per timer, but then
+    the period (or the frequency) can be independently configured on each channel. 
+    By using the callback method, the timer event can call a Python function.
+
+    Example usage to toggle an LED at a fixed frequency::
+
+        tim = machine.Timer(4)                                              # create a timer object using timer 4
+        tim.init(mode=Timer.PERIODIC)                                   # initialize it in periodic mode
+        tim_ch = tim.channel(Timer.A, freq=2)                           # configure channel A at a frequency of 2Hz
+        tim_ch.callback(handler=lambda t:led.toggle())                  # toggle a LED on every cycle of the timer
+
+    Example using named function for the callback::
+
+        tim = Timer(1, mode=Timer.PERIODIC)
+        tim_a = tim.channel(Timer.A, freq=1000)
+
+        led = Pin('GPIO2', af=0, mode=Pin.OUT)
+
+        def tick(timer):                # we will receive the timer object when being called
+            print(timer.time())         # show current timer's time value (is microseconds)
+            led.toggle()                # toggle the LED
+
+        tim_a.callback(handler=tick)
+
+    Further examples::
+
+        tim1 = machine.Timer(2, mode=Timer.EVENT_COUNT)                     # initialize it capture mode
+        tim2 = machine.Timer(1, mode=Timer.PWM)                             # initialize it in PWM mode
+        tim_ch = tim1.channel(Timer.A, freq=1, polarity=Timer.POSITIVE) # start the event counter with a frequency of 1Hz and triggered by positive edges
+        tim_ch = tim2.channel(Timer.B, freq=10000, duty_cycle=50)       # start the PWM on channel B with a 50% duty cycle
+        tim_ch.time()                                                   # get the current time in usec (can also be set)
+        tim_ch.freq(20)                                                 # set the frequency (can also get)
+        tim_ch.duty_cycle(30)                                           # set the duty cycle to 30% (can also get)
+        tim_ch.duty_cycle(30, Timer.NEGATIVE)                           # set the duty cycle to 30% and change the polarity to negative
+        tim_ch.event_count()                                            # get the number of captured events
+        tim_ch.event_time()                                             # get the the time of the last captured event
+        tim_ch.period(2000000)                                          # change the period to 2 seconds
+
+
+.. note::
+
+    Memory can't be allocated during a callback (an interrupt) and so
+    exceptions raised within a callback don't give much information.  See
+    :func:`micropython.alloc_emergency_exception_buf` for how to get around this
+    limitation.
+
+Constructors
+------------
+
+.. class:: machine.Timer(id, ...)
+
+    .. only:: port_wipy
+
+       Construct a new timer object of the given id.  If additional
+       arguments are given, then the timer is initialised by ``init(...)``.
+       ``id`` can be 1 to 4.
+
+
+Methods
+-------
+
+.. only:: port_wipy
+
+    .. method:: timer.init(mode, \*, width=16)
+
+       Initialise the timer. Example::
+
+           tim.init(Timer.PERIODIC)             # periodic 16-bit timer
+           tim.init(Timer.ONE_SHOT, width=32)   # one shot 32-bit timer
+
+       Keyword arguments:
+       
+         - ``mode`` can be one of:
+         
+           - ``Timer.ONE_SHOT`` - The timer runs once until the configured 
+             period of the channel expires.
+           - ``Timer.PERIODIC`` - The timer runs periodically at the configured 
+             frequency of the channel.
+           - ``Timer.EDGE_TIME`` - Meaure the time pin level changes.
+           - ``Timer.EDGE_COUNT`` - Count the number of pin level changes.
+
+         - ``width`` must be either 16 or 32 (bits). For really low frequencies <= ~1Hz
+           (or large periods), 32-bit timers should be used. 32-bit mode is only available
+           for ``ONE_SHOT`` AND ``PERIODIC`` modes.
+
+.. method:: timer.deinit()
+
+   Deinitialises the timer. Disables all channels and associated IRQs.
+   Stops the timer, and disables the timer peripheral.
+
+.. only:: port_wipy
+
+    .. method:: timer.channel(channel, \**, freq, period, polarity=Timer.POSITIVE, duty_cycle=0)
+    
+       If only a channel identifier passed, then a previously initialized channel
+       object is returned (or ``None`` if there is no previous channel).
+       
+       Othwerwise, a TimerChannel object is initialized and returned.
+       
+       The operating mode is is the one configured to the Timer object that was used to
+       create the channel.
+
+       - ``channel`` if the width of the timer is 16-bit, then must be either ``TIMER.A``, ``TIMER.B``. 
+         If the width is 32-bit then it **must be** ``TIMER.A | TIMER.B``.
+
+       Keyword only arguments:
+
+         - ``freq`` sets the frequency in Hz.
+         - ``period`` sets the period in microseconds.
+
+         .. note::
+
+            Either ``freq`` or ``period`` must be given, never both.
+
+         - ``polarity`` this is applicable for:
+           
+           - ``PWM``, defines the polarity of the duty cycle
+           - ``EDGE_TIME`` and ``EDGE_COUNT``, defines the polarity of the pin level change to detect.
+             To detect both rising and falling edges, make ``polarity=Timer.POSITIVE | Timer.NEGATIVE``.
+         - ``duty_cycle`` only applicable to ``PWM``. It's a percentage (0-100)
+
+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
+-------
+
+.. only:: port_wipy
+
+    .. method:: timerchannel.irq(\*, trigger, priority=1, handler=None)
+
+        The behavior of this callback is heaviliy dependent on the operating
+        mode of the timer channel:
+
+            - If mode is ``Timer.PERIODIC`` the callback is executed periodically
+              with the configured frequency or period.
+            - If mode is ``Timer.ONE_SHOT`` the callback is executed once when
+              the configured timer expires.
+            - If mode is ``Timer.PWM`` the callback is executed when reaching the duty
+              cycle value.
+
+        The accepted params are:
+
+            - ``priority`` level of the interrupt. Can take values in the range 1-7.
+              Higher values represent higher priorities.
+            - ``handler`` is an optional function to be called when the interrupt is triggered.
+
+        Returns a callback object.
+
+.. only:: port_wipy
+
+    .. method:: timerchannel.freq([value])
+    
+       Get or set the timer channel frequency (in Hz).
+
+    .. method:: timerchannel.period([value])
+
+       Get or set the timer channel period (in microseconds).
+       
+    .. method:: timerchannel.time([value])
+
+       Get or set the timer channel current **time** value (in microseconds).
+    
+    .. method:: timerchannel.event_count()
+
+       Get the number of edge events counted.
+
+    .. method:: timerchannel.event_time()
+
+       Get the time of ocurrance of the last event.
+
+    .. method:: timerchannel.duty_cycle([value])
+     
+       Get or set the duty cycle of the PWM signal (in the range of 0-100).

docs/library/machine.UART.rst

@@ -0,0 +1,170 @@
+.. _machine.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 machine import UART
+
+    uart = UART(1, 9600)                         # init with given baudrate
+    uart.init(9600, bits=8, parity=None, stop=1) # init with given parameters
+
+.. only:: port_machineoard
+
+    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.
+
+.. only:: port_wipy
+
+    Bits can be 5, 6, 7, 8.  Parity can be ``None``, ``UART.EVEN`` or ``UART.ODD``.  Stop can be 1 or 2.
+
+
+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
+
+.. only:: port_machineoard
+
+    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 MicroPython v1.3.4.
+    Earlier versions use ``uart.send`` and ``uart.recv``.
+
+.. only:: port_wipy
+
+    To check if there is anything to be read, use::
+
+        uart.any()               # returns the number of characters available for reading
+
+Constructors
+------------
+
+.. only:: port_wipy
+
+    .. class:: machine.UART(bus, ...)
+    
+       Construct a UART object on the given bus.  ``bus`` can be 0 or 1.
+       If the bus is not given, the default one will be selected (0) or the selection
+       will be made based on the given pins.
+
+Methods
+-------
+
+.. only:: port_wipy
+
+    .. method:: uart.init(baudrate=9600, bits=8, parity=None, stop=1, \*, pins=(TX, RX, RTS, CTS))
+    
+       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``, ``UART.EVEN`` or ``UART.ODD``.
+         - ``stop`` is the number of stop bits, 1 or 2.
+         - ``pins`` is a 4 or 2 item list indicating the TX, RX, RTS and CTS pins (in that order).
+           Any of the pins can be None if one wants the UART to operate with limited functionality.
+           If the RTS pin is given the the RX pin must be given as well. The same applies to CTS. 
+           When no pins are given, then the default set of TX and RX pins is taken, and hardware 
+           flow control will be disabled. If pins=None, no pin assignment will be made.
+
+.. method:: uart.deinit()
+
+   Turn off the UART bus.
+
+.. method:: uart.any()
+
+   Return the number of characters available for reading.
+
+.. method:: uart.read([nbytes])
+
+   Read characters.  If ``nbytes`` is specified then read at most that many bytes.
+
+   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.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.
+
+   Return value: number of bytes written.
+
+.. method:: uart.sendbreak()
+
+   Send a break condition on the bus.  This drives the bus low for a duration
+   of 13 bits.
+   Return value: ``None``.
+
+.. only:: port_wipy
+
+    .. method:: uart.irq(trigger, priority=1, handler=None, wake=machine.IDLE)
+
+       Create a callback to be triggered when data is received on the UART.
+
+           - ``trigger`` can only be ``UART.RX_ANY``
+           - ``priority`` level of the interrupt. Can take values in the range 1-7.
+             Higher values represent higher priorities.
+           - ``handler`` an optional function to be called when new characters arrive.
+           - ``wake`` can only be ``machine.IDLE``.
+
+       .. note::
+
+          The handler will be called whenever any of the following two conditions are met:
+
+              - 8 new characters have been received.
+              - At least 1 new character is waiting in the Rx buffer and the Rx line has been
+                silent for the duration of 1 complete frame.
+
+          This means that when the handler function is called there will be between 1 to 8 
+          characters waiting.
+
+       Returns a irq object.
+
+Constants
+---------
+
+.. data:: UART.EVEN
+.. data:: UART.ODD
+
+    parity types (anlong with ``None``)
+
+.. data:: UART.RX_ANY
+
+    IRQ trigger sources

docs/library/machine.WDT.rst

@@ -1,22 +1,22 @@
-.. _pyb.WDT:
+.. _machine.WDT:
 
 class WDT -- watchdog timer
 ===========================
 
 The WDT is used to restart the system when the application crashes and ends
 up into a non recoverable state. Once started it cannot be stopped or
-reconfigured in any way. After enabling, the application must "kick" the
+reconfigured in any way. After enabling, the application must "feed" the
 watchdog periodically to prevent it from expiring and resetting the system.
 
 Example usage::
 
-    wdt = pyb.WDT(timeout=2000) # enable with a timeout of 2s
+    wdt = machine.WDT(timeout=2000) # enable with a timeout of 2s
     wdt.feed()
 
 Constructors
 ------------
 
-.. class:: pyb.WDT(id=0, timeout=5000)
+.. class:: machine.WDT(id=0, timeout=5000)
 
    Create a WDT object and start it. The timeout must be given in seconds and
    the minimum value that is accepted is 1 second. Once it is running the timeout

docs/library/machine.rst

@@ -0,0 +1,132 @@
+:mod:`machine` --- functions related to the board
+=================================================
+
+.. module:: machine
+   :synopsis: functions related to the board
+
+The ``machine`` module contains specific functions related to the board.
+
+Reset related functions
+-----------------------
+
+.. function:: reset()
+
+   Resets the WiPy in a manner similar to pushing the external RESET
+   button.
+
+.. function:: reset_cause()
+
+   Get the reset cause. See :ref:`constants <machine_constants>` for the possible return values.
+
+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()
+
+   Returns a tuple of clock frequencies: ``(sysclk,)``
+   These correspond to:
+
+      - sysclk: frequency of the CPU
+
+.. function:: idle()
+
+   Gates the clock to the CPU, useful to reduce power consumption at any time during
+   short or long periods. Peripherals continue working and execution resumes as soon
+   as any interrupt is triggered (including the systick which has a period of 1ms).
+   Current consumption is reduced to ~12mA (in WLAN STA mode)
+
+.. function:: sleep()
+
+   Stops the CPU and disables all peripherals except for WLAN. Execution is resumed from
+   the point where the sleep was requested. Wake sources are ``Pin``, ``RTC`` and ``WLAN``.
+   Current consumption is reduced to 950uA (in WLAN STA mode).
+
+.. function:: deepsleep()
+
+   Stops the CPU and all peripherals including WLAN. Execution is resumed from main, just
+   as with a reset. The reset cause can be checked to know that we are coming from
+   from ``machine.DEEPSLEEP``. Wake sources are ``Pin`` and ``RTC``. Current consumption 
+   is reduced to ~5uA.
+
+.. function:: wake_reason()
+
+   Get the wake reason. See :ref:`constants <machine_constants>` for the possible return values.
+
+Miscellaneous functions
+-----------------------
+
+.. function:: main(filename)
+
+   Set the filename of the main script to run after boot.py is finished.  If
+   this function is not called then the default file main.py will be executed.
+
+   It only makes sense to call this function from within boot.py.
+
+.. function:: rng()
+
+   Return a 24-bit software generated random number.
+
+.. function:: unique_id()
+
+   Returns a string of 6 bytes (48 bits), which is the unique ID of the MCU.
+   This also corresponds to the ``MAC address`` of the WiPy.
+
+.. _machine_constants:
+
+Constants
+---------
+
+.. data:: machine.IDLE
+.. data:: machine.SLEEP
+.. data:: machine.DEEPSLEEP
+
+    irq wake values
+
+.. data:: machine.POWER_ON
+.. data:: machine.HARD_RESET
+.. data:: machine.WDT_RESET
+.. data:: machine.DEEPSLEEP_RESET
+.. data:: machine.SOFT_RESET
+
+    reset causes
+
+.. data:: machine.WLAN_WAKE
+.. data:: machine.PIN_WAKE
+.. data:: machine.RTC_WAKE
+
+    wake reasons
+
+Classes
+-------
+
+.. toctree::
+   :maxdepth: 1
+
+   machine.ADC.rst
+   machine.HeartBeat.rst
+   machine.I2C.rst
+   machine.Pin.rst
+   machine.RTC.rst
+   machine.SD.rst
+   machine.SPI.rst
+   machine.Timer.rst
+   machine.UART.rst
+   machine.WDT.rst

docs/library/network.rst

@@ -261,12 +261,13 @@ class WLAN
     This class provides a driver for WiFi network processor in the WiPy.  Example usage::
 
         import network
+        import time
         # setup as a station
-        nic = network.WLAN(mode=WLAN.STA)
+        wlan = network.WLAN(mode=WLAN.STA)
-        nic.connect('your-ssid', security=WLAN.WPA2, key='your-key')
+        wlan.connect('your-ssid', auth=(WLAN.WPA2, 'your-key'))
-        while not nic.isconnected():
+        while not wlan.isconnected():
-            pyb.delay(50)
+            time.sleep_ms(50)
-        print(nic.ifconfig())
+        print(wlan.ifconfig())
 
         # now use socket as usual
         ...
@@ -276,12 +277,12 @@ class WLAN
     
     .. class:: WLAN(..)
 
-       Create a WLAN object, and optionally configure it. See ``iwconfig`` for params of configuration.
+       Create a WLAN object, and optionally configure it. See ``init`` for params of configuration.
 
     Methods
     -------
 
-    .. method:: iwconfig(\*, mode, ssid, security, key, channel, antenna)
+    .. method:: init(mode, \*, ssid, security, key, channel, antenna)
     
        Set or get the WiFi network processor configuration.
     
@@ -289,14 +290,13 @@ class WLAN
     
          - ``mode`` can be either ``WLAN.STA`` or ``WLAN.AP``.
          - ``ssid`` is a string with the ssid name. Only needed when mode is ``WLAN.AP``.
-         - ``security`` can be ``WLAN.OPEN``, ``WLAN.WEP``, ``WLAN.WPA`` or ``WLAN.WPA2``. 
+         - ``auth`` is a tuple with (sec, key). Security can be ``None``, ``WLAN.WEP``,
-           Only needed when mode is ``WLAN.AP``.
+           ``WLAN.WPA`` or ``WLAN.WPA2``. The key is a string with the network password.
-         - ``key`` is a string with the network password. Not needed when mode is ``WLAN.STA``
+           If ``security`` is ``WLAN.WEP`` the key must be a string representing hexadecimal
-           or security is ``WLAN.OPEN``. If ``security`` is ``WLAN.WEP`` the key must be a
+           values (e.g. 'ABC1DE45BF'). Only needed when mode is ``WLAN.AP``.
-           string representing hexadecimal values (e.g. 'ABC1DE45BF').
          - ``channel`` a number in the range 1-11. Only needed when mode is ``WLAN.AP``.
          - ``antenna`` selects between the internal and the external antenna. Can be either
-           ``WLAN.INTERNAL`` or ``WLAN.EXTERNAL``.
+           ``WLAN.INT_ANT`` or ``WLAN.EXTERNAL``.
     
        For example, you can do::
 
@@ -311,7 +311,7 @@ class WLAN
        With no arguments given, the current configuration is returned as a namedtuple that looks like this:
        ``(mode=2, ssid='wipy-wlan', security=2, key='www.wipy.io', channel=5, antenna=0)``
 
-    .. method:: wlan.connect(ssid, \*, security=WLAN.OPEN, key=None, bssid=None, timeout=5000)
+    .. method:: wlan.connect(ssid, \*, auth=None, key=None, bssid=None, timeout=5000)
 
        Connect to a wifi access point using the given SSID, and other security
        parameters.
@@ -324,7 +324,7 @@ class WLAN
 
     .. method:: wlan.scan()
 
-       Performs a network scan and returns a list of named tuples with (ssid, bssid, security, channel, rssi).
+       Performs a network scan and returns a list of named tuples with (ssid, bssid, sec, channel, rssi).
        Note that channel is always ``None`` since this info is not provided by the WiPy.
 
     .. method:: wlan.disconnect()
@@ -336,7 +336,7 @@ class WLAN
        In case of STA mode, returns ``True`` if connected to a wifi access point and has a valid IP address.
        In AP mode returns ``True`` when a station is connected. Returns ``False`` otherwise.
 
-    .. method:: wlan.ifconfig(['dhcp' or configtuple])
+    .. method:: wlan.ifconfig(if_id, config=['dhcp' or configtuple])
 
        With no parameters given eturns a 4-tuple of ``(ip, subnet mask, gateway, DNS server)``.
        
@@ -345,23 +345,19 @@ class WLAN
        
        if the 4-tuple config is given then a static IP is configured. For example::
 
-          nic.ifconfig(('192.168.0.4', '255.255.255.0', '192.168.0.1', '8.8.8.8'))
+          nic.ifconfig(config=('192.168.0.4', '255.255.255.0', '192.168.0.1', '8.8.8.8'))
 
-    .. method:: wlan.mac()
+    .. method:: wlan.mac([mac_addr])
 
-       Returns a 6-byte long bytes object with the MAC address.
+       Get or set a 6-byte long bytes object with the MAC address.
 
-    .. method:: wlan.connections()
+    .. method:: wlan.irq(\*, handler, wake)
 
-       Returns a list of the devices currently connected. Each item in the list is a
+        Create a callback to be triggered when a WLAN event occurs during ``machine.SLEEP``
-       tuple of ``(ssid, mac)``.
-
-    .. method:: wlan.callback(wake_from)
-
-        Create a callback to be triggered when a WLAN event occurs during ``pyb.Sleep.SUSPENDED``
         mode. Events are triggered by socket activity or by WLAN connection/disconnection.
 
-            - ``wake_from`` must be ``pyb.Sleep.SUSPENDED``.
+            - ``handler`` is the function that gets called when the irq is triggered.
+            - ``wake`` must be ``machine.SLEEP``.
 
         Returns a callback object.
 
@@ -376,14 +372,13 @@ class WLAN
 
        WiFi access point mode
 
-    .. data:: WLAN.OPEN
     .. data:: WLAN.WEP
     .. data:: WLAN.WPA
     .. data:: WLAN.WPA2
 
        selects the network security
 
-    .. data:: WLAN.INTERNAL
+    .. data:: WLAN.INT_ANT
-    .. data:: WLAN.EXTERNAL
+    .. data:: WLAN.EXT_ANT
 
        selects the antenna type

docs/library/os.rst

@@ -71,9 +71,27 @@ Functions
 
 .. only:: port_wipy
 
-    .. function:: mkfs(drive)
+    .. function:: mount(block_device, mount_point, \*, readonly=False)
 
-       Formats the specified drive, must be either ``/flash`` or ``/sd``.
+       Mounts a block device (like an ``SD`` object) in the specified mount
+       point. Example::
+
+          os.mount(sd, '/sd')
+
+    .. function:: unmount(path)
+
+       Unmounts a prevoulsy mounted block device from the given path.
+
+    .. function:: mkfs(block_device or path)
+
+       Formats the specified path, must be either ``/flash`` or ``/sd``.
+       A block device can also be passed like an ``SD`` object before
+       being mounted.
+
+    .. function:: dupterm(stream_object)
+
+       Duplicate the terminal (the REPL) on the passed stream-like object.
+       The given object must at least implement the ``.read()`` and ``.write()`` methods.
 
 Constants
 ---------

docs/library/pyb.ADC.rst

@@ -18,16 +18,6 @@ class ADC -- analog to digital conversion
         val = adc.read_core_vbat()      # read MCU VBAT
         val = adc.read_core_vref()      # read MCU VREF
 
-.. only:: port_wipy
-
-    Usage::
-    
-       import pyb
-
-       adc = pyb.ADC()                 # create an ADC object
-       apin = adc.channel(pin='GP3')   # create an analog pin on GP3
-       val = apin()                    # read an analog value
-
 Constructors
 ------------
 
@@ -39,22 +29,6 @@ Constructors
        Create an ADC object associated with the given pin.
        This allows you to then read analog values on that pin.
 
-.. only:: port_wipy
-
-    .. class:: pyb.ADC(id=0, \*, bits=12)
-
-       Create an ADC object associated with the given pin.
-       This allows you to then read analog values on that pin.
-       For more info check the `pinout and alternate functions
-       table. <https://raw.githubusercontent.com/wipy/wipy/master/docs/PinOUT.png>`_ 
-
-       .. warning:: 
-
-          ADC pin input range is 0-1.4V (being 1.8V the absolute maximum that it 
-          can withstand). When GP2, GP3, GP4 or GP5 are remapped to the 
-          ADC block, 1.8 V is the maximum. If these pins are used in digital mode, 
-          then the maximum allowed input is 3.6V.
-
 Methods
 -------
 
@@ -100,48 +74,3 @@ Methods
 
        This function does not allocate any memory.
 
-.. only:: port_wipy
-
-   .. method:: adc.channel(id, *, pin)
-
-      Create an analog pin. If only channel ID is given, the correct pin will be selected. Alternatively,
-      only the pin can be passed and the correct channel will be selected. Examples::
-
-        # all of these are equivalent and enable ADC channel 1 on GP3
-        apin = adc.channel(1)
-        apin = adc.channel(pin='GP3')
-        apin = adc.channel(id=1, pin='GP3')
-
-   .. method:: adc.init()
-
-      Enable the ADC block.
-
-   .. method:: adc.deinit()
-
-      Disable the ADC block.
-
-.. only:: port_wipy
-
-    class ADCChannel --- read analog values from internal or external sources
-    =========================================================================
-
-    .. only:: port_wipy
-
-        ADC channels can be connected to internal points of the MCU or to GPIO pins.
-        ADC channels are created using the ADC.channel method.
-
-       .. method:: adcchannel()
-
-          Fast method to read the channel value.
-
-       .. method:: adcchannel.value()
-
-          Read the channel value.
-
-       .. method:: adcchannel.init()
-
-          Re-init (and effectively enable) the ADC channel.
-
-       .. method:: adcchannel.deinit()
-
-          Disable the ADC channel.

docs/library/pyb.I2C.rst

@@ -21,17 +21,6 @@ when created, or initialised later on.
         i2c.init(I2C.SLAVE, addr=0x42)       # init as a slave with given address
         i2c.deinit()                         # turn off the peripheral
 
-.. only:: port_wipy
-
-    Example::
-
-        from pyb import I2C
-
-        i2c = I2C(0)                         # create on bus 0
-        i2c = I2C(0, I2C.MASTER)             # create and init as a master
-        i2c.init(I2C.MASTER, baudrate=20000) # init as a master
-        i2c.deinit()                         # turn off the peripheral
-
 Printing the i2c object gives you information about its configuration.
 
 .. only:: port_pyboard
@@ -67,23 +56,6 @@ Printing the i2c object gives you information about its configuration.
         i2c.mem_write('abc', 0x42, 2, timeout=1000) # write 'abc' (3 bytes) to memory of slave 0x42
                                                     # starting at address 2 in the slave, timeout after 1 second
 
-.. only:: port_wipy
-
-    A master must specify the recipient's address::
-
-        i2c.init(I2C.MASTER)
-        i2c.writeto(0x42, '123')        # send 3 bytes to slave with address 0x42
-        i2c.writeto(addr=0x42, b'456')  # keyword for address
-
-    Master also has other methods::
-
-        i2c.scan()                          # scan for slaves on the bus, returning
-                                            #   a list of valid addresses
-        i2c.readfrom_mem(0x42, 2, 3)        # read 3 bytes from memory of slave 0x42,
-                                            #   starting at address 2 in the slave
-        i2c.writeto_mem(0x42, 2, 'abc')     # write 'abc' (3 bytes) to memory of slave 0x42
-                                            # starting at address 2 in the slave, timeout after 1 second
-
 Constructors
 ------------
 
@@ -102,13 +74,6 @@ Constructors
          - ``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)``
 
-.. only:: port_wipy
-
-    .. class:: pyb.I2C(bus, ...)
-
-       Construct an I2C object on the given bus.  `bus` can only be 0.
-       If the bus is not given, the default one will be selected (0).
-
 Methods
 -------
 
@@ -179,54 +144,6 @@ Methods
 
        Return value: ``None``.
 
-.. only:: port_wipy
-
-    .. method:: i2c.init(mode, \*, baudrate=100000, pins=(SDA, SCL))
-
-      Initialise the I2C bus with the given parameters:
-
-         - ``mode`` must be ``I2C.MASTER``
-         - ``baudrate`` is the SCL clock rate
-         - ``pins`` is an optional tuple with the pins to assign to the I2C bus.
-
-    .. method:: i2c.readfrom(addr, nbytes)
-
-        Read ``nbytes`` from the slave specified by ``addr``.
-        Returns a ``bytes`` object with the data read.
-
-    .. method:: i2c.readfrom_into(addr, buf)
-
-        Read into ``buf`` from the slave specified by ``addr``.
-        Returns the number of bytes read.
-
-    .. method:: i2c.writeto(addr, buf, \*, stop=True)
-
-        Write ``buf`` to the slave specified by ``addr``. Set ``stop`` to ``False``
-        if the transfer should be continued.
-        Returns the number of bytes written.
-
-    .. method:: i2c.readfrom_mem(addr, memaddr, nbytes, \*, addrsize=8)
-
-        Read ``nbytes`` from the slave specified by ``addr`` starting from the memory
-        address specified by ``memaddr``.
-        Param ``addrsize`` specifies the address size in bits.
-        Returns a ``bytes`` object with the data read.
-
-    .. method:: i2c.readfrom_mem_into(addr, memaddr, buf, \*, addrsize=8)
-
-        Read into ``buf`` from the slave specified by ``addr`` starting from the memory
-        address specified by ``memaddr``.
-        Param ``addrsize`` specifies the address size in bits.
-        Returns the number of bytes read.
-
-    .. method:: i2c.writeto_mem(addr, memaddr, buf, \*, addrsize=8)
-
-        Write ``buf`` to the slave specified by ``addr`` starting from the
-        memory address specified by ``memaddr``. Param ``addrsize`` specifies the 
-        address size in bits.
-        Set ``stop`` to ``False`` if the transfer should be continued.
-        Returns the number of bytes written.
-
 .. method:: i2c.scan()
 
    Scan all I2C addresses from 0x01 to 0x7f and return a list of those that respond.

docs/library/pyb.Pin.rst

@@ -63,24 +63,6 @@ Usage Model:
     that pin has an effective 40k Ohm resistor pulling it to 3V3 or GND
     respectively (except pin Y5 which has 11k Ohm resistors).
 
-.. only:: port_wipy
-
-    Board pins are identified by their string id::
-
-        g = pyb.Pin('GP9', mode=pyb.Pin.OUT, pull=None, drive=pyb.Pin.MED_POWER, alt=-1)
-
-    You can also configure the Pin to generate interrupts. For instance::
-
-        def pincb(pin):
-            print(pin.id())
-
-        pin_int = pyb.Pin('GP10', mode=Pin.IN, pull=pyb.Pin.PULL_DOWN)
-        pin_int.irq(mode=pyb.Pin.IRQ_RISING, handler=pincb)
-        # the callback can be triggered manually
-        pin_int.irq()()
-        # to disable the callback
-        pin_int.irq().disable()
-
     Now every time a falling edge is seen on the gpio pin, the callback will be
     executed. Caution: mechanical push buttons have "bounce" and pushing or
     releasing a switch will often generate multiple edges.
@@ -149,42 +131,6 @@ Methods
        
        Returns: ``None``.
 
-.. only:: port_wipy
-
-    .. method:: pin.init(mode, pull, \*, drive, alt)
-    
-       Initialise the pin:
-
-         - ``mode`` can be one of:
-
-            - ``Pin.IN``  - input pin.
-            - ``Pin.OUT`` - output pin in push-pull mode.
-            - ``Pin.OPEN_DRAIN`` - output pin in open-drain mode.
-            - ``Pin.ALT`` - pin mapped to an alternate function.
-            - ``Pin.ALT_OPEN_DRAIN`` - pin mapped to an alternate function in open-drain mode.
-
-         - ``pull`` can be one of:
-
-            - ``None`` - no pull up or down resistor.
-            - ``Pin.PULL_UP`` - pull up resistor enabled.
-            - ``Pin.PULL_DOWN`` - pull down resitor enabled.
-
-         - ``drive`` can be one of:
-
-            - ``Pin.LOW_POWER`` - 2mA drive capability.
-            - ``Pin.MED_POWER`` - 4mA drive capability.
-            - ``Pin.HIGH_POWER`` - 6mA drive capability.
-
-         - ``alt`` is the number of the alternate function. Please refer to the
-           `pinout and alternate functions table. <https://raw.githubusercontent.com/wipy/wipy/master/docs/PinOUT.png>`_
-           for the specific alternate functions that each pin supports.
-
-       Returns: ``None``.
-
-    .. method:: pin.id()
-
-       Get the pin id.
-
 .. method:: pin.value([value])
 
    Get or set the digital logic level of the pin:
@@ -238,62 +184,6 @@ Methods
     will match one of the allowed constants for the pull argument to the init
     function.
 
-.. only:: port_wipy
-
-    .. method:: pin([value])
-
-       Pin objects are callable. The call method provides a (fast) shortcut to set and get the value of the pin.
-       See **pin.value** for more details.
-
-    .. method:: pin.toggle()
-
-        Toggle the value of the pin.
-
-    .. method:: pin.mode([mode])
-
-        Get or set the pin mode.
-
-    .. method:: pin.pull([pull])
-
-        Get or set the pin pull.
-
-    .. method:: pin.drive([drive])
-
-        Get or set the pin drive strength.
-
-    .. method:: pin.irq(\*, trigger, priority=1, handler=None, wake=None)
-
-        Create a callback to be triggered when the input level at the pin changes.
-
-            - ``trigger`` configures the pin level which can generate an interrupt. Possible values are:
-
-                - ``Pin.IRQ_FALLING`` interrupt on falling edge.
-                - ``Pin.IRQ_RISING`` interrupt on rising edge.
-                - ``Pin.IRQ_LOW_LEVEL`` interrupt on low level.
-                - ``Pin.IRQ_HIGH_LEVEL`` interrupt on high level.
-              
-              The values can be *ORed* together, for instance mode=Pin.IRQ_FALLING | Pin.IRQ_RISING
-
-            - ``priority`` level of the interrupt. Can take values in the range 1-7.
-              Higher values represent higher priorities.
-            - ``handler`` is an optional function to be called when new characters arrive.
-            - ``wakes`` selects the power mode in which this interrupt can wake up the
-              board. Please note:
-
-              - If ``wake_from=pyb.Sleep.ACTIVE`` any pin can wake the board.
-              - If ``wake_from=pyb.Sleep.SUSPENDED`` pins ``GP2``, ``GP4``, ``GP10``,
-                ``GP11``, GP17`` or ``GP24`` can wake the board. Note that only 1
-                of this pins can be enabled as a wake source at the same time, so, only
-                the last enabled pin as a ``pyb.Sleep.SUSPENDED`` wake source will have effect.
-              - If ``wake_from=pyb.Sleep.SUSPENDED`` pins ``GP2``, ``GP4``, ``GP10``,
-                ``GP11``, ``GP17`` and ``GP24`` can wake the board. In this case all of the
-                6 pins can be enabled as a ``pyb.Sleep.HIBERNATE`` wake source at the same time.
-              - Values can be ORed to make a pin generate interrupts in more than one power
-                mode.
-
-            Returns a callback object.
-
-
 Constants
 ---------
 
@@ -335,44 +225,6 @@ Constants
     
        enable the pull-up resistor on the pin
 
-.. only:: port_wipy
-
-    .. data:: Pin.IN
-
-    .. data:: Pin.OUT
-    
-    .. data:: Pin.OPEN_DRAIN
-
-    .. data:: Pin.ALT
-
-    .. data:: Pin.ALT_OPEN_DRAIN
-
-       Selects the pin mode.
-
-    .. data:: Pin.PULL_UP
-
-    .. data:: Pin.PULL_DOWN
-    
-       Selectes the wether there's pull up/down resistor.
-
-    .. data:: Pin.LOW_POWER
-
-    .. data:: Pin.MED_POWER
-
-    .. data:: Pin.HIGH_POWER
-
-        Selects the drive strength.
-
-    .. data:: Pin.IRQ_FALLING
-
-    .. data:: Pin.IRQ_RISING
-
-    .. data:: Pin.IRQ_LOW_LEVEL
-
-    .. data:: Pin.IRQ_HIGH_LEVEL
-
-        Selects the IRQ trigger type.
-
 .. only:: port_pyboard
 
     class PinAF -- Pin Alternate Functions

docs/library/pyb.RTC.rst

@@ -42,14 +42,6 @@ Methods
        
        ``subseconds`` counts down from 255 to 0
 
-   .. only:: port_wipy
-   
-       The 8-tuple has the following format:
-       
-           ``(year, month, day, weekday, hours, minutes, seconds, milliseconds)``
-       
-       ``weekday`` is 0-6 for Monday through Sunday.
-
 .. only:: port_pyboard
 
     .. method:: rtc.wakeup(timeout, callback=None)
@@ -88,14 +80,3 @@ Methods
        usable calibration range is:
        (-511 * 0.954) ~= -487.5 ppm up to (512 * 0.954) ~= 488.5 ppm
 
-.. only:: port_wipy
-
-    .. method:: rtc.callback(\*, value, handler=None, wake_from=pyb.Sleep.ACTIVE)
-    
-       Create a callback object triggered by a real time clock alarm.
-    
-          - ``value`` is the alarm timeout in milliseconds. This parameter is required.
-          - ``handler`` is the function to be called when the callback is triggered.
-          - ``wake_from`` specifies the power mode from where this interrupt can wake
-            up the system.
-

docs/library/pyb.SPI.rst

@@ -26,18 +26,6 @@ there are 3 lines: SCK, MOSI, MISO.
         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
 
-.. only:: port_wipy
-
-    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=1000000, polarity=0, phase=0, firstbit=SPI.MSB)
-
-    Only required parameter is mode, must be SPI.MASTER.  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.
-
 Constructors
 ------------
 
@@ -59,16 +47,6 @@ Constructors
        At the moment, the NSS pin is not used by the SPI driver and is free
        for other use.
 
-.. only:: port_wipy
-
-    .. class:: pyb.SPI(bus, ...)
-
-       Construct an SPI object on the given bus.  ``bus`` can be only 1.
-       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.
-
 Methods
 -------
 
@@ -102,43 +80,6 @@ Methods
        Printing the SPI object will show you the computed baudrate and the chosen
        prescaler.
 
-.. only:: port_wipy
-
-    .. method:: spi.init(mode, baudrate=1000000, \*, polarity=0, phase=0, bits=8, firstbit=SPI.MSB, pins=(CLK, MOSI, MISO))
-
-       Initialise the SPI bus with the given parameters:
-
-         - ``mode`` must be ``SPI.MASTER``.
-         - ``baudrate`` is the SCK clock rate.
-         - ``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.
-         - ``bits`` is the width of each transfer, accepted values are 8, 16 and 32.
-         - ``firstbit`` can be ``SPI.MSB`` only.
-         - ``pins`` is an optional tupple with the pins to assign to the SPI bus.
-
-    .. method:: spi.write(buf)
-
-        Write the data contained in ``buf``. 
-        Returns the number of bytes written.
-
-    .. method:: spi.read(nbytes, *, write=0x00)
-
-        Read the ``nbytes`` while writing the data specified by ``write``.
-        Return the number of bytes read.
-
-    .. method:: spi.readinto(buf, *, write=0x00)
-
-        Read into the buffer specified by ``buf`` while writing the data specified by
-        ``write``.
-        Return the number of bytes read.
-
-    .. method:: spi.write_readinto(write_buf, read_buf)
-
-        Write from ``write_buf`` and read into ``read_buf``. Both buffers must have the
-        same length.
-        Returns the number of bytes written
-
 .. only:: port_pyboard
 
     .. method:: spi.recv(recv, \*, timeout=5000)
@@ -187,13 +128,3 @@ Constants
     .. data:: SPI.MSB
     
        set the first bit to be the least or most significant bit
-
-.. only:: port_wipy
-
-    .. data:: SPI.MASTER
-
-       for initialising the SPI bus to master
-    
-    .. data:: SPI.MSB
-
-    set the first bit to be the most significant bit

docs/library/pyb.Timer.rst

@@ -41,50 +41,6 @@ class Timer -- control internal timers
     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.
 
-.. only:: port_wipy
-
-    Timers can be used for a great variety of tasks, calling a function periodically,
-    counting events, and generating a PWM signal are among the most common use cases.
-    Each timer consists of 2 16-bit channels and this channels can be tied together to
-    form 1 32-bit timer. The operating mode needs to be configured per timer, but then
-    the period (or the frequency) can be independently configured on each channel. 
-    By using the callback method, the timer event can call a Python function.
-
-    Example usage to toggle an LED at a fixed frequency::
-
-        tim = pyb.Timer(4)                                              # create a timer object using timer 4
-        tim.init(mode=Timer.PERIODIC)                                   # initialize it in periodic mode
-        tim_ch = tim.channel(Timer.A, freq=2)                           # configure channel A at a frequency of 2Hz
-        tim_ch.callback(handler=lambda t:led.toggle())                  # toggle a LED on every cycle of the timer
-
-    Example using named function for the callback::
-
-        tim = Timer(1, mode=Timer.PERIODIC)
-        tim_a = tim.channel(Timer.A, freq=1000)
-
-        led = Pin('GPIO2', af=0, mode=Pin.OUT)
-
-        def tick(timer):                # we will receive the timer object when being called
-            print(timer.time())         # show current timer's time value (is microseconds)
-            led.toggle()                # toggle the LED
-
-        tim_a.callback(handler=tick)
-
-    Further examples::
-
-        tim1 = pyb.Timer(2, mode=Timer.EVENT_COUNT)                     # initialize it capture mode
-        tim2 = pyb.Timer(1, mode=Timer.PWM)                             # initialize it in PWM mode
-        tim_ch = tim1.channel(Timer.A, freq=1, polarity=Timer.POSITIVE) # start the event counter with a frequency of 1Hz and triggered by positive edges
-        tim_ch = tim2.channel(Timer.B, freq=10000, duty_cycle=50)       # start the PWM on channel B with a 50% duty cycle
-        tim_ch.time()                                                   # get the current time in usec (can also be set)
-        tim_ch.freq(20)                                                 # set the frequency (can also get)
-        tim_ch.duty_cycle(30)                                           # set the duty cycle to 30% (can also get)
-        tim_ch.duty_cycle(30, Timer.NEGATIVE)                           # set the duty cycle to 30% and change the polarity to negative
-        tim_ch.event_count()                                            # get the number of captured events
-        tim_ch.event_time()                                             # get the the time of the last captured event
-        tim_ch.period(2000000)                                          # change the period to 2 seconds
-
-
 *Note:* Memory can't be allocated during a callback (an interrupt) and so
 exceptions raised within a callback don't give much information.  See
 :func:`micropython.alloc_emergency_exception_buf` for how to get around this
@@ -102,13 +58,6 @@ Constructors
        arguments are given, then the timer is initialised by ``init(...)``.
        ``id`` can be 1 to 14, excluding 3.
 
-    .. only:: port_wipy
-    
-       Construct a new timer object of the given id.  If additional
-       arguments are given, then the timer is initialised by ``init(...)``.
-       ``id`` can be 1 to 4.
-
-
 Methods
 -------
 
@@ -161,30 +110,6 @@ Methods
        
         You must either specify freq or both of period and prescaler.
 
-.. only:: port_wipy
-
-    .. method:: timer.init(mode, \*, width=16)
-    
-       Initialise the timer. Example::
-       
-           tim.init(Timer.PERIODIC)             # periodic 16-bit timer
-           tim.init(Timer.ONE_SHOT, width=32)   # one shot 32-bit timer
-
-       Keyword arguments:
-       
-         - ``mode`` can be one of:
-         
-           - ``Timer.ONE_SHOT`` - The timer runs once until the configured 
-             period of the channel expires.
-           - ``Timer.PERIODIC`` - The timer runs periodically at the configured 
-             frequency of the channel.
-           - ``Timer.EDGE_TIME`` - Meaure the time pin level changes.
-           - ``Timer.EDGE_COUNT`` - Count the number of pin level changes.
-
-         - ``width`` must be either 16 or 32 (bits). For really low frequencies <= ~1Hz
-           (or large periods), 32-bit timers should be used. 32-bit mode is only available
-           for ``ONE_SHOT`` AND ``PERIODIC`` modes.
-
 .. method:: timer.deinit()
 
    Deinitialises the timer.
@@ -280,37 +205,6 @@ Methods
            ch2 = timer.channel(2, pyb.Timer.PWM, pin=pyb.Pin.board.X2, pulse_width=8000)
            ch3 = timer.channel(3, pyb.Timer.PWM, pin=pyb.Pin.board.X3, pulse_width=16000)
 
-.. only:: port_wipy
-
-    .. method:: timer.channel(channel, \**, freq, period, polarity=Timer.POSITIVE, duty_cycle=0)
-    
-       If only a channel identifier passed, then a previously initialized channel
-       object is returned (or ``None`` if there is no previous channel).
-       
-       Othwerwise, a TimerChannel object is initialized and returned.
-       
-       The operating mode is is the one configured to the Timer object that was used to
-       create the channel.
-
-       - ``channel`` if the width of the timer is 16-bit, then must be either ``TIMER.A``, ``TIMER.B``. 
-         If the width is 32-bit then it **must be** ``TIMER.A | TIMER.B``.
-
-       Keyword only arguments:
-
-         - ``freq`` sets the frequency in Hz.
-         - ``period`` sets the period in microseconds.
-
-         .. note::
-
-            Either ``freq`` or ``period`` must be given, never both.
-
-         - ``polarity`` this is applicable for:
-           
-           - ``PWM``, defines the polarity of the duty cycle
-           - ``EDGE_TIME`` and ``EDGE_COUNT``, defines the polarity of the pin level change to detect.
-             To detect both rising and falling edges, make ``polarity=Timer.POSITIVE | Timer.NEGATIVE``.
-         - ``duty_cycle`` only applicable to ``PWM``. It's a percentage (0-100)
-
 .. only:: port_pyboard
 
     .. method:: timer.counter([value])
@@ -355,32 +249,6 @@ Methods
        ``fun`` is passed 1 argument, the timer object.
        If ``fun`` is ``None`` then the callback will be disabled.
 
-.. only:: port_wipy
-
-    .. method:: timerchannel.callback(\**, value, priority=1, handler=None)
-
-        The behavior of this callback is heaviliy dependent on the operating
-        mode of the timer channel:
-
-            - If mode is ``Timer.PERIODIC`` the callback is executed periodically
-              with the configured frequency or period.
-            - If mode is ``Timer.ONE_SHOT`` the callback is executed once when
-              the configured timer expires.
-            - If mode is ``Timer.EDGE_COUNT`` the callback is executed when reaching
-              the configured number of events (see ``value`` param below).
-            - If mode is ``Timer.PWM`` the callback is executed when reaching the duty
-              cycle value.
-
-        The accepted params are:
-
-            - ``priority`` level of the interrupt. Can take values in the range 1-7.
-              Higher values represent higher priorities.
-            - ``handler`` is an optional function to be called when the interrupt is triggered.
-            - ``value`` is **only valid** when in ``Timer.EDGE_COUNT`` mode and is used to set
-              the number of edge events that will trigger the interrupt.
-
-        Returns a callback object.
-
 .. only:: port_pyboard
 
     .. method:: timerchannel.capture([value])
@@ -411,29 +279,3 @@ Methods
        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%.
-
-.. only:: port_wipy
-
-    .. method:: timerchannel.freq([value])
-    
-       Get or set the timer channel frequency (in Hz).
-
-    .. method:: timerchannel.period([value])
-
-       Get or set the timer channel period (in microseconds).
-       
-    .. method:: timerchannel.time([value])
-
-       Get or set the timer channel current **time** value (in microseconds).
-    
-    .. method:: timerchannel.event_count()
-
-       Get the number of edge events counted.
-
-    .. method:: timerchannel.event_time()
-
-       Get the time of ocurrance of the last event.
-
-    .. method:: timerchannel.duty_cycle([value])
-     
-       Get or set the duty cycle of the PWM signal (in the range of 0-100).

docs/library/pyb.UART.rst

@@ -22,11 +22,6 @@ UART objects can be created and initialised using::
     *Note:* with parity=None, only 8 and 9 bits are supported.  With parity enabled,
     only 7 and 8 bits are supported.
 
-.. only:: port_wipy
-
-    Bits can be 5, 6, 7, 8.  Parity can be ``None``, ``UART.EVEN`` or ``UART.ODD``.  Stop can be 1 or 2.
-
-
 A UART object acts like a stream object and reading and writing is done
 using the standard stream methods::
 
@@ -50,12 +45,6 @@ using the standard stream methods::
     *Note:* The stream functions ``read``, ``write``, etc. are new in MicroPython v1.3.4.
     Earlier versions use ``uart.send`` and ``uart.recv``.
 
-.. only:: port_wipy
-
-    To check if there is anything to be read, use::
-
-        uart.any()               # returns the number of characters available for reading
-
 Constructors
 ------------
 
@@ -77,14 +66,6 @@ Constructors
          - ``UART(3)`` is on ``YB``: ``(TX, RX) = (Y9, Y10) = (PB10, PB11)``
          - ``UART(2)`` is on: ``(TX, RX) = (X3, X4) = (PA2, PA3)``
 
-.. only:: port_wipy
-
-    .. class:: pyb.UART(bus, ...)
-    
-       Construct a UART object on the given bus.  ``bus`` can be 0 or 1.
-       If the bus is not given, the default one will be selected (0) or the selection
-       will be made based on the given pins.
-
 Methods
 -------
 
@@ -114,22 +95,6 @@ Methods
        *Note:* with parity=None, only 8 and 9 bits are supported.  With parity enabled,
        only 7 and 8 bits are supported.
 
-.. only:: port_wipy
-
-    .. method:: uart.init(baudrate=9600, bits=8, parity=None, stop=1, \*, pins=(TX, RX, RTS, CTS))
-    
-       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``, ``UART.EVEN`` or ``UART.ODD``.
-         - ``stop`` is the number of stop bits, 1 or 2.
-         - ``pins`` is a 4 or 2 item list indicating the TX, RX, RTS and CTS pins (in that order).
-           Any of the pins can be None if one wants the UART to operate with limited functionality.
-           If the RTS pin is given the the RX pin must be given as well. The same applies to CTS. 
-           When no pins are given, then the default set of TX and RX pins is taken, and hardware 
-           flow control will be disabled. If pins=None, no pin assignment will be made.
-
 .. method:: uart.deinit()
 
    Turn off the UART bus.
@@ -145,12 +110,6 @@ Methods
       Write a single character on the bus.  ``char`` is an integer to write.
       Return value: ``None``.
 
-.. only:: port_wipy
-
-    .. method:: uart.any()
-
-       Return the number of characters available for reading.
-
 .. method:: uart.read([nbytes])
 
    Read characters.  If ``nbytes`` is specified then read at most that many bytes.
@@ -163,11 +122,6 @@ Methods
       Return value: a bytes object containing the bytes read in.  Returns ``b''``
       on timeout.
 
-   .. only:: port_wipy
-
-      Return value: a bytes object containing the bytes read in.  Returns ``b''``
-      on timeout.
-
 .. method:: uart.readall()
 
    Read as much data as possible.
@@ -204,43 +158,12 @@ Methods
 
       Return value: number of bytes written.
 
-   .. only:: port_wipy
-
-      Write the buffer of bytes to the bus.
-
-      Return value: number of bytes written.
-
 .. method:: uart.sendbreak()
 
    Send a break condition on the bus.  This drives the bus low for a duration
    of 13 bits.
    Return value: ``None``.
 
-.. only:: port_wipy
-
-    .. method:: uart.callback(value, priority=1, handler=None)
-
-       Create a callback to be triggered when data is received on the UART.
-
-           - ``value`` sets the size in bytes of the Rx buffer. Every character
-             received is put into this buffer as long as there's space free.
-           - ``priority`` level of the interrupt. Can take values in the range 1-7.
-             Higher values represent higher priorities.
-           - ``handler`` an optional function to be called when new characters arrive.
-
-       .. note::
-
-          The handler will be called whenever any of the following two conditions are met:
-          
-              - 4 new characters have been received.
-              - At least 1 new character is waiting in the Rx buffer and the Rx line has been
-                silent for the duration of 1 complete frame.
-
-          This means that when the handler function is called there might be 1, 2, 3 or 4
-          characters waiting.
-
-       Return a callback object.
-
 Constants
 ---------
 
@@ -250,9 +173,3 @@ Constants
     .. data:: UART.CTS
 
        to select the flow control type
-
-.. only:: port_wipy
-
-   .. data:: UART.RX_ANY
-
-       IRQ trigger sources

docs/library/pyb.rst

@@ -63,22 +63,11 @@ Time related functions
 Reset related functions
 -----------------------
 
-.. only:: port_pyboard
-
 .. function:: hard_reset()
 
    Resets the pyboard in a manner similar to pushing the external RESET
    button.
 
-.. only:: port_wipy
-
-    .. function:: reset()
-    
-       Resets the WiPy in a manner similar to pushing the external RESET
-       button.
-
-.. only:: port_pyboard
-
 .. function:: bootloader()
 
    Activate the bootloader without BOOT\* pins.
@@ -175,15 +164,6 @@ Power related functions
     
        See :meth:`rtc.wakeup` to configure a real-time-clock wakeup event.
 
-.. only:: port_wipy
-
-    .. function:: freq([sysclk])
-
-       Returns a tuple of clock frequencies: ``(sysclk)``
-       These correspond to:
-
-          - sysclk: frequency of the CPU
-
 Miscellaneous functions
 -----------------------
 
@@ -256,12 +236,6 @@ Miscellaneous functions
     
        Return a 30-bit hardware generated random number.
 
-.. only:: port_wipy
-
-    .. function:: rng()
-    
-       Return a 24-bit software generated random number.
-
 .. function:: sync()
 
    Sync all file systems.
@@ -272,13 +246,6 @@ Miscellaneous functions
     
        Returns a string of 12 bytes (96 bits), which is the unique ID of the MCU.
 
-.. only:: port_wipy
-
-    .. function:: unique_id()
-    
-       Returns a string of 6 bytes (48 bits), which is the unique ID of the MCU.
-       This also corresponds to the ``MAC address`` of the WiPy.
-
 Classes
 -------
 
@@ -303,19 +270,3 @@ Classes
        pyb.Timer.rst
        pyb.UART.rst
        pyb.USB_VCP.rst
-
-.. only:: port_wipy
-
-    .. toctree::
-       :maxdepth: 1
-    
-       pyb.ADC.rst
-       pyb.HeartBeat.rst
-       pyb.I2C.rst
-       pyb.Pin.rst
-       pyb.RTC.rst
-       pyb.SD.rst
-       pyb.SPI.rst
-       pyb.Timer.rst
-       pyb.UART.rst
-       pyb.WDT.rst

docs/library/time.rst

@@ -44,6 +44,46 @@ Functions
     
        Sleep for the given number of seconds.
 
+.. only:: port_wipy
+
+    .. function::  sleep_ms(ms)
+
+       Delay for given number of milliseconds, should be positive or 0.
+
+    .. function::  sleep_us(us)
+
+       Delay for given number of microseconds, should be positive or 0
+
+    .. function::  ticks_ms()
+
+        Returns an increasing millisecond counter with arbitrary reference point, 
+        that wraps after some (unspecified) value. The value should be treated as 
+        opaque, suitable for use only with ticks_diff().
+
+    .. function::  ticks_us()
+
+       Just like ``ticks_ms`` above, but in microseconds.
+
+    .. function::  ticks_cpu()
+
+       Similar to ``ticks_ms`` and ``ticks_us``, but with higher resolution (usually CPU clocks).
+
+    .. function::  ticks_diff(old, new)
+
+       Measure period between consecutive calls to ticks_ms(), ticks_us(), or ticks_cpu(). 
+       The value returned by these functions may wrap around at any time, so directly 
+       subtracting them is not supported. ticks_diff() should be used instead. "old" value should 
+       actually precede "new" value in time, or result is undefined. This function should not be
+       used to measure arbitrarily long periods of time (because ticks_*() functions wrap around 
+       and usually would have short period). The expected usage pattern is implementing event 
+       polling with timeout::
+
+            # Wait for GPIO pin to be asserted, but at most 500us
+            start = time.ticks_us()
+            while pin.value() == 0:
+                if time.ticks_diff(start, time.ticks_us()) > 500:
+                    raise TimeoutError
+
 .. function:: time()
 
    Returns the number of seconds, as an integer, since 1/1/2000.

docs/wipy/general.rst

@@ -1,6 +1,28 @@
 General information about the WiPy
 ==================================
 
+No floating point support
+-------------------------
+
+Due to space reasons, there's no floating point support, and no math module. This
+means that floating point numbers cannot be used anywhere in the code, and that
+all divisions must be performed using '//' instead of '/'. Example::
+
+    r = 4 // 2  # this will work
+    r = 4 / 2   # this WON'T
+
+Before applying power
+---------------------
+
+.. warning:: 
+
+   The GPIO pins of the WiPy are NOT 5V tolerant, connecting them to voltages higer
+   than 3.6V will cause irreparable damage to the board. ADC pins, when configured 
+   in analog mode cannot withstand volatges above 1.8V. Keep these considerations in
+   mind when wiring your electronics.
+
+
+
 WLAN default behaviour
 ----------------------
 
@@ -28,6 +50,14 @@ Open your FTP client of choice and connect to:
 
 ``ftp://192.168.1.1``, ``user: micro``, ``password: python``
 
+The FTP server on the WiPy doesn't support active mode, only passive, so for instance
+if using the native unix ftp client, just after logging in::
+
+    ftp> passive
+
+Besides that, the FTP server only supports onw data connection at a time. Check out
+the Filezilla settings section below for more info.
+
 FileZilla settings
 ------------------
 Do not use the quick connect button, instead, open the site manager and create a new
@@ -46,8 +76,8 @@ inside ``/flash/sys/`` because it's actually saved bypassing the user file syste
 assured that it was successfully transferred, and it has been signed with a MD5 checksum to
 verify its integrity. Now, reset the MCU by pressing the switch on the board, or by typing::
 
-    import pyb
+    import machine
-    pyb.reset()
+    machine.reset()
 
 Boot modes
 ----------
@@ -91,7 +121,7 @@ The heart beat LED
 By default the heart beat LED flashes once every 4s to signal that the system is
 alive. This can be overridden through the HeartBeat class:
 
-``pyb.HeartBeat().disable()``
+``machine.HeartBeat().disable()``
 
 There are currently 2 kinds of errors that you might see:
 

docs/wipy/quickref.rst

@@ -7,25 +7,28 @@ Quick reference for the WiPy
     :alt: WiPy pinout and alternate functions table
     :width: 800px
 
-General board control
+General board control (including sleep modes)
----------------------
+---------------------------------------------
 
-See :mod:`pyb`. ::
+See :mod:`machine`. ::
 
-    import pyb
+    import machine
 
-    help(pyb) # display all members from the pyb module
+    help(machine) # display all members from the machine module
-    pyb.delay(50) # wait 50 milliseconds
+    machine.freq() # get the CPU frequency
-    pyb.millis() # number of milliseconds since boot-up
+    machine.unique_id() # return the 6-byte unique id of the board (the WiPy's MAC address)
-    pyb.freq() # get the CPU frequency
+
-    pyb.unique_id() # return the 6-byte unique id of the board (the WiPy's MAC address)
+    machine.idle()        # average curernt decreases to (~12mA), any interrupts wakes it up
+    machine.sleep()       # everything except for WLAN is powered down (~950uA avg. current)
+                          # wakes from Pin, RTC or WLAN
+    machine.deepsleep()   # deepest sleep mode, MCU starts from reset. Wakes from Pin and RTC.
 
 Pins and GPIO
 -------------
 
-See :ref:`pyb.Pin <pyb.Pin>`. ::
+See :ref:`machine.Pin <machine.Pin>`. ::
 
-    from pyb import Pin
+    from machine import Pin
 
     # initialize GP2 in gpio mode (af=0) and make it an output
     p_out = Pin('GP2', mode=Pin.OUT)
@@ -41,10 +44,10 @@ See :ref:`pyb.Pin <pyb.Pin>`. ::
 Timers
 ------
 
-See :ref:`pyb.Timer <pyb.Timer>` and :ref:`pyb.Pin <pyb.Pin>`. ::
+See :ref:`machine.Timer <machine.Timer>` and :ref:`machine.Pin <machine.Pin>`. ::
 
-    from pyb import Timer
+    from machine import Timer
-    from pyb import Pin
+    from machine import Pin
 
     tim = Timer(1, mode=Timer.PERIODIC)
     tim_a = tim.channel(Timer.A, freq=1000)
@@ -52,18 +55,18 @@ See :ref:`pyb.Timer <pyb.Timer>` and :ref:`pyb.Pin <pyb.Pin>`. ::
     tim_a.freq(1) # 1 Hz
     
     p_out = Pin('GP2', af=0, mode=Pin.OUT)
-    tim_a.callback(handler=lambda t: p_out.toggle())
+    tim_a.irq(handler=lambda t: p_out.toggle())
 
 PWM (pulse width modulation)
 ----------------------------
 
-See :ref:`pyb.Pin <pyb.Pin>` and :ref:`pyb.Timer <pyb.Timer>`. ::
+See :ref:`machine.Pin <machine.Pin>` and :ref:`machine.Timer <machine.Timer>`. ::
 
-    from pyb import Timer
+    from machine import Timer
-    from pyb import Pin
+    from machine import Pin
 
-    # assign GP25 to alternate function 5 (PWM)
+    # assign GP25 to alternate function 9 (PWM)
-    p_out = Pin('GP25', af=9, type=Pin.STD)
+    p_out = Pin('GP25', mode=Pin.AF, af=9)
 
     # timer 2 in PWM mode and width must be 16 buts
     tim = Timer(2, mode=Timer.PWM, width=16)
@@ -74,9 +77,9 @@ See :ref:`pyb.Pin <pyb.Pin>` and :ref:`pyb.Timer <pyb.Timer>`. ::
 ADC (analog to digital conversion)
 ----------------------------------
 
-See :ref:`pyb.ADC <pyb.ADC>`. ::
+See :ref:`machine.ADC <machine.ADC>`. ::
 
-    from pyb import ADC
+    from machine import ADC
 
     adc = ADC()
     apin = adc.channel(pin='GP3')
@@ -85,19 +88,19 @@ See :ref:`pyb.ADC <pyb.ADC>`. ::
 UART (serial bus)
 -----------------
 
-See :ref:`pyb.Pin <pyb.Pin>` and :ref:`pyb.UART <pyb.UART>`. ::
+See :ref:`machine.Pin <machine.Pin>` and :ref:`machine.UART <machine.UART>`. ::
 
-    from pyb import Pin, UART
+    from machine import Pin, UART
-    uart = UART(0, 9600)
+    uart = UART(0, baudrate=9600)
     uart.write('hello')
     uart.read(5) # read up to 5 bytes
 
 SPI bus
 -------
 
-See :ref:`pyb.SPI <pyb.SPI>`. ::
+See :ref:`machine.SPI <machine.SPI>`. ::
 
-    from pyb SPI
+    from machine SPI
 
     # configure the SPI master @ 2MHz
     spi = SPI(0, SPI.MASTER, baudrate=200000, polarity=0, phase=0)
@@ -109,9 +112,9 @@ See :ref:`pyb.SPI <pyb.SPI>`. ::
 I2C bus
 -------
 
-See :ref:`pyb.Pin <pyb.Pin>` and :ref:`pyb.I2C <pyb.I2C>`. ::
+See :ref:`machine.Pin <machine.Pin>` and :ref:`machine.I2C <machine.I2C>`. ::
 
-    from pyb import Pin, I2C
+    from machine import Pin, I2C
     # configure the I2C bus
     i2c = I2C(0, I2C.MASTER, baudrate=100000)
     i2c.scan() # returns list of slave addresses
@@ -123,9 +126,9 @@ See :ref:`pyb.Pin <pyb.Pin>` and :ref:`pyb.I2C <pyb.I2C>`. ::
 Watchdog timer (WDT)
 --------------------
 
-See :ref:`pyb.WDT <pyb.WDT>`. ::
+See :ref:`machine.WDT <machine.WDT>`. ::
 
-    from pyb import WDT
+    from machine import WDT
 
     # enable the WDT with a timeout of 5s (1s is the minimum)
     wdt = WDT(timeout=5000)
@@ -134,79 +137,73 @@ See :ref:`pyb.WDT <pyb.WDT>`. ::
 Real time clock (RTC)
 ---------------------
 
-See :ref:`pyb.RTC <pyb.RTC>` and ``pyb.Sleep``. ::
+See :ref:`machine.RTC <machine.RTC>` ::
 
-    from pyb import RTC, Sleep
+    import machine
+    from machine import RTC
 
-    rtc = pyb.RTC()
+    rtc = machine.RTC() # init with default time and date
-    rtc.datetime((2014, 5, 1, 4, 13, 0, 0, 0))
+    rtc = RTC(datetime=(2015, 8, 29, 9, 0, 0, 0, None)) # init with a specific time and date
-    print(rtc.datetime())
+    print(rtc.now())
 
-    def some_handler (rtc_obj):
+    def alarm_handler (rtc_o):
-        # trigger the callback again in 30s
+        pass
-        rtc_obj.callback(value=30000, handler=some_handler)
+        # do some non blocking operations
+        # warning printing on an irq via telnet is not
+        # possible, only via UART 
 
-    # create a RTC alarm that expires in 30s
+    # create a RTC alarm that expires after 5 seconds
-    rtc.callback(value=30000, handler=some_handler, wake_from=Sleep.SUSPENDED)
+    rtc.alarm(time=5000, repeat=False)
+
+    # enable RTC interrupts
+    rtc_i = rtc.irq(trigger=RTC.ALARM0, handler=alarm_handler, wake=machine.SLEEP)
 
     # go into suspended mode waiting for the RTC alarm to expire and wake us up
-    Sleep.suspend()
+    machine.sleep()
 
 SD card
 -------
 
-See :ref:`pyb.SD <pyb.SD>`. ::
+See :ref:`machine.SD <machine.SD>`. ::
 
-    from pyb import SD
+    from machine import SD
     import os
 
-    # SD card pins need special configuration so we pass them to the constructor
     # clock pin, cmd pin, data0 pin
     sd = SD(pins=('GP10', 'GP11', 'GP15'))
+    # or use default ones for the expansion board
+    sd = SD()
     os.mount(sd, '/sd')
 
 WLAN (WiFi) 
 -----------
 
-See :ref:`network.WLAN <network.WLAN>` and ``pyb.Sleep``. ::
+See :ref:`network.WLAN <network.WLAN>` and :mod:`machine`. ::
 
+    import machine
     from network import WLAN
-    from pyb import Sleep
 
     # configure the WLAN subsystem in station mode (the default is AP)
-    wifi = WLAN(WLAN.STA)
+    wifi = WLAN(mode=WLAN.STA)
     # go for fixed IP settings
-    wifi.ifconfig(('192.168.0.107', '255.255.255.0', '192.168.0.1', '8.8.8.8'))
+    wifi.ifconfig(config=('192.168.0.107', '255.255.255.0', '192.168.0.1', '8.8.8.8'))
     wifi.scan()     # scan for available netrworks
-    wifi.connect(ssid='mynetwork', security=2, key='mynetworkkey')
+    wifi.connect(ssid='mynetwork', auth=(WLAN.WPA2, 'mynetworkkey'))
     while not wifi.isconnected():
         pass
     print(wifi.ifconfig())
     # enable wake on WLAN
-    wifi.callback(wake_from=Sleep.SUSPENDED)
+    wifi.irq(wake=machine.SLEEP)
     # go to sleep
-    Sleep.suspend()
+    machine.sleep()
     # now, connect to the FTP or the Telnet server and the WiPy will wake-up
 
-Sleep and power modes control
------------------------------
-
-See ``pyb.Sleep``. ::
-
-    from pyb import Sleep
-
-    Sleep.idle()        # lowest sleep mode (~12mA), any interrupts wakes it up
-    Sleep.suspend()     # everything except for WLAN is powered down (~950uA)
-                        # wakes from Pin, RTC or WLAN
-
-    Sleep.hibernate()   # deepest sleep mode, MCU starts from reset. Wakes from Pin and RTC.
-
 Heart beat LED
 --------------
 
-See :ref:`pyb.HeartBeat <pyb.HeartBeat>`. ::
+See :ref:`machine.HeartBeat <machine.HeartBeat>`. ::
 
-    from pyb import HeartBeat
+    from machine import HeartBeat
 
     # disable the heart beat indication (you are free to use this LED connected to GP25)
     HeartBeat().disable()