docs: Bump version to 1.8.

docs/esp8266/tutorial: Change name of ESP8266 firmware to match actual.
docs/esp8266/tutorial/repl: Reword description of initial WebREPL setup a bit.
2025-12-24 22:00:12 +01:00 · 2016-05-03 17:32:32 +01:00 · 2016-05-03 16:42:52 +01:00 · 2016-05-03 18:40:16 +03:00 · 2016-05-03 18:35:43 +03:00 · 2016-05-03 18:25:27 +03:00
1609 changed files with 330256 additions and 80285 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -33,5 +33,7 @@ tests/*.out
 ######################
 __pycache__/

-# Customized Makefile overrides
+# Customized Makefile/project overrides
+######################
 GNUmakefile
+user.props
--- a/.gitmodules
+++ b/.gitmodules
@@ -0,0 +1,10 @@
+[submodule "lib/axtls"]
+	path = lib/axtls
+	url = https://github.com/pfalcon/axtls
+	branch = micropython
+[submodule "lib/libffi"]
+	path = lib/libffi
+	url = https://github.com/atgreen/libffi
+[submodule "lib/lwip"]
+	path = lib/lwip
+	url = http://git.savannah.gnu.org/r/lwip.git
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,22 +1,31 @@
+sudo: required
+dist: trusty
 language: c
 compiler:
  - gcc

 before_script:
-  - sudo add-apt-repository -y ppa:fkrull/deadsnakes
-  - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
+# Extra CPython versions
+#  - sudo add-apt-repository -y ppa:fkrull/deadsnakes
+# Extra gcc versions
+#  - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
  - sudo add-apt-repository -y ppa:terry.guo/gcc-arm-embedded
-  - sudo apt-get update -qq
-  - sudo apt-get install -y python3.4 python3 gcc-4.7 gcc-multilib gcc-arm-none-eabi qemu-system mingw32
+  - sudo dpkg --add-architecture i386
+  - sudo apt-get update -qq || true
+  - sudo apt-get install -y python3 gcc-multilib gcc-arm-none-eabi pkg-config libffi-dev libffi-dev:i386 qemu-system mingw32
  # For teensy build
  - sudo apt-get install realpath
  # For coverage testing
  - sudo pip install cpp-coveralls
+  - gcc --version
+  - arm-none-eabi-gcc --version
+  - python3 --version

 script:
  - make -C minimal test
-  - make -C unix CC=gcc-4.7
-  - make -C unix-cpy CC=gcc-4.7
+  - make -C unix deplibs
+  - make -C unix
+  - make -C unix nanbox
  - make -C bare-arm
  - make -C qemu-arm test
  - make -C stmhal
@@ -32,12 +41,12 @@ script:
  #- (cd tests && MICROPY_CPYTHON3=python3.4 ./run-tests --emit native)

  # run tests with coverage info
-  - make -C unix CC=gcc-4.7 coverage
+  - make -C unix coverage
  - (cd tests && MICROPY_CPYTHON3=python3.4 MICROPY_MICROPYTHON=../unix/micropython_coverage ./run-tests)
  - (cd tests && MICROPY_CPYTHON3=python3.4 MICROPY_MICROPYTHON=../unix/micropython_coverage ./run-tests --emit native)

 after_success:
-  - (cd unix && coveralls --root .. --build-root . --gcov $(which gcov-4.7) --gcov-options '\-o build-coverage/' --include py --include extmod)
+  - (cd unix && coveralls --root .. --build-root . --gcov $(which gcov) --gcov-options '\-o build-coverage/' --include py --include extmod)

 after_failure:
  - (cd tests && for exp in *.exp; do testbase=$(basename $exp .exp); echo -e "\nFAILURE $testbase"; diff -u $testbase.exp $testbase.out; done)
--- a/855
+++ b/855
@@ -1,4 +1,4 @@
-The Micro Python project was proudly and successfully crowdfunded
+The MicroPython project was proudly and successfully crowdfunded
 via a Kickstarter campaign which ended on 13th December 2013.  The
 project was supported by 1923 very generous backers, who pledged
 for a total of 2320 pyboards.
@@ -261,6 +261,7 @@ today.  The names appear in order of pledging.
  503 skakz
  504 Chad Cooper
  505 Makhan Virdi, mlvirdi.com, InfinityXLabs.com, USA
+  506 Glenn Ruben Bakke, Norway
  507 Alasdair Allan
  509 dlbrandon
  511 Dr J Garcia, Sweden
@@ -694,6 +695,7 @@ today.  The names appear in order of pledging.
 1499 Ronald Eddy
 1500 SynShop Las Vegas
 1503 This is really cool.  - Jack Conway
+ 1505 Victor Suarez, Argentina
 1507 Renesas Electronics America
 1509 Team
 1513 A. Lamborn KD0ZFY
@@ -910,3 +912,854 @@ today.  The names appear in order of pledging.
 1955 Pieter Röhling
 1957 uomorando, Italy
 1959 Acacio Cruz
+
+The MicroPython project raised further funds through a second
+Kickstarter campaign that was primarily targeted at porting the
+code to the ESP8266 WiFi chip.  The campaign ended on 2nd March
+2016 and gained the support of 1384 fantastic backers who believed
+in the project and the principles of Open Source code.  Those
+backers who asked to be named are listed below, with an asterisk
+indicating that they also supported the first campaign.
+
+*   1 Gabriel, Seattle
+*   2 @robberwick
+*   6 Dave Hylands
+    7 Les, UK
+    8 Ryanteck LTD., UK
+   10 karlsruhe, HU
+*  11 Turbinenreiter
+   13 Ben Nuttall, UK
+*  14 Bryan Morrissey, MA, USA
+*  15 Jogy, Qatar
+*  16 BOB63,IT
+   19 ReaBoyd
+*  20 Andrew, MK
+*  21 chrisq, NO
+   22 Pascal RENOU, France
+   23 Javier G, ES
+   25 Forrest, US
+   26 Filip Korling, Sweden
+   27 roberthh - Rhineland
+*  28 Herbert Graef, Stuttgart, thanking the MicroPython Team for this great project
+*  29 johnsonfamily38, UK
+   30 CympleCy
+   31 OJ, PK
+   32 Daniel, SVK
+   33 Shabaz Mohammad
+*  35 Kenneth Henderick, BE
+*  37 Daniel Mouritzen, DK
+   39 Torntrousers, UK
+*  44 Scanner
+   45 Radomir Dopieralski
+   46 Nick, UK
+*  47 Jon Hylands, Canada
+*  48 Ben Barwise Clacktronics
+   50 Rob Kent, UK
+   52 Carlos Pereira Atencio
+   54 Andy, UK
+*  55 WMinarik, Canada
+   57 Hauffe, Germany
+   58 HyperTaz, IT
+*  61 Michael Kovacs, AT
+   62 Erick Navarro, PE
+   69 Karan,US
+*  71 Nick B, UK
+*  72 Anthony Lister, NZ
+*  73 Bryan Lyon
+   76 Miguel Angel Ajo,  ES
+*  78 Sebastian, Regensburg (GER)
+*  80 iv3unm
+   81 Thierry BÉNET, FR
+   84 Jannis, Germany
+   86 Nathan Jeffrey
+   88 Cory Benfield, UK
+   90 Carlo, IT
+*  91 Wojciech Bederski (@wuub)
+   92 Steve Holden, UK
+   93 Tristan Roddis, UK
+   94 Balder, Sweden
+*  95 Rhys, UK
+   96 Rowan, UK
+*  97 Gary Martin, Edinburgh
+* 100 Mikael Eiman
+* 101 torwag
+* 102 Craig Barnes, UK
+  103 Andrea Grandi, UK
+  105 Piers, UK
+* 109 Wayne Keenan
+  110 makuk66
+  111 Hamine,DZ
+  112 Arahavica,JP
+* 113 Bill Eubanks, USA
+  114 Jonathan, UK
+  115 ghickman
+* 117 Christian Lange, Germany
+  119 Jonty Wareing
+  121 TheHetman
+  123 Víctor R. Ruiz, Spain
+* 124 Laurynas Paukste, Norway
+* 125 Taki
+  126 André Milette, Canada
+* 127 Ron Cromberge,NL
+  128 IJ, Thailand
+* 130 IGOR VIZIR
+  132 Bill Saturno
+  134 scibi
+  136 Timbo, AU
+  137 Raphael Vogel, DE
+* 139 jasonkirk, US
+  141 Linköping, Sweden
+* 142 Dugres
+  144 DarioS, UK
+  146 NelisW
+* 148 _Mark_
+* 149 Folke Berglund, Sweden
+  150 Deniz Dag/Belgium
+  152 Jacques Thomas
+  153 Dag Henrik, Norway
+* 154 Alexander Steppke
+  158 stavros.io
+* 161 Seong-Woo Kim, KR
+  162 Aaron H, Seattle
+  164 Iwan, CZ
+  165 Jenning, DE
+  167 Oliver Z, Germany
+* 168 Chris Mason, Australia
+  169 Fabio P. Italy
+  171 Jonathan, Ireland
+  173 Philipp B., DE
+  174 Mancho, IT
+  175 Mikkel Sørensen, DK
+  176 Raphael Lullis
+* 177 Tim, China
+  179 JasperS, NL
+  180 Scott, AU
+  181 Roland Kay, UK
+  182 Adam Baxter
+  184 Hugo Herter
+  185 Simon AM, Malta
+  186 Leif Denby
+  190 Maxious
+* 192 Guido, GER
+* 193 Pierre Rousseau, Canada
+  195 Pete Hinch
+* 198 KoalaBear,USA. TRUMPED 2016!
+* 200 Pimoroni, UK
+  201 jpwsutton, UK
+  203 Felix, Sweden
+  204 Dmitri Don, Tallinn Estonia
+  205 PeteDemiSwede, UK
+* 207 Serge GUILLAUME
+  208 Gurtubay, ES
+  209 Geir-Olav, NO
+  210 RayDeo, Germany
+  215 DIYAbility
+  216 Josef Dunbar, USA
+* 217 Enrico, BE/IT
+  219 Damian Moore, UK
+  220 Wayne and Layne, LLC
+  221 The Old Crow, USA
+  224 Hackscribble, UK
+* 225 Alex March, UK
+  226 @rdslw
+  227 Mike, Canada
+* 228 Adrian Smith
+  229 Dinu Gherman, Germany
+  230 Tinamous.com
+* 231 Nikesh, US
+* 232 chrisallick.com
+  234 Daniel Von Fange
+* 235 Michal Muhlpachr, CZ
+* 236 Petr Viktorin
+  237 Ryan Aldredge
+  238 Patrik Wallström, SE
+* 239 MobiusNexus
+  240 Stray, US
+* 241 BOFG, no
+  244 Issac Kelly
+* 247 David Prime
+  249 James Marsh, UK
+* 250 BezouwenR
+  252 Avinash Magdum, India
+  253 Greg Abbas, Menlo Park CA
+  254 Jorge, ES
+  256 JohanP, swe
+* 258 Ben Doan
+  259 Jan van Haarst, NL
+* 263 JoshT, Los Angeles
+  264 cstuder, Switzerland
+  266 Jon Armani
+* 270 Liam Welsh
+  271 Jason Peacock
+  272 Alejandro Lopez
+  275 Dan O'Donovan, UK
+  276 N1TWC
+  277 Roland Tanglao, Vancouver
+  278 Twpsyn
+  280 Robert, ME-US
+* 282 Thomas, UK
+  283 Jeff Schroeder, USA
+  284 Paulus Schoutsen
+* 287 Neon22, NZ
+  290 kbmeister
+  291 Gary Hahn
+  292 Dave Matsumoto, USA
+  296 Sam Lee, SG
+  304 Poul Borg, Denmark
+  307 MightyPork
+  308 Dale
+* 312 Anton Kraft, Germany
+  315 Kism3t, UK
+  317 NateM
+* 318 N&T, Calvijn Meerpaal, NL
+  322 Andreas Monitzer
+  323 Rikard, SE
+  328 Olaf, DE
+* 329 John Boudreaux
+  330 DOCE, Germany
+  331 feilipu
+  332 Stefan Schwetschke
+  333 Wayneji, NZ
+  337 Alain de Lamirande, Canada
+  338 Hori, TW
+  340 Azmodie, UK
+  341 Lygon, UK
+* 342 JRM in STL, USA
+  344 R Colistete-Jr., BR
+* 345 ChristianG, DE
+  347 Nis Sarup, DK.
+  350 Nickedynick
+  351 Dazza, Oz
+  352 lispmeister, NL
+  355 Tomas Lubkowitz, SE
+  357 Mark, UK
+* 358 Team ME
+  363 Papahabla
+  364 Greg Chevalley
+  365 Maic Striepe, Germany
+  369 Ian McMahon
+  371 A. DARGA, Fr
+  372 Ernesto Maranesi, BR
+  373 Steve Lyon
+  374 James Cloos
+  375 Bas Zeppenfeldt, The Netherlands
+  378 Pycom Ltd
+  380 Wade Christensen, USA
+  382 Justin Wing Chung Hui, UK
+  383 C Paulson
+  384 Ian Tickle
+  386 Danny, Seattle
+  388 Erik Moe, Chicago, IL
+* 389 Eric B. Wertz, USA
+  390 Michael. CH
+  391 Christopher Baughman
+  392 James Churchill
+  393 Rob, DC
+  395 Whee Min, Singapore
+* 396 Jason Doege, TX
+  401 MrFish
+  403 Thejesh GN
+  404 Markus, Sweden
+  405 AMR, Spain
+  407 Svet, ES
+* 408 Thoralt, Germany
+  409 Emil, Sweden
+  410 David Moloney, ireland
+  411 Marco S, DE
+  415 Peter W., Austria
+  417 emendo A/S
+* 419 Kalestis, Switzerland
+  421 Ondra, CZ
+  422 Elheffe
+  423 thinkl33t, UK
+  424 TonyF
+  425 Herr Robert Linder, PA, USA
+* 426 Anders Astrom S(E|G)
+* 428 Jussi Ylanen, CT, USA
+  431 Neil H., USA
+  434 Rod Perez, MX
+  435 Carol, US
+  436 Gina Haeussge, DE
+  438 Weilinger, GER
+* 439 Ron Ward, Australia
+  441 Rex, UT, USA
+* 444 Slush, CZ
+  445 Bruce, Florida
+* 448 Patrick Di Justo
+  449 ScubaBearLA
+  450 Mike Causer, Sydney AU
+  451 Joel Fries, USA
+* 452 Andrew Bernstein, US
+  454 EAS, Seattle, WA, USA
+* 456 Christopher J. Morrone, USA
+* 457 Anthony Gilley, Sweden
+  458 Andre Breiler, DE
+* 460 Fuffkin, UK
+* 461 adent, CZ
+  462 Samuel Pickard
+  463 Mirko, Germany
+* 464 Ramin/US
+  465 Mike, Grenoble
+  466 Rolf, DE
+* 467 Dave Haynes
+* 469 Mac Ha, Vietnam
+* 470 Enno, DE
+* 473 Smudo, DE
+* 474 Duncan, Scotland
+  475 Chris, UK
+  476 Peter Groen, NL
+  478 Gertjan Geerling, Nijmegen
+* 479 Benjamin Eberle
+* 480 Mechanical Men Sweden
+* 482 Rémi de Chazelles, FR
+  483 mager, Bremen
+  484 jurekh, NL
+* 485 Craig Burkhead
+  487 JohanHartman, SouthAfrica
+* 489 Viktor, NL
+  491 Jean-Denis Carre
+  492 Jesse, Canada
+  493 Alex C. MacDonald, USA
+* 494 GustavoV, MX
+  495 Sebastian, Berlin
+  497 Bernard, Feluy
+* 500 Ron H, USA
+  501 Gregg "Cabe" Bond, UK
+  502 Colin, NI
+  504 Robin, USA
+* 507 pkropf
+* 510 6LhasaCo Canada
+  511 Tom Sepe, USA
+  513 Andrew McKenna
+  515 tom46037
+  516 G2, USA
+* 517 Pauline Middelink, NL
+* 518 Brush Technology, Ltd
+  520 Pierre Meyitang, USA
+  521 Stephanie Maks, Canada
+  526 John McClain
+* 527 Sigadore, US
+  528 Richard Hudspeth, US
+  530 Martin, Austria
+  531 Stephen Eaton, Australia
+* 533 RJCE, UK
+  535 Teiste, Finland
+  536 Pio, UK
+  537 DirtyHarry, DE
+* 540 Dom G. UK
+* 541 Nial, UK
+  543 Andreas, AUT
+  545 WisdomWolf
+* 549 MrMx,ES
+  552 Daniel Soto, Landscape.
+  554 Claus Fischer, DK
+  557 Aleksi Määttä
+  560 Justin Wilcott, USA
+  562 LoneTone, UK
+  567 Cameron, US
+  568 Dirck, Germany
+  569 Michael Keirnan
+  571 Harry, CN
+* 572 Ward Wouts
+  573 Dan Anaya, USA
+  574 Ben Bennett
+  575 nirvana2165, US
+  576 PDG, BZH
+* 581 Visit, Thailand
+  582 John Carr, UK
+* 583 Klankschap
+  587 jacky,FR
+  588 JD Marsters
+  591 Ryan Jarvis, US
+  595 Claudio Hediger, CH
+* 597 Bambam, Sweden
+  598 Timothé, FR
+* 599 Luís Manuel, Portugal
+  601 Eric, DE
+  602 Olaf, Cambridge, UK
+* 603 Tim, Dubai
+  604 Tyndell, US
+  606 Ciellt AB, SE
+  607 Ömer Boratav
+  609 Guy Molinari, US
+  614 Freek Dijkstra
+  615 Carlos Camargo CO
+  616 Michael Nemecky, Norway
+  618 Ovidiu G.
+  619 arobg, USA
+* 621 Geoff Shilling, US
+  623 EliotB, NZ
+  624 slos UK
+  625 Montreal, CA
+* 626 Peter Korcz
+  627 Kodi
+  628 Jim, Valdosta, USA
+  629 Sander Boele, NL
+  630 Max Lupo
+  631 Daniel.B, Newcastle Australia
+  632 Andrés Suárez García, Vigo (Spain)
+  633 Rens, NL
+  634 Max Petrich, DE
+  635 Fabian Affolter, CH
+  636 Cadair
+* 637 Mike Karliner
+  638 Daniel T, UK
+  639 Mark Campbell, UK
+  640 James S, Australia
+  641 PBTX!
+* 642 amaza,SP
+  644 se4mus
+* 645 Alexander Steffen
+* 647 Jim Richards Maine, USA
+  649 Doug D, US
+  650 Keaton Walker
+* 651 Scott Winder, USA
+  653 Jeff Fischer, USA
+  654 Andrej Mosat
+  655 Mohd Faizal Mansor, Malaysia
+  657 Mike "Cutter" Shievitz, US
+* 658 Daniel Andersson, SE
+  659 Alexander, NL
+  660 François, CH
+* 661 AndrewS, UK
+  662 Denisae, PT
+  663 KC8KZN
+  664 Angelo, Wales
+  665 BlueberryE, Germany
+  667 fvlmurat
+  668 Adam Wilson
+  675 Ulrich Norbisrath (http://ulno.net)
+  676 Daniel, Portland OR
+* 677 Andreas Lindquist, SE
+  680 Jason, NL
+  682 lapawa, GER
+  683 John Batty, UK
+  685 Addy, Netherlands
+  686 Marc, CA
+  690 APapantonatos
+  691 gmorell, US
+* 692 Jamie Mackenzie, Adelaide, SA
+* 693 Dave Dean, US
+  697 woojay, US
+  698 Webabot, NY
+* 699 Jason Fehr, Canada
+  700 Hadi (AU)
+* 701 Abraham Arce
+* 703 Must Be Art
+  712 Thanks for the great work!/datax-holding/Stuttgart
+* 714 Thomas Pr., BE
+  715 Black Country Atelier BCA
+  718 Don W, Arlington VA
+  721 Xavier C. (EU)
+  722 Chad P. Lung, U.S.A
+  726 Alexander Lash (@lexlash)
+  727 Sven, MX
+  728 Terence, PL
+* 730 Mauro De Giorgi, USA
+  735 Jay Ward, Canada
+  736 Fabian Topfstedt, AT
+  739 sjoerdDOTcom
+  740 David, Australia
+  743 Michael Niewiera, Germany
+  745 cbenhagen
+  746 berserck, CH
+  748 Lars Hansson, Sweden
+  750 Landrash
+  751 Richard B., CT USA
+  752 Neil Chandler, UK
+* 753 John Griessen US
+* 755 Caminiti, Mexico
+  757 Mikael Trieb, Sweden
+  760 S1GM9, MX
+  761 Dave C, US
+* 763 Su Zhou, China
+  765 Caitlyn - USA
+  769 Will, NZ
+  770 CJB,UK
+  771 Victor Claessen, NL
+  772 Antal, CH
+  773 Tokyo, Japan
+* 774 Join Business & Technology AB, Sweden
+  777 Overspeed Innovation
+* 778 Bruce, Chanute KS
+  779 TOPALIS, RO
+  780 klaas2
+  781 Matthias Schmitz, Berlin
+  783 Jan Studený wishes "Python everywhere"
+  788 Ian, USA
+  789 Mark K, UK
+  791 DerFlob, Germany
+  792 Staffan Johansson, Sweden
+  793 Stefan W., DE
+  795 Mark S. Harris, Small Dog Electronics
+  796 Kittikun, TH
+* 798 aerialist, Japan
+  799 Sweta
+* 800 Mark Shuttleworth
+  802 Kim Thostrup
+  803 Andy Fundinger
+  810 Matt Vallevand, Detroit MI
+  813 Jim McDonald
+  816 Rob Dobson
+  817 Rafał Zieliński, PL
+* 818 Shaun Walker, AUS
+  819 Timothy R, Belgium
+  820 clem
+  825 JuanB, ES
+  826 Randall Gaz, Colorado USA
+  827 Dick van Ginkel, The Netherlands
+  829 Jan-Pieter Van Impe
+  831 David Kirkpatrick, AU
+  832 Ravi Teja, India
+  833 AkosLukacs, HU
+  834 Dave Desson, CAN
+  837 LWQ.CZ, CZ
+  838 Robert W., Issaquah, WA
+  839 Daniel Hrynczenko
+  840 Martin Filtenborg, DK
+  841 InnHuchen, Ger
+  845 Raju Pillai,India
+  847 cfus/DE
+* 851 Juli H.
+  853 David Monterroso Cabello , SP
+  857 24x8, LLC, US
+  860 Sebastian, DE
+  861 pajusmar
+  864 Ronnie, UK
+* 867 Travis Travelstead, USA
+* 870 Woodat, US/UK
+  872 Gary Bake, UK
+  873 Ernesto Martinez
+* 874 Scottt, USA
+  876 Ronnie Kizzle, LA
+  880 Harish, Singapore
+  882 Wacht, Pittsburgh
+  883 PatrickF, US
+  886 Paolo, IT
+  888 Defragster
+  889 Rachel Rayns, UK
+* 890 Peak Data LLC
+  891 Mindwarp, AU
+  892 Vincent Smedley, UK
+* 894 Bailey & Brayden
+  898 Jacek Artymiak, UK
+  900 John Hudson, USA
+* 901 ReneS, NL
+* 902 B Stevens
+  903 Cptnslick, US
+  904 janlj@me.com
+  905 São Caetano do Sul, SP, Brazil
+  906 Lenz Hirsch
+  907 SerSher, RU
+  908 Florian, DE
+  909 Mathias Svendsen, DK
+* 910 Jeremiah Dey-Oh
+  911 Allan Joseph Medwick
+  913 Matt, Australia
+  914 Christian Pedersen
+* 915 SPIN
+  916 Denis M., Russia
+  917 Ahmed Alboori, Saudi Arabia
+  918 Luciano, Italy
+  919 Ragdehl
+* 921 Artur, HU
+  922 Greg, NC - USA
+  924 Gurzixo
+* 927 Gregg, Oregon
+  928 cwschroeder, BY
+  929 W. Bush - NY, USA.
+  932 ddparker
+  933 Enkion
+* 934 Eric G. Barron
+  936 thomasDOTwtf
+  940 mifous, cucurbitae.eu
+  942 VFL68, FR
+  943 Casey, Hong Kong
+* 945 Kean Electronics
+  946 Nima, UK
+  947 Klosinski, USA
+  948 PieWiE, NL
+* 949 Rui Carmo, PT
+* 950 basbrun.com
+  951 Aashu, UK
+* 952 vk2nq - Brian
+  954 gojimmypi
+  955 Jack, USA
+* 957 @SteveBattle
+* 958 Beshr, Sweden
+  962 PeterR, UK
+  964 Russell Calbert
+  965 LAurent_B, Fr
+  967 Qazi, USA
+  971 Jonas, FR
+  973 PK Shiu
+* 974 sea_kev
+  976 Radhika, USA
+  977 Chris Gibson, US
+* 978 Mike, AU
+* 979 Geeky Pete
+  981 Timmy the wonderdog
+  983 An Ostler it IT
+  984 Frank Ray Robles
+  985 Kurtsik
+  987 Johan, SE
+  988 NJBerland, Norway
+  992 Leon Noel - @leonnoel
+  994 Kjell, SE
+  995 boriskourt
+  997 Bartek B., CANADA
+  999 Thomas Wiradikusuma, Indonesia
+ 1000 Trey, NOLA
+ 1002 Jori, FI
+ 1005 nmmarkin
+ 1006 Mattias Fornander
+ 1007 Panayot Daskalov, Bulgaria
+*1009 AndyP, UK
+ 1011 TSD
+ 1013 Chris, Berlin
+ 1017 Gareth Edwards, UK
+ 1018 Trixam,DE
+ 1019 César from Makespace Madrid, Spain
+ 1020 Prajwal, Australia
+*1024 Fred Dart - FTDI
+ 1025 bsx
+*1026 Regis, FR
+ 1027 Adrian Hill
+ 1029 Alice, UK
+ 1030 Erkan Shakir, BG
+ 1031 Alexander, EE
+ 1033 Patric, Luxembourg
+ 1034 For my beloved mother, Colleen Clancy.
+ 1035 NigelB
+ 1037 François, Aus/Fr
+*1039 Thanura Siribaddana, Australia
+ 1041 Harald, USA
+ 1042 Jeremy Utting, NZ
+ 1043 bejuryu, KR
+*1044 Daniel Wood, UK
+ 1046 C. J. Blocker
+*1047 Rodrigo Benenson, Germany
+ 1048 Håvard Gulldahl
+ 1049 SeB, Belgium
+ 1054 Ryan Miller, Austin TX
+ 1055 Gianluca Cancelmi
+ 1057 Francesco, IT
+ 1058 RockTractor!
+ 1060 Bill G., Atlanta GA USA
+ 1061 joenotjoe
+ 1064 ATrivedi, USA
+ 1067 Jim Chandler, UK
+ 1068 Aria Sabeti
+ 1069 Noah Rosamilia, USA
+ 1070 GAKgDavid, CA
+ 1072 Markus, Austria
+*1073 Tarwin, MUC
+*1077 Balazs Kinszler, HU
+*1080 pfh
+*1082 Ovidiu Hossu, SG
+*1083 mmhanif, NJ
+*1084 Wincent Balin, DE
+*1086 Anatoly Verkhovsky
+*1087 Greg, Plano
+*1089 Angelo Compagnucci
+ 1090 Ryan Shaw (ryannathans), AU
+ 1092 Dries007, BE
+*1093 Dave Snowdon, UK
+*1094 halfpress
+*1096 DeuxVis, FR
+*1097 Your Creative Solutions
+ 1099 Emanuele Goldoni, IT
+*1100 Tendayi Mawushe
+ 1101 Rob, Tikitere
+*1102 SolidStateSoul
+*1103 Michael, GER
+*1106 Paul, San Francisco
+*1107 Oddvar Lovaas
+*1108 Doc Savage, Man of Bronze
+ 1109 Stijn Debrouwere
+ 1111 Ark Nieckarz, USA
+*1112 ECS87.com, USA
+*1114 Gary P. Wolfe, USA
+ 1117 Tom Hodson
+*1118 @arikb (twitter)
+ 1123 Piotr Gryko UK
+*1125 Cantalaweb, Spain
+ 1126 Edward of Clovis
+ 1127 Jim G
+*1128 billbr, Loveland, CO, USA
+ 1129 dalanmiller
+*1130 StephenH, UK
+*1132 Thomas Sarlandie - @sarfata
+ 1133 Doug Rohm, US
+*1134 Eric Floehr, Ohio, USA
+*1135 Sven Haiges
+ 1136 relix42
+*1137 Ralf Nyren
+*1138 nickgb
+ 1139 zwack, DE
+ 1140 Michal B., PL
+ 1141 Matt, Australia
+ 1143 slv, Mi2
+ 1144 Pawel, CH
+*1145 James Saffery
+*1147 nekomatic
+*1149 @nt1, Earth
+*1150 Alister Galpin, NZ
+ 1151 Jayemel, UK
+ 1152 Koalabs
+ 1153 James Myatt, UK
+*1154 DanS, Norway
+ 1155 Sandeep, US
+*1156 Anil Kavipurapu
+*1158 Frederik Werner, DE
+ 1160 Erik J, Canada
+ 1164 bluezebra, Ireland
+ 1168 Birk, DE
+ 1169 Gabi, FR
+*1173 mliberty, USA
+ 1174 Jamie Smith, Scotland
+ 1175 Sebastian, Germany
+*1176 John Cooper, UK
+ 1177 Moritz, DE
+ 1178 Kevin, DE
+*1179 Ming Leung, Canada
+ 1180 Laird Popkin
+ 1181 tasmaniac, GA
+*1183 RichardW, UK
+*1187 Thomas Quinlan, London, UK
+ 1188 LGnap, BE
+*1189 bloater, Edinburgh UK
+ 1192 pakt, SE
+ 1194 Sandsmark, NO
+*1195 Gert Menke
+ 1197 Emsi88, SK
+ 1199 GTtronics HK Ltd.
+ 1200 Jo, Bergen
+*1202 MarkS, Australia
+ 1203 Igor, HR
+ 1204 Lord Nightmare
+ 1205 Great Uncle Bulgaria, UK
+*1206 salomonderossi
+ 1208 Master_Ipse, DE
+ 1209 Luis G.F, ES
+ 1211 Harald, FO
+*1212 Kimmo, Finland
+*1213 P. Perreijn, Netherlands
+ 1214 jcea, Spain
+ 1215 simon holmes à court
+ 1217 Bill M, Newcastle
+*1218 snowball
+*1221 Georges, CDN
+ 1222 JPLa
+ 1225 Erik Gullberg, Sweden
+ 1226 Matthias Fuchs, IN, Germany
+ 1229 Majed, CA
+ 1230 Michiel, Reeuwijk
+ 1231 Clive, Essex UK
+ 1232 Jan Kalina, CZ
+ 1234 MBBest, Australia
+*1235 Reinoud de Lange, NL
+ 1237 Jeffrey Park, South Korea
+ 1238 David Olson
+ 1239 Nathan Battan
+ 1240 Marcus, TW
+ 1241 randyrrt, USA
+ 1242 Holger, Germany
+ 1243 Dmitri Chapkine, FRANCE
+ 1244 Ceyhun Kapucu, TR
+ 1245 Hong Kong
+*1246 gPozo, US
+ 1247 Peter M, Sweden
+*1249 Duncan, Cambridge
+*1251 Schaeferling, DE
+ 1252 Christian Prior, DE
+*1256 ovig
+ 1257 Kerry Channing, UK
+ 1258 Exception42, GER
+*1259 nchalikias
+ 1261 Kittie, US
+ 1263 Alex, Norway
+ 1264 wats0n, TW
+*1265 Henner
+*1266 Mike M, AZ, USA
+ 1268 Bobby Ly, USA
+*1269 Espen STO, Norway
+ 1270 arduware.cc
+ 1274 Christopher Flynn, NH USA
+*1275 Bruce Boyes, USA
+ 1276 DCH
+ 1278 McGinkel, Netherlands
+ 1279 Dieter, Wien
+ 1280 R. Tummers, NL
+ 1283 Pranav Maddula, USA
+ 1286 Dusan, SLovakia
+ 1290 Stephen Youndt
+*1291 Lertsenem, FR
+ 1292 NuclearTide, London
+ 1293 Ben Gift, USA
+ 1294 rmg
+ 1295 jmaybe, USA
+ 1296 Allan G, Georgia
+ 1297 Duncan Brassington, UK
+ 1300 Hans, NL
+ 1301 Valerio "valdez" Paolini, IT
+ 1303 Neotreat, DE
+ 1306 tomtoump
+ 1307 Edward B Cox, England
+ 1310 Oliver Steele
+ 1311 merps, AUS
+ 1313 n8henrie, USA
+*1314 YGA-KSD n7/ULB, FR-BE
+ 1317 Adrian, Romania
+*1318 Luca "Loop", ITA
+*1319 Michael Twomey, Ireland
+ 1321 Trey Aughenbaugh
+ 1322 Marcel Hecko, SK
+ 1323 Hugo Neira, CL
+ 1326 JH, US
+*1330 Luthander, SE
+ 1331 Rickard Dahlstrand, Sweden
+ 1333 Olivier M., France
+ 1334 DWVL, UK
+ 1335 MRZANE, Sweden
+ 1336 Benedikt, DE
+*1338 Tiegeng, US
+*1339 arthoo Eindhoven Nederland
+ 1340 Magnus Gustavsson, Sweden
+ 1341 Jan Bednařík
+ 1344 Mike McGary: US
+ 1346 mp3tobi
+*1350 Cyberhippy
+ 1351 Sandro, PT
+ 1355 Kwabena W. Agyeman
+ 1357 Ryan Young
+*1358 Chiang Mai, Thailand
+ 1359 AKLitman, USA
+ 1360 JASK Enterprises, Ltd-John
+*1361 Tom Gidden, UK
+ 1362 AdamT, USA
+ 1363 Jose de la Campa, BOL
+ 1365 Steve Laguna, U.S.A
+*1368 Walrusklasse, NL
+ 1370 Timofei Korostelev, Belarus
+ 1374 Janos,HU
+*1375 Paul Cunnane
+ 1377 IanE, UK
+ 1378 Hans, NL
+ 1379 Jose Angel Jimenez Vadillo, Spain
+*1380 PaulT, Lancs
+ 1383 Lutz; DE
+ 1385 AnRkey
+ 1387 Fredrik, FIN
+ 1388 Matt W (funkyHat)
+ 1389 Zeev Rotshtein, Israel
+ 1391 joostd, NL
+ 1392 Lukasz Blaszczyk, USA
+*1397 Wei-Ning Huang, TW
+ 1398 myu
+*1399 Thorsten, Germany
+ 1401 sm0ihr
+ 1403 Xiaotian, Seattle US
+*1406 -gt-, Czech Republic
+ 1407 Mike Y. Diallo, US
+ 1409 ubii, US
--- a/CODECONVENTIONS.md
+++ b/CODECONVENTIONS.md
@@ -33,37 +33,50 @@ Braces:
  closing brace.

 Header files:
- Try to stick to the Plan 9 header style, where header files do not
-  include other header files.
- Don't protect a header file from multiple inclusion with #if directives.
+- Header files should be protected from multiple inclusion with #if
+  directives. See an existing header for naming convention.

-Type names and declarations:
- When defining a type, put '_t' after it.
+Names:
+- Use underscore_case, not camelCase for all names.
+- Use CAPS_WITH_UNDERSCORE for enums and macros.
+- When defining a type use underscore_case and put '_t' after it.

-Integer types: Micro Python runs on 32 and 64 bit machines (and one day
-maybe 16 bit), so it's important to use the correctly-sized (and signed)
-integer types.  The general guidelines are:
+Integer types: MicroPython runs on 16, 32, and 64 bit machines, so it's
+important to use the correctly-sized (and signed) integer types.  The
+general guidelines are:
 - For most cases use mp_int_t for signed and mp_uint_t for unsigned
  integer values.  These are guaranteed to be machine-word sized and
-  therefore big enough to hold the value from a Micro Python small-int
+  therefore big enough to hold the value from a MicroPython small-int
  object.
 - Use size_t for things that count bytes / sizes of objects.
 - You can use int/uint, but remember that they may be 16-bits wide.
 - If in doubt, use mp_int_t/mp_uint_t.

+Comments:
+- Be concise and only write comments for things that are not obvious.
+- Use `// ` prefix, NOT `/* ... */`. No extra fluff.
+
+Memory allocation:
+- Use m_new, m_renew, m_del (and friends) to allocate and free heap memory.
+  These macros are defined in py/misc.h.
+
 Examples
 --------

-Braces and spaces:
+Braces, spaces, names and comments:

-    int foo(int x, int y) {
-        if (x < y) {
-            foo(y, x);
+    #define TO_ADD (123)
+
+    // This function will always recurse indefinitely and is only used to show
+    // coding style
+    int foo_function(int x, int some_value) {
+        if (x < some_value) {
+            foo(some_value, x);
        } else {
-            foo(x + 1, y - 1);
+            foo(x + TO_ADD, some_value - 1);
        }

-        for (int i = 0; i < x; i++) {
+        for (int my_counter = 0; my_counter < x; my_counter++) {
        }
    }

--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -0,0 +1,8 @@
+When reporting an issue and especially submitting a pull request, please
+make sure that you are acquainted with Contributor Guidelines:
+
+https://github.com/micropython/micropython/wiki/ContributorGuidelines
+
+and Code Conventions:
+
+https://github.com/micropython/micropython/blob/master/CODECONVENTIONS.md
--- a/README.md
+++ b/README.md
@@ -8,24 +8,26 @@
 [istats-issue-img]: http://issuestats.com/github/micropython/micropython/badge/issue
 [istats-issue-repo]: http://issuestats.com/github/micropython/micropython

-The Micro Python project
-========================
+The MicroPython project
+=======================
 <p align="center">
  <img src="https://raw.githubusercontent.com/micropython/micropython/master/logo/upython-with-micro.jpg" alt="MicroPython Logo"/>
 </p>

-This is the Micro Python project, which aims to put an implementation
+This is the MicroPython project, which aims to put an implementation
 of Python 3.x on microcontrollers and small embedded systems.
+You can find the official website at [micropython.org](http://www.micropython.org).

 WARNING: this project is in beta stage and is subject to changes of the
 code-base, including project-wide name changes and API changes.

-Micro Python implements the entire Python 3.4 syntax (including exceptions,
-"with", "yield from", etc.).  The following core datatypes are provided:
-str (including basic Unicode support), bytes, bytearray, tuple, list, dict,
-set, frozenset, array.array, collections.namedtuple, classes and instances.
-Builtin modules include sys, time, and struct.  Note that only subset of
-Python 3.4 functionality implemented for the data types and modules.
+MicroPython implements the entire Python 3.4 syntax (including exceptions,
+"with", "yield from", etc., and additionally "async" keyword from Python 3.5).
+The following core datatypes are provided: str (including basic Unicode
+support), bytes, bytearray, tuple, list, dict, set, frozenset, array.array,
+collections.namedtuple, classes and instances. Builtin modules include sys,
+time, and struct.  Note that only subset of Python 3.4 functionality
+implemented for the data types and modules.

 See the repository www.github.com/micropython/pyboard for the Micro
 Python board, the officially supported reference electronic circuit board.
@@ -33,24 +35,24 @@ Python board, the officially supported reference electronic circuit board.
 Major components in this repository:
 - py/ -- the core Python implementation, including compiler, runtime, and
  core library.
- unix/ -- a version of Micro Python that runs on Unix.
- stmhal/ -- a version of Micro Python that runs on the Micro Python board
+- unix/ -- a version of MicroPython that runs on Unix.
+- stmhal/ -- a version of MicroPython that runs on the MicroPython board
  with an STM32F405RG (using ST's Cube HAL drivers).
- minimal/ -- a minimal Micro Python port. Start with this if you want
-  to port Micro Python to another microcontroller.
+- minimal/ -- a minimal MicroPython port. Start with this if you want
+  to port MicroPython to another microcontroller.
+- tests/ -- test framework and test scripts.
+- docs/ -- user documentation in Sphinx reStructuredText format.

 Additional components:
- bare-arm/ -- a bare minimum version of Micro Python for ARM MCUs. Used
+- bare-arm/ -- a bare minimum version of MicroPython for ARM MCUs. Used
  mostly to control code size.
- teensy/ -- a version of Micro Python that runs on the Teensy 3.1
+- teensy/ -- a version of MicroPython that runs on the Teensy 3.1
  (preliminary but functional).
- pic16bit/ -- a version of Micro Python for 16-bit PIC microcontrollers.
- cc3200/ -- a version of Micro Python that runs on the CC3200 from TI.
- unix-cpy/ -- a version of Micro Python that outputs bytecode (for testing).
- tests/ -- test framework and test scripts.
+- pic16bit/ -- a version of MicroPython for 16-bit PIC microcontrollers.
+- cc3200/ -- a version of MicroPython that runs on the CC3200 from TI.
+- esp8266/ -- an experimental port for ESP8266 WiFi modules.
 - tools/ -- various tools, including the pyboard.py module.
 - examples/ -- a few example Python scripts.
- docs/ -- official documentation in RST format.

 "make" is used to build the components, or "gmake" on BSD-based systems.
 You will also need bash and Python (at least 2.7 or 3.3).
@@ -64,7 +66,7 @@ as ARM and MIPS. Making full-featured port to another architecture requires
 writing some assembly code for the exception handling and garbage collection.
 Alternatively, fallback implementation based on setjmp/longjmp can be used.

-To build:
+To build (see section below for required dependencies):

    $ cd unix
    $ make
@@ -74,21 +76,62 @@ Then to give it a try:
    $ ./micropython
    >>> list(5 * x + y for x in range(10) for y in [4, 2, 1])

+Use `CTRL-D` (i.e. EOF) to exit the shell.
+Learn about command-line options (in particular, how to increase heap size
+which may be needed for larger applications):
+
+    $ ./micropython --help
+
 Run complete testsuite:

    $ make test

-Debian/Ubuntu/Mint derivative Linux distros will require build-essentials and
-libreadline-dev packages installed. To build FFI (Foreign Function Interface)
-module, libffi-dev and pkg-config packages are required. If you have problems
-with some dependencies, they can be disabled in unix/mpconfigport.mk .
+Unix version comes with a builtin package manager called upip, e.g.:
+
+    $ ./micropython -m upip install micropython-pystone
+    $ ./micropython -m pystone
+
+Browse available modules on
+[PyPI](https://pypi.python.org/pypi?%3Aaction=search&term=micropython).
+Standard library modules come from
+[micropython-lib](https://github.com/micropython/micropython-lib) project.
+
+External dependencies
+---------------------
+
+Building Unix version requires some dependencies installed. For
+Debian/Ubuntu/Mint derivative Linux distros, install `build-essential`
+(includes toolchain and make), `libffi-dev`, and `pkg-config` packages.
+
+Other dependencies can be built together with MicroPython. Oftentimes,
+you need to do this to enable extra features or capabilities. To build
+these additional dependencies, first fetch git submodules for them:
+
+    $ git submodule update --init
+
+Use this same command to get the latest versions of dependencies, as
+they are updated from time to time. After that, in `unix/` dir, execute:
+
+    $ make deplibs
+
+This will build all available dependencies (regardless whether they
+are used or not). If you intend to build MicroPython with additional
+options (like cross-compiling), the same set of options should be passed
+to `make deplibs`. To actually enabled use of dependencies, edit
+`unix/mpconfigport.mk` file, which has inline descriptions of the options.
+For example, to build SSL module (required for `upip` tool described above),
+set `MICROPY_PY_USSL` to 1.
+
+In `unix/mpconfigport.mk`, you can also disable some dependencies enabled
+by default, like FFI support, which requires libffi development files to
+be installed.

 The STM version
 ---------------

 The "stmhal" port requires an ARM compiler, arm-none-eabi-gcc, and associated
 bin-utils.  For those using Arch Linux, you need arm-none-eabi-binutils and
-arm-none-eabi-gcc packages from the AUR.  Otherwise, try here:
+arm-none-eabi-gcc packages.  Otherwise, try here:
 https://launchpad.net/gcc-arm-embedded

 To build:
@@ -104,23 +147,7 @@ Then to flash the code via USB DFU to your device:

    $ make deploy

-You will need the dfu-util program, on Arch Linux it's dfu-util-git in the
-AUR.  If the above does not work it may be because you don't have the
-correct permissions.  Try then:
-
-    $ sudo dfu-util -a 0 -d 0483:df11 -D build-PYBV10/firmware.dfu
-
-Building the documentation locally
----------------------------------
-
-Install Sphinx, and optionally (for the RTD-styling), sphinx_rtd_theme,
-preferably in a virtualenv:
-
-     pip install sphinx
-     pip install sphinx_rtd_theme
-
-In `micropython/docs`, build the docs:
-
-    make html
-
-You'll find the index page at `micropython/docs/build/html/index.html`.
+This will use the included `tools/pydfu.py` script.  If flashing the firmware
+does not work it may be because you don't have the correct permissions, and
+need to use `sudo make deploy`.
+See the README.md file in the stmhal/ directory for further details.
--- a/bare-arm/Makefile
+++ b/bare-arm/Makefile
@@ -8,7 +8,7 @@ include ../py/py.mk

 CROSS_COMPILE = arm-none-eabi-

-INC =  -I.
+INC += -I.
 INC += -I..
 INC += -I$(BUILD)

@@ -42,7 +42,7 @@ all: $(BUILD)/firmware.elf

 $(BUILD)/firmware.elf: $(OBJ)
 	$(ECHO) "LINK $@"
-	$(Q)$(LD) $(LDFLAGS) -o $@ $(OBJ) $(LIBS)
+	$(Q)$(LD) $(LDFLAGS) -o $@ $^ $(LIBS)
 	$(Q)$(SIZE) $@

 include ../py/mkrules.mk
--- a/bare-arm/main.c
+++ b/bare-arm/main.c
@@ -7,7 +7,7 @@
 #include "py/runtime.h"
 #include "py/repl.h"

-void do_str(const char *src) {
+void do_str(const char *src, mp_parse_input_kind_t input_kind) {
    mp_lexer_t *lex = mp_lexer_new_from_str_len(MP_QSTR__lt_stdin_gt_, src, strlen(src), 0);
    if (lex == NULL) {
        return;
@@ -16,8 +16,8 @@ void do_str(const char *src) {
    nlr_buf_t nlr;
    if (nlr_push(&nlr) == 0) {
        qstr source_name = lex->source_name;
-        mp_parse_node_t pn = mp_parse(lex, MP_PARSE_SINGLE_INPUT);
-        mp_obj_t module_fun = mp_compile(pn, source_name, MP_EMIT_OPT_NONE, true);
+        mp_parse_tree_t parse_tree = mp_parse(lex, input_kind);
+        mp_obj_t module_fun = mp_compile(&parse_tree, source_name, MP_EMIT_OPT_NONE, true);
        mp_call_function_0(module_fun);
        nlr_pop();
    } else {
@@ -28,14 +28,12 @@ void do_str(const char *src) {

 int main(int argc, char **argv) {
    mp_init();
-    do_str("print('hello world!', list(x+1 for x in range(10)), end='eol\n')");
+    do_str("print('hello world!', list(x+1 for x in range(10)), end='eol\\n')", MP_PARSE_SINGLE_INPUT);
+    do_str("for i in range(10):\n  print(i)", MP_PARSE_FILE_INPUT);
    mp_deinit();
    return 0;
 }

-void gc_collect(void) {
-}
-
 mp_lexer_t *mp_lexer_new_from_file(const char *filename) {
    return NULL;
 }
@@ -44,7 +42,7 @@ mp_import_stat_t mp_import_stat(const char *path) {
    return MP_IMPORT_STAT_NO_EXIST;
 }

-mp_obj_t mp_builtin_open(uint n_args, const mp_obj_t *args, mp_map_t *kwargs) {
+mp_obj_t mp_builtin_open(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
    return mp_const_none;
 }
 MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_open_obj, 1, mp_builtin_open);
--- a/bare-arm/mpconfigport.h
+++ b/bare-arm/mpconfigport.h
@@ -2,6 +2,7 @@

 // options to control how Micro Python is built

+#define MICROPY_QSTR_BYTES_IN_HASH  (1)
 #define MICROPY_ALLOC_PATH_MAX      (512)
 #define MICROPY_EMIT_X64            (0)
 #define MICROPY_EMIT_THUMB          (0)
@@ -18,15 +19,20 @@
 #define MICROPY_ENABLE_SOURCE_LINE  (0)
 #define MICROPY_ENABLE_DOC_STRING   (0)
 #define MICROPY_ERROR_REPORTING     (MICROPY_ERROR_REPORTING_TERSE)
+#define MICROPY_BUILTIN_METHOD_CHECK_SELF_ARG (0)
+#define MICROPY_PY_ASYNC_AWAIT (0)
 #define MICROPY_PY_BUILTINS_BYTEARRAY (0)
 #define MICROPY_PY_BUILTINS_MEMORYVIEW (0)
+#define MICROPY_PY_BUILTINS_ENUMERATE (0)
 #define MICROPY_PY_BUILTINS_FROZENSET (0)
+#define MICROPY_PY_BUILTINS_REVERSED (0)
 #define MICROPY_PY_BUILTINS_SET     (0)
 #define MICROPY_PY_BUILTINS_SLICE   (0)
 #define MICROPY_PY_BUILTINS_PROPERTY (0)
 #define MICROPY_PY___FILE__         (0)
 #define MICROPY_PY_GC               (0)
 #define MICROPY_PY_ARRAY            (0)
+#define MICROPY_PY_ATTRTUPLE        (0)
 #define MICROPY_PY_COLLECTIONS      (0)
 #define MICROPY_PY_MATH             (0)
 #define MICROPY_PY_CMATH            (0)
@@ -52,6 +58,9 @@ typedef void *machine_ptr_t; // must be of pointer size
 typedef const void *machine_const_ptr_t; // must be of pointer size
 typedef long mp_off_t;

+// dummy print
+#define MP_PLAT_PRINT_STRN(str, len) (void)0
+
 // extra built in names to add to the global namespace
 extern const struct _mp_obj_fun_builtin_t mp_builtin_open_obj;
 #define MICROPY_PORT_BUILTINS \
--- a/bare-arm/mphalport.h
+++ b/bare-arm/mphalport.h
@@ -0,0 +1 @@
+// empty file
--- a/cc3200/FreeRTOS/FreeRTOSConfig.h
+++ b/cc3200/FreeRTOS/FreeRTOSConfig.h
@@ -83,7 +83,7 @@
 #define configUSE_TICK_HOOK				        1
 #define configCPU_CLOCK_HZ				        ( ( unsigned long ) 80000000 )
 #define configTICK_RATE_HZ				        ( ( TickType_t ) 1000 )
-#define configMINIMAL_STACK_SIZE		        ( ( unsigned short ) 64 )
+#define configMINIMAL_STACK_SIZE		        ( ( unsigned short ) 72 )
 #define configTOTAL_HEAP_SIZE			        ( ( size_t ) ( 16384 ) )
 #define configMAX_TASK_NAME_LEN			        ( 8 )
 #define configUSE_TRACE_FACILITY		        0
--- a/cc3200/Makefile
+++ b/cc3200/Makefile
@@ -1,10 +1,11 @@
 # Select the board to build for: if not given on the command line,
-# then default to LAUNCHXL
-BOARD ?= LAUNCHXL
+# then default to WIPY
+BOARD ?= WIPY
 ifeq ($(wildcard boards/$(BOARD)/.),)
 $(error Invalid BOARD specified)
 endif

+# Make 'release' the default build type
 BTYPE ?= release

 # If the build directory is not given, make it reflect the board name.
@@ -16,11 +17,11 @@ include ../py/mkenv.mk
 CROSS_COMPILE ?= arm-none-eabi-

 CFLAGS_CORTEX_M4 = -mthumb -mtune=cortex-m4 -march=armv7e-m -mabi=aapcs -mcpu=cortex-m4 -msoft-float -mfloat-abi=soft -fsingle-precision-constant -Wdouble-promotion
-CFLAGS = -Wall -Wpointer-arith -Werror -ansi -std=gnu99 -nostdlib $(CFLAGS_CORTEX_M4)
+CFLAGS = -Wall -Wpointer-arith -Werror -ansi -std=gnu99 -nostdlib $(CFLAGS_CORTEX_M4) -Os
 CFLAGS += -g -ffunction-sections -fdata-sections -fno-common -fsigned-char -mno-unaligned-access
 CFLAGS += -Iboards/$(BOARD)

-LDFLAGS = -Wl,-nostdlib -Wl,--gc-sections -Wl,-Map=$@.map --specs=nano.specs
+LDFLAGS = -Wl,-nostdlib -Wl,--gc-sections -Wl,-Map=$@.map

 ifeq ($(BTARGET), application)
 # qstr definitions (must come before including py.mk)
--- a/cc3200/README.md
+++ b/cc3200/README.md
@@ -1,6 +1,6 @@
 # Build Instructions for the CC3200

-Currently the CC3200 port of Micro Python builds under Linux and OSX and not under Windows.
+Currently the CC3200 port of MicroPython builds under Linux and OSX **but not under Windows**.

 The tool chain required for the build can be found at <https://launchpad.net/gcc-arm-embedded>.

@@ -13,45 +13,55 @@ In order to debug the port specific code, optimizations need to be disabled on t
 port file (check the Makefile for specific details). You can use CCS from TI.
 Use the CC3200.ccxml file supplied with this distribution for the debuuger configuration. 
 ```bash
-make BTARGET=application BTYPE=debug
+make BTARGET=application BTYPE=debug BOARD=LAUNCHXL
 ```
 ## To build an image suitable to be flashed to the device:
 ```bash
-make BTARGET=application BTYPE=release
+make BTARGET=application BTYPE=release BOARD=LAUNCHXL
 ```
 ## Building the bootloader
 ```bash
-make BTARGET=bootloader BTYPE=release
+make BTARGET=bootloader BTYPE=release BOARD=LAUNCHXL
 ```

+## Regarding old revisions of the CC3200-LAUNCHXL
+First silicon (pre-release) revisions of the CC3200 had issues with the ram blocks, and MicroPython cannot run
+there. Make sure to use a **v4.1 (or higer) LAUNCHXL board** when trying this port, otherwise it won't work.
+
 ## Flashing the CC3200
 - Make sure that you have built both the *bootloader* and the *application* in **release** mode.
 - Make sure the SOP2 jumper is in position.
 - Open CCS_Uniflash and connect to the board (by default on port 22). 
- Format the serial flash (select 1MB size in case of the CC3200-LAUNCHXL, leave the rest unchecked).
- Mark the following files for erasing: `/cert/ca.pem`, `/cert/client.pm`, `/cert/private.key` and `/tmp/pac.bin`.
+- Format the serial flash (select 1MB size in case of the CC3200-LAUNCHXL, 2MB in case of the WiPy, leave the rest unchecked).
+- Mark the following files for erasing: `/cert/ca.pem`, `/cert/client.pem`, `/cert/private.key` and `/tmp/pac.bin`.
 - Add a new file with the name of /sys/mcuimg.bin, and select the URL to point to cc3200\bootmgr\build\<BOARD_NAME>\bootloader.bin.
- Add another file with the name of /sys/factimg.bin, and select the URL to point to cc3200\build\<BOARD_NAME>\MCUIMG.BIN.
+- Add another file with the name of /sys/factimg.bin, and select the URL to point to cc3200\build\<BOARD_NAME>\mcuimg.bin.
 - Click "Program" to apply all changes.
- Flash the latest service pack (servicepack_1.0.0.1.2.bin) using the "Service Pack Update" button.
+- Flash the latest service pack (servicepack_1.0.0.10.0.bin) using the "Service Pack Update" button.
 - Close CCS_Uniflash, remove the SOP2 jumper and reset the board.

+## Updating the board to with new software version
+- Make sure the board is running and connected to the same network as the computer.
+
+```bash
+make BTARGET=application BTYPE=release BOARD=LAUNCHXL WIPY_IP=192.168.1.1 WIPY_USER=micro WIPY_PWD=python deploy
+```
+
+If `WIPY_IP`, `WIPY_USER` or `WIPY_PWD` are omitted the default values (the ones shown above) will be used.
+
 ## Playing with MicroPython and the CC3200:

 Once the software is running, you have two options to access the MicroPython REPL:

- Through the UART. 
-  **Connect to PORT 22, baud rate = 115200, parity = none, stop bits = 1**
 - Through telnet. 
-  * Connect to the network created by the board (as boots up in AP mode), **ssid = "micropy-wlan", key = "micropython"**
+  * Connect to the network created by the board (as boots up in AP mode), **ssid = "wipy-wlan", key = "www.wipy.io"**.
    * You can also reinitialize the WLAN in station mode and connect to another AP, or in AP mode but with a
      different ssid and/or key.
  * Use your favourite telnet client with the following settings: **host = 192.168.1.1, port = 23.**
  * Log in with **user = "micro" and password = "python"**

-The board has a small file system of 64K located in the serial flash connected to the CC3200. SD cards are also supported, but
-since the CC3200 LaunchXL doesn't come with an SD card socket installed, you will need to add one yourself. Any SD card breakout
-board will do, as long as you connect it as described here: <http://processors.wiki.ti.com/index.php/CC32xx_SDHost_FatFS>
+The board has a small file system of 192K (WiPy) or 64K (Launchpad) located in the serial flash connected to the CC3200. 
+SD cards are also supported, you can connect any SD card and configure the pinout using the SD class API.

 ## Uploading scripts:

@@ -63,15 +73,15 @@ not 100% sure of it.

 ## Upgrading the firmware Over The Air:

-OTA software updates can be performed through the FTP server. After building a new MCUIMG.BIN in release mode, upload it to:
-`/SFLASH/SYS/MCUIMG.BIN` it will take around 8s (The TI simplelink file system is quite slow because every file is mirrored for
-safety). You won't see the file being stored inside `/SFLASH/SYS/` because it's actually saved bypassing FatFS, but rest assured that
+OTA software updates can be performed through the FTP server. After building a new **mcuimg.bin** in release mode, upload it to:
+`/flash/sys/mcuimg.bin` it will take around 6s (The TI simplelink file system is quite slow because every file is mirrored for
+safety). You won't see the file being stored inside `/flash/sys/` because it's actually saved bypassing FatFS, but rest assured that
 the file 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:

 ```python
-import pyb
-pyb.hard_reset()
+import machine
+machine.reset()
 ```

 ### Note regarding FileZilla:
--- a/cc3200/application.lds
+++ b/cc3200/application.lds
@@ -26,7 +26,6 @@

 __stack_size__    = 2K;       /* interrupts are handled within this stack */
 __min_heap_size__ = 8K;
-__rtos_heap_size  = 16K;

 MEMORY
 {
--- a/cc3200/application.mk
+++ b/cc3200/application.mk
@@ -20,6 +20,8 @@ APP_INC += -I$(BUILD)
 APP_INC += -I$(BUILD)/genhdr
 APP_INC += -I../lib/fatfs
 APP_INC += -I../lib/mp-readline
+APP_INC += -I../lib/netutils
+APP_INC += -I../lib/timeutils
 APP_INC += -I../stmhal

 APP_CPPDEFINES = -Dgcc -DTARGET_IS_CC3200 -DSL_FULL -DUSE_FREERTOS
@@ -73,22 +75,24 @@ APP_HAL_SRC_C = $(addprefix hal/,\
 	)

 APP_MISC_SRC_C = $(addprefix misc/,\
+	antenna.c \
 	FreeRTOSHooks.c \
-	pin_named_pins.c \
 	help.c \
-	mpcallback.c \
+	mpirq.c \
 	mperror.c \
 	mpexception.c \
 	mpsystick.c \
-	pin_defs_cc3200.c \
 	)

 APP_MODS_SRC_C = $(addprefix mods/,\
+	modmachine.c \
 	modnetwork.c \
-	modpyb.c \
+	modubinascii.c \
 	moduos.c \
 	modusocket.c \
+	modussl.c \
 	modutime.c \
+	modwipy.c \
 	modwlan.c \
 	pybadc.c \
 	pybpin.c \
@@ -97,6 +101,7 @@ APP_MODS_SRC_C = $(addprefix mods/,\
 	pybsd.c \
 	pybsleep.c \
 	pybspi.c \
+	pybtimer.c \
 	pybuart.c \
 	pybwdt.c \
 	)
@@ -122,6 +127,7 @@ APP_TELNET_SRC_C = $(addprefix telnet/,\
 	)
 	
 APP_UTIL_SRC_C = $(addprefix util/,\
+	cryptohash.c \
 	fifo.c \
 	gccollect.c \
 	random.c \
@@ -143,18 +149,21 @@ APP_LIB_SRC_C = $(addprefix lib/,\
 	fatfs/option/ccsbcs.c \
 	libc/string0.c \
 	mp-readline/readline.c \
+	netutils/netutils.c \
+	timeutils/timeutils.c \
+	utils/pyexec.c \
+	utils/pyhelp.c \
+	utils/printf.c \
 	)
 	
 APP_STM_SRC_C = $(addprefix stmhal/,\
 	bufhelper.c \
-	file.c \
+	builtin_open.c \
 	import.c \
 	input.c \
 	irq.c \
 	lexerfatfs.c \
 	moduselect.c \
-	printf.c \
-	pyexec.c \
 	pybstdio.c \
 	)

@@ -163,6 +172,12 @@ OBJ += $(addprefix $(BUILD)/, $(APP_MODS_SRC_C:.c=.o) $(APP_CC3100_SRC_C:.c=.o)
 OBJ += $(addprefix $(BUILD)/, $(APP_MAIN_SRC_C:.c=.o) $(APP_LIB_SRC_C:.c=.o) $(APP_STM_SRC_C:.c=.o))
 OBJ += $(BUILD)/pins.o

+# List of sources for qstr extraction
+SRC_QSTR += $(APP_MODS_SRC_C) $(APP_MISC_SRC_C) $(APP_STM_SRC_C)
+# Append any auto-generated sources that are needed by sources listed in
+# SRC_QSTR
+SRC_QSTR_AUTO_DEPS +=
+
 # Add the linker script
 LINKER_SCRIPT = application.lds
 LDFLAGS += -T $(LINKER_SCRIPT)
@@ -175,30 +190,10 @@ $(BUILD)/drivers/cc3100/src/driver.o: CFLAGS += -fno-strict-aliasing

 # Check if we would like to debug the port code
 ifeq ($(BTYPE), release)
-# Optimize everything and define the NDEBUG flag
-CFLAGS += -Os -DNDEBUG
+CFLAGS += -DNDEBUG
 else
 ifeq ($(BTYPE), debug)
-# Define the DEBUG flag
-CFLAGS += -DDEBUG=DEBUG
-# Optimize the stable sources only
-$(BUILD)/extmod/%.o: CFLAGS += -Os
-$(BUILD)/lib/%.o: CFLAGS += -Os
-$(BUILD)/fatfs/src/%.o: CFLAGS += -Os
-$(BUILD)/FreeRTOS/Source/%.o: CFLAGS += -Os
-$(BUILD)/ftp/%.o: CFLAGS += -Os
-$(BUILD)/hal/%.o: CFLAGS += -Os
-$(BUILD)/misc/%.o: CFLAGS += -Os
-$(BUILD)/py/%.o: CFLAGS += -Os
-$(BUILD)/simplelink/%.o: CFLAGS += -Os
-$(BUILD)/drivers/cc3100/%.o: CFLAGS += -Os
-$(BUILD)/stmhal/%.o: CFLAGS += -Os
-$(BUILD)/telnet/%.o: CFLAGS += -Os
-$(BUILD)/util/%.o: CFLAGS += -Os
-$(BUILD)/pins.o: CFLAGS += -Os
-$(BUILD)/main.o: CFLAGS += -Os
-$(BUILD)/mptask.o: CFLAGS += -Os
-$(BUILD)/servertask.o: CFLAGS += -Os
+CFLAGS += -DNDEBUG
 else
 $(error Invalid BTYPE specified)
 endif
@@ -206,9 +201,19 @@ endif

 SHELL = bash
 APP_SIGN = appsign.sh
+UPDATE_WIPY ?= tools/update-wipy.py
+WIPY_IP ?= '192.168.1.1'
+WIPY_USER ?= 'micro'
+WIPY_PWD ?= 'python'

 all: $(BUILD)/mcuimg.bin

+.PHONY: deploy
+
+deploy: $(BUILD)/mcuimg.bin
+	$(ECHO) "Writing $< to the board"
+	$(Q)$(PYTHON) $(UPDATE_WIPY) --verify --ip $(WIPY_IP) --user $(WIPY_USER) --password $(WIPY_PWD) --file $<
+
 $(BUILD)/application.axf: $(OBJ) $(LINKER_SCRIPT)
 	$(ECHO) "LINK $@"
 	$(Q)$(CC) -o $@ $(LDFLAGS) $(OBJ) $(LIBS)
@@ -220,7 +225,7 @@ $(BUILD)/application.bin: $(BUILD)/application.axf

 $(BUILD)/mcuimg.bin: $(BUILD)/application.bin
 	$(ECHO) "Create $@"
-	$(Q)$(SHELL) $(APP_SIGN) $(BOARD) $(BTYPE)
+	$(Q)$(SHELL) $(APP_SIGN) $(BUILD)

 MAKE_PINS = boards/make-pins.py
 BOARD_PINS = boards/$(BOARD)/pins.csv
--- a/cc3200/appsign.sh
+++ b/cc3200/appsign.sh
@@ -1,19 +1,20 @@
 #!/bin/bash

-if [ "$#" -ne 2 ]; then
-    echo "Usage: appsign.sh *board type* *build type*"
+if [ "$#" -ne 1 ]; then
+    echo "Usage: appsign.sh *build dir*"
    exit 1
 fi

-BOARD=$1
-BTYPE=$2
-
 # Build location
-# Based on build type and board type
-BUILD=build/${BOARD}/${BTYPE}
+BUILD=$1

 # Generate the MD5 hash
+# md5 on Darwin, md5sum on Unix
+if [ `uname -s` = "Darwin" ]; then
+echo -n `md5 -q $BUILD/application.bin` > __md5hash.bin
+else
 echo -n `md5sum --binary $BUILD/application.bin | awk '{ print $1 }'` > __md5hash.bin
+fi

 # Concatenate it with the application binary
 cat $BUILD/application.bin __md5hash.bin > $BUILD/mcuimg.bin
--- a/cc3200/boards/LAUNCHXL/mpconfigboard.h
+++ b/cc3200/boards/LAUNCHXL/mpconfigboard.h
@@ -25,34 +25,23 @@
 * THE SOFTWARE.
 */

-#include "version.h"
-
 #define LAUNCHXL

-#define BOARD_NAME                                  "LaunchPad "
-#define MICROPY_HW_BOARD_NAME                       VERSION_E(BOARD_NAME, VERSION_NUMBER)
+#define MICROPY_HW_BOARD_NAME                       "LaunchPad"
 #define MICROPY_HW_MCU_NAME                         "CC3200"

-#define MICROPY_PORT_WLAN_AP_SSID                   "launchpad-wlan"
-#define MICROPY_PORT_WLAN_AP_KEY                    "micropython"
-#define MICROPY_PORT_WLAN_AP_SECURITY               SL_SEC_TYPE_WPA_WPA2
-#define MICROPY_PORT_WLAN_AP_CHANNEL                5
+#define MICROPY_HW_ANTENNA_DIVERSITY                (0)

-#define MICROPY_HW_HAS_SDCARD                       (0)
-#define MICROPY_HW_ENABLE_RNG                       (1)
-#define MICROPY_HW_ENABLE_RTC                       (1)
-
-#define MICROPY_STDIO_UART                          PYB_UART_0
+#define MICROPY_STDIO_UART                          0
 #define MICROPY_STDIO_UART_BAUD                     115200
-#define MICROPY_STDIO_UART_RX_BUF_SIZE              128

 #define MICROPY_SYS_LED_PRCM                        PRCM_GPIOA1
 #define MICROPY_SAFE_BOOT_PRCM                      PRCM_GPIOA2
 #define MICROPY_SYS_LED_PORT                        GPIOA1_BASE
 #define MICROPY_SAFE_BOOT_PORT                      GPIOA2_BASE
-#define MICROPY_SYS_LED_GPIO                        pin_GPIO9
-#define MICROPY_SYS_LED_PIN_NUM                     PIN_64      // GPIO9
-#define MICROPY_SAFE_BOOT_PIN_NUM                   PIN_15      // GPIO22
+#define MICROPY_SYS_LED_GPIO                        pin_GP9
+#define MICROPY_SYS_LED_PIN_NUM                     PIN_64      // GP9
+#define MICROPY_SAFE_BOOT_PIN_NUM                   PIN_15      // GP22
 #define MICROPY_SYS_LED_PORT_PIN                    GPIO_PIN_1
 #define MICROPY_SAFE_BOOT_PORT_PIN                  GPIO_PIN_6

--- a/cc3200/boards/WIPY-SD/mpconfigboard.h
+++ b/cc3200/boards/WIPY-SD/mpconfigboard.h
@@ -1,59 +0,0 @@
-/*
- * This file is part of the Micro Python project, http://micropython.org/
- *
- * The MIT License (MIT)
- *
- * Copyright (c) 2013, 2014 Damien P. George
- * Copyright (c) 2015 Daniel Campora
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include "version.h"
-
-#define WIPY_SD
-
-#define BOARD_NAME                                  "WiPy-SD "
-#define MICROPY_HW_BOARD_NAME                       VERSION_E(BOARD_NAME, VERSION_NUMBER)
-#define MICROPY_HW_MCU_NAME                         "CC3200"
-
-#define MICROPY_PORT_WLAN_AP_SSID                   "wipy-wlan"
-#define MICROPY_PORT_WLAN_AP_KEY                    "www.wipy.io"
-#define MICROPY_PORT_WLAN_AP_SECURITY               SL_SEC_TYPE_WPA_WPA2
-#define MICROPY_PORT_WLAN_AP_CHANNEL                5
-
-#define MICROPY_HW_HAS_SDCARD                       (1)
-#define MICROPY_HW_ENABLE_RNG                       (1)
-#define MICROPY_HW_ENABLE_RTC                       (1)
-
-#define MICROPY_STDIO_UART                          PYB_UART_0
-#define MICROPY_STDIO_UART_BAUD                     115200
-#define MICROPY_STDIO_UART_RX_BUF_SIZE              128
-
-#define MICROPY_SYS_LED_PRCM                        PRCM_GPIOA3
-#define MICROPY_SAFE_BOOT_PRCM                      PRCM_GPIOA3
-#define MICROPY_SYS_LED_PORT                        GPIOA3_BASE
-#define MICROPY_SAFE_BOOT_PORT                      GPIOA3_BASE
-#define MICROPY_SYS_LED_GPIO                        pin_GPIO25
-#define MICROPY_SYS_LED_PIN_NUM                     PIN_21      // GPIO25   (SOP2)
-#define MICROPY_SAFE_BOOT_PIN_NUM                   PIN_18      // GPIO28
-#define MICROPY_SYS_LED_PORT_PIN                    GPIO_PIN_1
-#define MICROPY_SAFE_BOOT_PORT_PIN                  GPIO_PIN_4
-
-#define MICROPY_PORT_SFLASH_BLOCK_COUNT             96
--- a/cc3200/boards/WIPY-SD/pins.csv
+++ b/cc3200/boards/WIPY-SD/pins.csv
@@ -1,25 +0,0 @@
-L2,GPIO2
-L3,GPIO1
-L4,GPIO23
-L5,GPIO24
-L6,GPIO11
-L7,GPIO12
-L8,GPIO13
-L9,GPIO14
-L10,GPIO15
-L11,GPIO16
-L12,GPIO17
-L13,GPIO22
-L14,GPIO28
-R4,GPIO10
-R5,GPIO9
-R6,GPIO8
-R7,GPIO7
-R8,GPIO6
-R9,GPIO30
-R10,GPIO31
-R11,GPIO3
-R12,GPIO0
-R13,GPIO4
-R14,GPIO5
-HBL,GPIO25
--- a/cc3200/boards/WIPY/mpconfigboard.h
+++ b/cc3200/boards/WIPY/mpconfigboard.h
@@ -25,34 +25,20 @@
 * THE SOFTWARE.
 */

-#include "version.h"
-
 #define WIPY

-#define BOARD_NAME                                  "WiPy "
-#define MICROPY_HW_BOARD_NAME                       VERSION_E(BOARD_NAME, VERSION_NUMBER)
+#define MICROPY_HW_BOARD_NAME                       "WiPy"
 #define MICROPY_HW_MCU_NAME                         "CC3200"

-#define MICROPY_PORT_WLAN_AP_SSID                   "wipy-wlan"
-#define MICROPY_PORT_WLAN_AP_KEY                    "www.wipy.io"
-#define MICROPY_PORT_WLAN_AP_SECURITY               SL_SEC_TYPE_WPA_WPA2
-#define MICROPY_PORT_WLAN_AP_CHANNEL                5
-
-#define MICROPY_HW_HAS_SDCARD                       (0)
-#define MICROPY_HW_ENABLE_RNG                       (1)
-#define MICROPY_HW_ENABLE_RTC                       (1)
-
-#define MICROPY_STDIO_UART                          PYB_UART_0
-#define MICROPY_STDIO_UART_BAUD                     115200
-#define MICROPY_STDIO_UART_RX_BUF_SIZE              128
+#define MICROPY_HW_ANTENNA_DIVERSITY                (1)

 #define MICROPY_SYS_LED_PRCM                        PRCM_GPIOA3
 #define MICROPY_SAFE_BOOT_PRCM                      PRCM_GPIOA3
 #define MICROPY_SYS_LED_PORT                        GPIOA3_BASE
 #define MICROPY_SAFE_BOOT_PORT                      GPIOA3_BASE
-#define MICROPY_SYS_LED_GPIO                        pin_GPIO25
-#define MICROPY_SYS_LED_PIN_NUM                     PIN_21      // GPIO25   (SOP2)
-#define MICROPY_SAFE_BOOT_PIN_NUM                   PIN_18      // GPIO28
+#define MICROPY_SYS_LED_GPIO                        pin_GP25
+#define MICROPY_SYS_LED_PIN_NUM                     PIN_21      // GP25   (SOP2)
+#define MICROPY_SAFE_BOOT_PIN_NUM                   PIN_18      // GP28
 #define MICROPY_SYS_LED_PORT_PIN                    GPIO_PIN_1
 #define MICROPY_SAFE_BOOT_PORT_PIN                  GPIO_PIN_4

--- a/cc3200/boards/WIPY/pins.csv
+++ b/cc3200/boards/WIPY/pins.csv
@@ -1,25 +1,25 @@
-L2,GPIO2
-L3,GPIO1
-L4,GPIO23
-L5,GPIO24
-L6,GPIO11
-L7,GPIO12
-L8,GPIO13
-L9,GPIO14
-L10,GPIO15
-L11,GPIO16
-L12,GPIO17
-L13,GPIO22
-L14,GPIO28
-R4,GPIO10
-R5,GPIO9
-R6,GPIO8
-R7,GPIO7
-R8,GPIO6
-R9,GPIO30
-R10,GPIO31
-R11,GPIO3
-R12,GPIO0
-R13,GPIO4
-R14,GPIO5
-HBL,GPIO25
+L2,GP2
+L3,GP1
+L4,GP23
+L5,GP24
+L6,GP11
+L7,GP12
+L8,GP13
+L9,GP14
+L10,GP15
+L11,GP16
+L12,GP17
+L13,GP22
+L14,GP28
+R4,GP10
+R5,GP9
+R6,GP8
+R7,GP7
+R8,GP6
+R9,GP30
+R10,GP31
+R11,GP3
+R12,GP0
+R13,GP4
+R14,GP5
+HBL,GP25
--- a/cc3200/boards/cc3200_af.csv
+++ b/cc3200/boards/cc3200_af.csv
@@ -1,25 +1,25 @@
 Pin,Name,Default,AF0,AF1,AF2,AF3,AF4,AF5,AF6,AF7,AF8,AF9,AF10,AF11,AF12,AF13,AF14,AF15,ADC
-1,GPIO10,GPIO10,GPIO10,I2C_SCL,,GT_PWM06,,,SDCARD_CLK,UART1_TX,,,,,GT_CCP01,,,,
-2,GPIO11,GPIO11,GPIO11,I2C_SDA,,GT_PWM07,pXCLK(XVCLK),,SDCARD_CMD,UART1_RX,,,,,GT_CCP02,McAFSX,,,
-3,GPIO12,GPIO12,GPIO12,,,McACLK,pVS(VSYNC),I2C_SCL,,UART0_TX,,,,,GT_CCP03,,,,
-4,GPIO13,GPIO13,GPIO13,,,,pHS(HSYNC),I2C_SDA,,UART0_RX,,,,,GT_CCP04,,,,
-5,GPIO14,GPIO14,GPIO14,,,,pDATA8(CAM_D4),2C_SCL,,GSPI_CLK,,,,,GT_CCP05,,,,
-6,GPIO15,GPIO15,GPIO15,,,,pDATA9(CAM_D5),I2C_SDA,,GSPI_MISO,,,,,,GT_CCP06,,,
-7,GPIO16,GPIO16,GPIO16,,,,pDATA10(CAM_D6),UART1_TX,,GSPI_MOSI,,,,,,GT_CCP07,,,
-8,GPIO17,GPIO17,GPIO17,,,,pDATA11(CAM_D7),UART1_RX,,GSPI_CS,,,,,,,,,
+1,GP10,GP10,GP10,I2C0_SCL,,TIM3_PWM,,,SD0_CLK,UART1_TX,,,,,TIM0_CC,,,,
+2,GP11,GP11,GP11,I2C0_SDA,,TIM3_PWM,pXCLK(XVCLK),,SD0_CMD,UART1_RX,,,,,TIM1_CC,I2S0_FS,,,
+3,GP12,GP12,GP12,,,I2S0_CLK,pVS(VSYNC),I2C0_SCL,,UART0_TX,,,,,TIM1_CC,,,,
+4,GP13,GP13,GP13,,,,pHS(HSYNC),I2C0_SDA,,UART0_RX,,,,,TIM2_CC,,,,
+5,GP14,GP14,GP14,,,,pDATA8(CAM_D4),I2C0_SCL,,SPI0_CLK,,,,,TIM2_CC,,,,
+6,GP15,GP15,GP15,,,,pDATA9(CAM_D5),I2C0_SDA,,SPI0_MISO,SD0_DAT0,,,,,TIM3_CC,,,
+7,GP16,GP16,GP16,,,,pDATA10(CAM_D6),UART1_TX,,SPI0_MOSI,SD0_CLK,,,,,TIM3_CC,,,
+8,GP17,GP17,GP17,,,,pDATA11(CAM_D7),UART1_RX,,SPI0_CS0,SD0_CMD,,,,,,,,
 9,VDD_DIG1,VDD_DIG1,VDD_DIG1,,,,,,,,,,,,,,,,
 10,VIN_IO1,VIN_IO1,VIN_IO1,,,,,,,,,,,,,,,,
 11,FLASH_SPI_CLK,FLASH_SPI_CLK,FLASH_SPI_CLK,,,,,,,,,,,,,,,,
 12,FLASH_SPI_DOUT,FLASH_SPI_DOUT,FLASH_SPI_DOUT,,,,,,,,,,,,,,,,
 13,FLASH_SPI_DIN,FLASH_SPI_DIN,FLASH_SPI_DIN,,,,,,,,,,,,,,,,
 14,FLASH_SPI_CS,FLASH_SPI_CS,FLASH_SPI_CS,,,,,,,,,,,,,,,,
-15,GPIO22,GPIO22,GPIO22,,,,,GT_CCP04,,McAFSX,,,,,,,,,
-16,GPIO23,TDI,GPIO23,TDI,UART1_TX,,,,,,,2C_SCL,,,,,,,
-17,GPIO24,TDO,GPIO24,TDO,UART1_RX,,GT_CCP06,PWM0,McAFSX,,,I2C_SDA,,,,,,,
-18,GPIO28,GPIO28,GPIO28,,,,,,,,,,,,,,,,
-19,TCK,TCK,,TCK,,,,,,,GT_PWM03,,,,,,,,
-20,GPIO29,TMS,GPIO29,TMS,,,,,,,,,,,,,,,
-21,GPIO25,SOP2,GPIO25,,McAFSX,,,,,,,GT_PWM02,,,,,,,
+15,GP22,GP22,GP22,,,,,TIM2_CC,,I2S0_FS,,,,,,,,,
+16,GP23,TDI,GP23,TDI,UART1_TX,,,,,,,I2C0_SCL,,,,,,,
+17,GP24,TDO,GP24,TDO,UART1_RX,,TIM3_CC,TIM0_PWM,I2S0_FS,,,I2C0_SDA,,,,,,,
+18,GP28,GP28,GP28,,,,,,,,,,,,,,,,
+19,TCK,TCK,,TCK,,,,,,,TIM1_PWM,,,,,,,,
+20,GP29,TMS,GP29,TMS,,,,,,,,,,,,,,,
+21,GP25,SOP2,GP25,,I2S0_FS,,,,,,,TIM1_PWM,,,,,,,
 22,WLAN_XTAL_N,WLAN_XTAL_N,WLAN_XTAL_N,,,,,,,,,,,,,,,,
 23,WLAN_XTAL_P,WLAN_XTAL_P,WLAN_XTAL_P,,,,,,,,,,,,,,,,
 24,VDD_PLL,VDD_PLL,VDD_PLL,,,,,,,,,,,,,,,,
@@ -43,24 +43,24 @@ Pin,Name,Default,AF0,AF1,AF2,AF3,AF4,AF5,AF6,AF7,AF8,AF9,AF10,AF11,AF12,AF13,AF1
 42,DCDC_PA_OUT,DCDC_PA_O UT,DCDC_PA_O UT,,,,,,,,,,,,,,,,
 43,DCDC_DIG_SW,DCDC_DIG_ SW,DCDC_DIG_ SW,,,,,,,,,,,,,,,,
 44,VIN_DCDC_DIG,VIN_DCDC_ DIG,VIN_DCDC_ DIG,,,,,,,,,,,,,,,,
-45,GPIO31,DCDC_ANA2_SW_P,GPIO31,,UART1_RX,,,,McAXR0,GSPI_CLK,,UART0_RX,,,McAFSX,,,,
+45,GP31,DCDC_ANA2_SW_P,GP31,,UART1_RX,,,,I2S0_DAT0,SPI0_CLK,,UART0_RX,,,I2S0_FS,,,,
 46,DCDC_ANA2_SW_N,DCDC_ANA2_SW_N,DCDC_ANA2_SW_N,,,,,,,,,,,,,,,,
 47,VDD_ANA2,VDD_ANA2,VDD_ANA2,,,,,,,,,,,,,,,,
 48,VDD_ANA1,VDD_ANA1,VDD_ANA1,,,,,,,,,,,,,,,,
 49,VDD_RAM,VDD_RAM,VDD_RAM,,,,,,,,,,,,,,,,
-50,GPIO0,GPIO0,GPIO0,,,UART0_RTS,McAXR0,,McAXR1,GT_CCP00,,GSPI_CS,UART1_RTS,,UART0_CTS,,,,
+50,GP0,GP0,GP0,,,UART0_RTS,I2S0_DAT0,,I2S0_DAT1,TIM0_CC,,SPI0_CS0,UART1_RTS,,UART0_CTS,,,,
 51,RTC_XTAL_P,RTC_XTAL_P,RTC_XTAL_P,,,,,,,,,,,,,,,,
-52,RTC_XTAL_N,RTC_XTAL_N,GPIO32,,McACLK,,McAXR0,,UART0_RTS,,GSPI_MOSI,,,,,,,,
-53,GPIO30,GPIO30,GPIO30,,McACLK,McAFSX,GT_CCP05,,,GSPI_MISO,,UART0_TX,,,,,,,
+52,RTC_XTAL_N,RTC_XTAL_N,GP32,,I2S0_CLK,,I2S0_DAT0,,UART0_RTS,,SPI0_MOSI,,,,,,,,
+53,GP30,GP30,GP30,,I2S0_CLK,I2S0_FS,TIM2_CC,,,SPI0_MISO,,UART0_TX,,,,,,,
 54,VIN_IO2,VIN_IO2,VIN_IO2,,,,,,,,,,,,,,,,
-55,GPIO1,GPIO1,GPIO1,,,GSPI_MISO,pCLK (PIXCLK),,UART1_TX,GT_CCP01,,,,,,,,,
+55,GP1,GP1,GP1,,,UART0_TX,pCLK (PIXCLK),,UART1_TX,TIM0_CC,,,,,,,,,
 56,VDD_DIG2,VDD_DIG2,VDD_DIG2,,,,,,,,,,,,,,,,
-57,GPIO2,GPIO2,GPIO2,,,UART0_RX,,,UART1_RX,GT_CCP02,,,,,,,,,ADC_CH0
-58,GPIO3,GPIO3,GPIO3,,,,pDATA7(CAM_D3),,UART1_TX,,,,,,,,,,ADC_CH1
-59,GPIO4,GPIO4,GPIO4,,,,pDATA6(CAM_D2),,UART1_RX,,,,,,,,,,ADC_CH2
-60,GPIO5,GPIO5,GPIO5,,,,pDATA5(CAM_D1),,McAXR1,GT_CCP05,,,,,,,,,ADC_CH3
-61,GPIO6,GPIO6,GPIO6,,,UART1_CTS,pDATA4(CAM_D0),UART0_RTS,UART0_CTS,GT_CCP06,,,,,,,,,
-62,GPIO7,GPIO7,GPIO7,,,UART1_RTS,,,,,,,UART0_RTS,UART0_TX,,McACLKX,,,
-63,GPIO8,GPIO8,GPIO8,,,,,,SDCARD_IRQ,McAFSX,,,,,GT_CCP06,,,,
-64,GPIO9,GPIO9,GPIO9,,,GT_PWM05,,,SDCARD_DATA,McAXR0,,,,,GT_CCP00,,,,
+57,GP2,GP2,GP2,,,UART0_RX,,,UART1_RX,TIM1_CC,,,,,,,,,ADC0_CH0
+58,GP3,GP3,GP3,,,,pDATA7(CAM_D3),,UART1_TX,,,,,,,,,,ADC0_CH1
+59,GP4,GP4,GP4,,,,pDATA6(CAM_D2),,UART1_RX,,,,,,,,,,ADC0_CH2
+60,GP5,GP5,GP5,,,,pDATA5(CAM_D1),,I2S0_DAT1,TIM2_CC,,,,,,,,,ADC0_CH3
+61,GP6,GP6,GP6,,,UART1_CTS,pDATA4(CAM_D0),UART0_RTS,UART0_CTS,TIM3_CC,,,,,,,,,
+62,GP7,GP7,GP7,,,UART1_RTS,,,,,,,UART0_RTS,UART0_TX,,I2S0_CLK,,,
+63,GP8,GP8,GP8,,,,,,SD0_IRQ,I2S0_FS,,,,,TIM3_CC,,,,
+64,GP9,GP9,GP9,,,TIM2_PWM,,,SD0_DAT0,I2S0_DAT0,,,,,TIM0_CC,,,,
 65,GND_TAB,GND_TAB,GND_TAB,,,,,,,,,,,,,,,,
--- a/cc3200/boards/cc3200_prefix.c
+++ b/cc3200/boards/cc3200_prefix.c
@@ -39,16 +39,31 @@
 #include "pybpin.h"


-#define PIN(p_pin_name, p_port, p_bit, p_pin_num) \
+#define AF(af_name, af_idx, af_fn, af_unit, af_type) \
+{ \
+    .name = MP_QSTR_ ## af_name, \
+    .idx = (af_idx), \
+    .fn = PIN_FN_ ## af_fn, \
+    .unit = (af_unit), \
+    .type = PIN_TYPE_ ## af_fn ## _ ## af_type, \
+}
+
+
+#define PIN(p_pin_name, p_port, p_bit, p_pin_num, p_af_list, p_num_afs) \
 { \
    { &pin_type }, \
-    .name     = MP_QSTR_ ## p_pin_name, \
-    .port     = PORT_A ## p_port, \
-    .type     = PIN_TYPE_STD, \
-    .bit      = (p_bit), \
-    .pin_num  = (p_pin_num), \
-    .af       = PIN_MODE_0, \
-    .strength = PIN_STRENGTH_4MA, \
-    .mode     = GPIO_DIR_MODE_IN, \
-    .isused   = false, \
+    .name           = MP_QSTR_ ## p_pin_name, \
+    .port           = PORT_A ## p_port, \
+    .af_list        = (p_af_list), \
+    .pull           = PIN_TYPE_STD, \
+    .bit            = (p_bit), \
+    .pin_num        = (p_pin_num), \
+    .af             = PIN_MODE_0, \
+    .strength       = PIN_STRENGTH_4MA, \
+    .mode           = GPIO_DIR_MODE_IN, \
+    .num_afs        = (p_num_afs), \
+    .value          = 0, \
+    .used           = false, \
+    .irq_trigger    = 0, \
+    .irq_flags      = 0, \
 }
--- a/cc3200/boards/make-pins.py
+++ b/cc3200/boards/make-pins.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-"""Generates the pins files for the CC3200."""
+"""Generates the pins file for the CC3200."""

 from __future__ import print_function

@@ -8,20 +8,44 @@ import sys
 import csv


+SUPPORTED_AFS = { 'UART': ('TX', 'RX', 'RTS', 'CTS'),
+                  'SPI': ('CLK', 'MOSI', 'MISO', 'CS0'),
+                  #'I2S': ('CLK', 'FS', 'DAT0', 'DAT1'),
+                  'I2C': ('SDA', 'SCL'),
+                  'TIM': ('PWM'),
+                  'SD': ('CLK', 'CMD', 'DAT0'),
+                  'ADC': ('CH0', 'CH1', 'CH2', 'CH3')
+                }
+
 def parse_port_pin(name_str):
    """Parses a string and returns a (port, gpio_bit) tuple."""
-    if len(name_str) < 5:
-        raise ValueError("Expecting pin name to be at least 5 characters")
-    if name_str[:4] != 'GPIO':
-        raise ValueError("Expecting pin name to start with GPIO")
-    if not name_str[4:].isdigit():
+    if len(name_str) < 3:
+        raise ValueError("Expecting pin name to be at least 3 characters")
+    if name_str[:2] != 'GP':
+        raise ValueError("Expecting pin name to start with GP")
+    if not name_str[2:].isdigit():
        raise ValueError("Expecting numeric GPIO number")
-    port = int(int(name_str[4:]) / 8)
-    gpio_bit = 1 << int(int(name_str[4:]) % 8)
+    port = int(int(name_str[2:]) / 8)
+    gpio_bit = 1 << int(int(name_str[2:]) % 8)
    return (port, gpio_bit)


-class Pin(object):
+class AF:
+    """Holds the description of an alternate function"""
+    def __init__(self, name, idx, fn, unit, type):
+        self.name = name
+        self.idx = idx
+        if self.idx > 15:
+            self.idx = -1
+        self.fn = fn
+        self.unit = unit
+        self.type = type
+
+    def print(self):
+        print ('    AF({:16s}, {:4d}, {:8s}, {:4d}, {:8s}),    // {}'.format(self.name, self.idx, self.fn, self.unit, self.type, self.name))
+
+
+class Pin:
    """Holds the information associated with a pin."""
    def __init__(self, name, port, gpio_bit, pin_num):
        self.name = name
@@ -29,45 +53,48 @@ class Pin(object):
        self.gpio_bit = gpio_bit
        self.pin_num = pin_num
        self.board_pin = False
+        self.afs = []

-    def cpu_pin_name(self):
-        return self.name  
-        
-    def is_board_pin(self):
-        return self.board_pin
-
-    def set_is_board_pin(self):
-        self.board_pin = True
+    def add_af(self, af):
+        self.afs.append(af)

    def print(self):
-        print('pin_obj_t pin_{:6s} = PIN({:6s}, {:1d}, {:3d}, {:2d});'.format(
-               self.name, self.name, self.port, self.gpio_bit, self.pin_num))
+        print('// {}'.format(self.name))
+        if len(self.afs):
+            print('const pin_af_t pin_{}_af[] = {{'.format(self.name))
+            for af in self.afs:
+                af.print()
+            print('};')
+            print('pin_obj_t pin_{:4s} = PIN({:6s}, {:1d}, {:3d}, {:2d}, pin_{}_af, {});\n'.format(
+                   self.name, self.name, self.port, self.gpio_bit, self.pin_num, self.name, len(self.afs)))
+        else:
+            print('pin_obj_t pin_{:4s} = PIN({:6s}, {:1d}, {:3d}, {:2d}, NULL, 0);\n'.format(
+                   self.name, self.name, self.port, self.gpio_bit, self.pin_num))

    def print_header(self, hdr_file):
        hdr_file.write('extern pin_obj_t pin_{:s};\n'.format(self.name))


-class Pins(object):
-
+class Pins:
    def __init__(self):
-        self.cpu_pins = []   # list of pin objects
+        self.board_pins = []   # list of pin objects

    def find_pin(self, port, gpio_bit):
-        for pin in self.cpu_pins:
+        for pin in self.board_pins:
            if pin.port == port and pin.gpio_bit == gpio_bit:
                return pin

    def find_pin_by_num(self, pin_num):
-        for pin in self.cpu_pins:
+        for pin in self.board_pins:
            if pin.pin_num == pin_num:
                return pin

    def find_pin_by_name(self, name):
-        for pin in self.cpu_pins:
+        for pin in self.board_pins:
            if pin.name == name:
                return pin

-    def parse_af_file(self, filename, pin_col, pinname_col):
+    def parse_af_file(self, filename, pin_col, pinname_col, af_start_col):
        with open(filename, 'r') as csvfile:
            rows = csv.reader(csvfile)
            for row in rows:
@@ -76,11 +103,21 @@ class Pins(object):
                except:
                    continue
                if not row[pin_col].isdigit():
-                    raise ValueError("Invalid pin number:  {:s} in row {:s}".format(row[pin_col]), row)
+                    raise ValueError("Invalid pin number {:s} in row {:s}".format(row[pin_col]), row)
                # Pin numbers must start from 0 when used with the TI API
                pin_num = int(row[pin_col]) - 1;        
                pin = Pin(row[pinname_col], port_num, gpio_bit, pin_num)
-                self.cpu_pins.append(pin)
+                self.board_pins.append(pin)
+                af_idx = 0
+                for af in row[af_start_col:]:
+                    af_splitted = af.split('_')
+                    fn_name = af_splitted[0].rstrip('0123456789')
+                    if  fn_name in SUPPORTED_AFS:
+                        type_name = af_splitted[1]
+                        if type_name in SUPPORTED_AFS[fn_name]:
+                            unit_idx = af_splitted[0][-1]
+                            pin.add_af(AF(af, af_idx, fn_name, int(unit_idx), type_name))
+                    af_idx += 1

    def parse_board_file(self, filename, cpu_pin_col):
        with open(filename, 'r') as csvfile:
@@ -92,37 +129,44 @@ class Pins(object):
                else:
                    pin = self.find_pin_by_name(row[cpu_pin_col])
                if pin:
-                    pin.set_is_board_pin()
+                    pin.board_pin = True

    def print_named(self, label, pins):
        print('')
        print('STATIC const mp_map_elem_t pin_{:s}_pins_locals_dict_table[] = {{'.format(label))
        for pin in pins:
-            if pin.is_board_pin():
-                print('  {{ MP_OBJ_NEW_QSTR(MP_QSTR_{:6s}), (mp_obj_t)&pin_{:6s} }},'.format(pin.cpu_pin_name(),  pin.cpu_pin_name()))
+            if pin.board_pin:
+                print('    {{ MP_OBJ_NEW_QSTR(MP_QSTR_{:6s}), (mp_obj_t)&pin_{:6s} }},'.format(pin.name, pin.name))
        print('};')
        print('MP_DEFINE_CONST_DICT(pin_{:s}_pins_locals_dict, pin_{:s}_pins_locals_dict_table);'.format(label, label));

    def print(self):
-        for pin in self.cpu_pins:
-            if pin.is_board_pin():
+        for pin in self.board_pins:
+            if pin.board_pin:
                pin.print()
-        self.print_named('cpu', self.cpu_pins)
+        self.print_named('board', self.board_pins)
        print('')

    def print_header(self, hdr_filename):
        with open(hdr_filename, 'wt') as hdr_file:
-            for pin in self.cpu_pins:
-                if pin.is_board_pin():
+            for pin in self.board_pins:
+                if pin.board_pin:
                    pin.print_header(hdr_file)

    def print_qstr(self, qstr_filename):
        with open(qstr_filename, 'wt') as qstr_file:
-            qstr_set = set([])
-            for pin in self.cpu_pins:
-                if pin.is_board_pin():
-                    qstr_set |= set([pin.cpu_pin_name()])
-            for qstr in sorted(qstr_set):
+            pin_qstr_set = set([])
+            af_qstr_set = set([])
+            for pin in self.board_pins:
+                if pin.board_pin:
+                    pin_qstr_set |= set([pin.name])
+                    for af in pin.afs:
+                        af_qstr_set |= set([af.name])
+            print('// Board pins', file=qstr_file)
+            for qstr in sorted(pin_qstr_set):
+                print('Q({})'.format(qstr), file=qstr_file)
+            print('\n// Pin AFs', file=qstr_file)
+            for qstr in sorted(af_qstr_set):
                print('Q({})'.format(qstr), file=qstr_file)


@@ -169,12 +213,12 @@ def main():
    print('//')
    if args.af_filename:
        print('// --af {:s}'.format(args.af_filename))
-        pins.parse_af_file(args.af_filename, 0, 1)
+        pins.parse_af_file(args.af_filename, 0, 1, 3)

    if args.board_filename:
        print('// --board {:s}'.format(args.board_filename))
-        pins.parse_board_file(args.board_filename, 1)    
-        
+        pins.parse_board_file(args.board_filename, 1)
+
    if args.prefix_filename:
        print('// --prefix {:s}'.format(args.prefix_filename))
        print('')
--- a/cc3200/bootmgr/bootgen.sh
+++ b/cc3200/bootmgr/bootgen.sh
@@ -1,19 +1,17 @@
 #!/bin/bash

-if [ "$#" -ne 2 ]; then
-    echo "Usage: bootgen.sh *board type* *build type*"
+if [ "$#" -ne 1 ]; then
+    echo "Usage: bootgen.sh *build dir*"
    exit 1
 fi

-BOARD=$1
-BTYPE=$2
+BUILD=$1

 # Re-locator Path
 RELOCATOR=bootmgr/relocator

-# Boot Manager Path
-# First parameter passed is the board type
-BOOTMGR=bootmgr/build/${BOARD}/${BTYPE}
+# Build location
+BOOTMGR=${BUILD}

 # Check for re-locator binary
 if [ ! -f $RELOCATOR/relocator.bin ]; then
--- a/cc3200/bootmgr/bootloader.mk
+++ b/cc3200/bootmgr/bootloader.mk
@@ -19,6 +19,7 @@ BOOT_CPPDEFINES = -Dgcc -DBOOTLOADER -DTARGET_IS_CC3200 -DSL_TINY
 BOOT_HAL_SRC_C = $(addprefix hal/,\
 	cpu.c \
 	interrupt.c \
+	gpio.c \
 	pin.c \
 	prcm.c \
 	shamd5.c \
@@ -42,6 +43,7 @@ BOOT_CC3100_SRC_C = $(addprefix drivers/cc3100/,\
 	)

 BOOT_MISC_SRC_C = $(addprefix misc/,\
+	antenna.c \
 	mperror.c \
 	)

@@ -50,7 +52,7 @@ BOOT_SL_SRC_C = $(addprefix simplelink/,\
 	)

 BOOT_UTIL_SRC_C = $(addprefix util/,\
-	hash.c \
+	cryptohash.c \
 	) 

 BOOT_MAIN_SRC_C = \
@@ -63,16 +65,13 @@ BOOT_PY_SRC_C = $(addprefix py/,\
 	mpprint.c \
 	)

-BOOT_STM_SRC_C = $(addprefix stmhal/,\
-	printf.c \
-	)
-
 BOOT_LIB_SRC_C = $(addprefix lib/,\
 	libc/string0.c \
+	utils/printf.c \
 	)

 OBJ  = $(addprefix $(BUILD)/, $(BOOT_HAL_SRC_C:.c=.o) $(BOOT_SL_SRC_C:.c=.o) $(BOOT_CC3100_SRC_C:.c=.o) $(BOOT_UTIL_SRC_C:.c=.o) $(BOOT_MISC_SRC_C:.c=.o))
-OBJ += $(addprefix $(BUILD)/, $(BOOT_MAIN_SRC_C:.c=.o) $(BOOT_MAIN_SRC_S:.s=.o) $(BOOT_PY_SRC_C:.c=.o) $(BOOT_STM_SRC_C:.c=.o))
+OBJ += $(addprefix $(BUILD)/, $(BOOT_MAIN_SRC_C:.c=.o) $(BOOT_MAIN_SRC_S:.s=.o) $(BOOT_PY_SRC_C:.c=.o))
 OBJ += $(addprefix $(BUILD)/, $(BOOT_LIB_SRC_C:.c=.o))

 # Add the linker script
@@ -122,12 +121,12 @@ $(BUILD)/bootmgr.bin: $(BUILD)/bootmgr.axf

 $(BUILD)/bootloader.bin: $(BUILD)/bootmgr.bin
 	$(ECHO) "Create $@"
-	$(Q)$(SHELL) $(BOOT_GEN) $(BOARD) $(BTYPE)
+	$(Q)$(SHELL) $(BOOT_GEN) $(BUILD)

 # Create an empty "qstrdefs.generated.h" needed by py/mkrules.mk
 $(HEADER_BUILD)/qstrdefs.generated.h: | $(HEADER_BUILD)
 	touch $@

-# Create an empty "py-version.h" needed by py/mkrules.mk
-$(HEADER_BUILD)/py-version.h: | $(HEADER_BUILD)
+# Create an empty "mpversion.h" needed by py/mkrules.mk
+$(HEADER_BUILD)/mpversion.h: | $(HEADER_BUILD)
 	touch $@
--- a/cc3200/bootmgr/bootmgr.lds
+++ b/cc3200/bootmgr/bootmgr.lds
@@ -39,6 +39,7 @@ SECTIONS
    {
        _text = .;
        KEEP(*(.intvecs))
+        *(.boot*)
        *(.text*)
        *(.rodata*)
        *(.ARM.extab* .gnu.linkonce.armextab.*)
--- a/cc3200/bootmgr/flc.h
+++ b/cc3200/bootmgr/flc.h
@@ -43,23 +43,31 @@ extern "C"
 *******************************************************************************/
 #define IMG_BOOT_INFO           "/sys/bootinfo.bin"
 #define IMG_FACTORY             "/sys/factimg.bin"
-#define IMG_UPDATE              "/sys/updtimg.bin"
+#define IMG_UPDATE1             "/sys/updtimg1.bin"
+#define IMG_UPDATE2             "/sys/updtimg2.bin"
+#define IMG_PREFIX              "/sys/updtimg"

 #define IMG_SRVPACK             "/sys/servicepack.ucf"
 #define SRVPACK_SIGN            "/sys/servicepack.sig"

+#define CA_FILE                 "/cert/ca.pem"
+#define CERT_FILE               "/cert/cert.pem"
+#define KEY_FILE                "/cert/private.key"
+
 /******************************************************************************
-   Image file sizes
+   Special file sizes
 *******************************************************************************/
-#define IMG_SIZE                (232 * 1024)    /* 16KB are reserved for the bootloader and at least 8KB for the heap*/
+#define IMG_SIZE                (192 * 1024)    /* 16KB are reserved for the bootloader and at least 48KB for the heap*/
 #define SRVPACK_SIZE            (16  * 1024)
 #define SIGN_SIZE               (2   * 1024)
+#define CA_KEY_SIZE             (4   * 1024)

 /******************************************************************************
   Active Image
 *******************************************************************************/
 #define IMG_ACT_FACTORY         0
-#define IMG_ACT_UPDATE          1
+#define IMG_ACT_UPDATE1         1
+#define IMG_ACT_UPDATE2         2

 #define IMG_STATUS_CHECK        0
 #define IMG_STATUS_READY        1
@@ -67,13 +75,13 @@ extern "C"
 /******************************************************************************
   Boot Info structure
 *******************************************************************************/
-typedef struct sBootInfo
+typedef struct _sBootInfo_t
 {
  _u8  ActiveImg;
  _u8  Status;
+  _u8  PrevImg;
  _u8  : 8;
-  _u8  : 8;
-}sBootInfo_t;
+} sBootInfo_t;


 /******************************************************************************
--- a/cc3200/bootmgr/main.c
+++ b/cc3200/bootmgr/main.c
@@ -26,10 +26,10 @@

 #include <stdint.h>
 #include <stdbool.h>
+
 #include "std.h"

 #include "py/mpconfig.h"
-#include MICROPY_HAL_H
 #include "hw_ints.h"
 #include "hw_types.h"
 #include "hw_gpio.h"
@@ -38,7 +38,6 @@
 #include "hw_common_reg.h"
 #include "pin.h"
 #include "gpio.h"
-#include "rom.h"
 #include "rom_map.h"
 #include "prcm.h"
 #include "simplelink.h"
@@ -47,11 +46,12 @@
 #include "flc.h"
 #include "bootmgr.h"
 #include "shamd5.h"
-#include "hash.h"
+#include "cryptohash.h"
 #include "utils.h"
 #include "cc3200_hal.h"
 #include "debug.h"
 #include "mperror.h"
+#include "antenna.h"


 //*****************************************************************************
@@ -62,11 +62,16 @@
 #define BOOTMGR_HASH_SIZE                   32
 #define BOOTMGR_BUFF_SIZE                   512

-#define BOOTMGR_WAIT_SAFE_MODE_MS           1600
-#define BOOTMGR_WAIT_SAFE_MODE_TOOGLE_MS    200
+#define BOOTMGR_WAIT_SAFE_MODE_0_MS         500

-#define BOOTMGR_SAFE_MODE_ENTER_MS          800
-#define BOOTMGR_SAFE_MODE_ENTER_TOOGLE_MS   80
+#define BOOTMGR_WAIT_SAFE_MODE_1_MS         3000
+#define BOOTMGR_WAIT_SAFE_MODE_1_BLINK_MS   500
+
+#define BOOTMGR_WAIT_SAFE_MODE_2_MS         3000
+#define BOOTMGR_WAIT_SAFE_MODE_2_BLINK_MS   250
+
+#define BOOTMGR_WAIT_SAFE_MODE_3_MS         1500
+#define BOOTMGR_WAIT_SAFE_MODE_3_BLINK_MS   100

 //*****************************************************************************
 // Exported functions declarations
@@ -77,9 +82,11 @@ extern void bootmgr_run_app (_u32 base);
 // Local functions declarations
 //*****************************************************************************
 static void bootmgr_board_init (void);
-static bool bootmgr_verify (void);
+static bool bootmgr_verify (_u8 *image);
 static void bootmgr_load_and_execute (_u8 *image);
-static bool safe_mode_boot (void);
+static bool wait_while_blinking (uint32_t wait_time, uint32_t period, bool force_wait);
+static bool safe_boot_request_start (uint32_t wait_time);
+static void wait_for_safe_boot (sBootInfo_t *psBootInfo);
 static void bootmgr_image_loader (sBootInfo_t *psBootInfo);

 //*****************************************************************************
@@ -138,44 +145,52 @@ void SimpleLinkSockEventHandler(SlSockEvent_t *pSock)
 //! Board Initialization & Configuration
 //*****************************************************************************
 static void bootmgr_board_init(void) {
-    // Set vector table base
+    // set the vector table base
    MAP_IntVTableBaseSet((unsigned long)&g_pfnVectors[0]);

-    // Enable Processor Interrupts
+    // enable processor interrupts
    MAP_IntMasterEnable();
    MAP_IntEnable(FAULT_SYSTICK);

-    // Mandatory MCU Initialization
+    // mandatory MCU initialization
    PRCMCC3200MCUInit();

+    // clear all the special bits, since we can't trust their content after reset
+    // except for the WDT reset one!!
+    PRCMClearSpecialBit(PRCM_SAFE_BOOT_BIT);
+    PRCMClearSpecialBit(PRCM_FIRST_BOOT_BIT);
+
+    // check the reset after clearing the special bits
    mperror_bootloader_check_reset_cause();

-    // Enable the Data Hashing Engine
-    HASH_Init();
+#if MICROPY_HW_ANTENNA_DIVERSITY
+    // configure the antenna selection pins
+    antenna_init0();
+#endif

-    // Init the system led and the system switch
+    // enable the data hashing engine
+    CRYPTOHASH_Init();
+
+    // init the system led and the system switch
    mperror_init0();
-
-    // clear the safe boot flag, since we can't trust its content after reset
-    PRCMClearSafeBootRequest();
 }

 //*****************************************************************************
 //! Verifies the integrity of the new application binary
 //*****************************************************************************
-static bool bootmgr_verify (void) {
+static bool bootmgr_verify (_u8 *image) {
    SlFsFileInfo_t FsFileInfo;
    _u32 reqlen, offset = 0;
    _i32 fHandle;

    // open the file for reading
-    if (0 == sl_FsOpen((_u8 *)IMG_UPDATE, FS_MODE_OPEN_READ, NULL, &fHandle)) {
+    if (0 == sl_FsOpen(image, FS_MODE_OPEN_READ, NULL, &fHandle)) {
        // get the file size
-        sl_FsGetInfo((_u8 *)IMG_UPDATE, 0, &FsFileInfo);
+        sl_FsGetInfo(image, 0, &FsFileInfo);

        if (FsFileInfo.FileLen > BOOTMGR_HASH_SIZE) {
            FsFileInfo.FileLen -= BOOTMGR_HASH_SIZE;
-            HASH_SHAMD5Start(BOOTMGR_HASH_ALGO, FsFileInfo.FileLen);
+            CRYPTOHASH_SHAMD5Start(BOOTMGR_HASH_ALGO, FsFileInfo.FileLen);
            do {
                if ((FsFileInfo.FileLen - offset) > BOOTMGR_BUFF_SIZE) {
                    reqlen = BOOTMGR_BUFF_SIZE;
@@ -185,10 +200,10 @@ static bool bootmgr_verify (void) {
                }

                offset += sl_FsRead(fHandle, offset, bootmgr_file_buf, reqlen);
-                HASH_SHAMD5Update(bootmgr_file_buf, reqlen);
+                CRYPTOHASH_SHAMD5Update(bootmgr_file_buf, reqlen);
            } while (offset < FsFileInfo.FileLen);

-            HASH_SHAMD5Read (bootmgr_file_buf);
+            CRYPTOHASH_SHAMD5Read (bootmgr_file_buf);

            // convert the resulting hash to hex
            for (_u32 i = 0; i < (BOOTMGR_HASH_SIZE / 2); i++) {
@@ -235,47 +250,81 @@ static void bootmgr_load_and_execute (_u8 *image) {
 }

 //*****************************************************************************
-//! Check for the safe mode pin
+//! Wait while the safe mode pin is being held high and blink the system led
+//! with the specified period
 //*****************************************************************************
-static bool safe_mode_boot (void) {
-    _u32 count = 0;
-    while (MAP_GPIOPinRead(MICROPY_SAFE_BOOT_PORT, MICROPY_SAFE_BOOT_PORT_PIN) &&
-           ((BOOTMGR_WAIT_SAFE_MODE_TOOGLE_MS * count++) < BOOTMGR_WAIT_SAFE_MODE_MS)) {
+static bool wait_while_blinking (uint32_t wait_time, uint32_t period, bool force_wait) {
+    _u32 count;
+    for (count = 0; (force_wait || MAP_GPIOPinRead(MICROPY_SAFE_BOOT_PORT, MICROPY_SAFE_BOOT_PORT_PIN)) &&
+         ((period * count) < wait_time); count++) {
        // toogle the led
        MAP_GPIOPinWrite(MICROPY_SYS_LED_PORT, MICROPY_SYS_LED_PORT_PIN, ~MAP_GPIOPinRead(MICROPY_SYS_LED_PORT, MICROPY_SYS_LED_PORT_PIN));
-        UtilsDelay(UTILS_DELAY_US_TO_COUNT(BOOTMGR_WAIT_SAFE_MODE_TOOGLE_MS * 1000));
+        UtilsDelay(UTILS_DELAY_US_TO_COUNT(period * 1000));
+    }
+    return MAP_GPIOPinRead(MICROPY_SAFE_BOOT_PORT, MICROPY_SAFE_BOOT_PORT_PIN) ? true : false;
+}
+
+static bool safe_boot_request_start (uint32_t wait_time) {
+    if (MAP_GPIOPinRead(MICROPY_SAFE_BOOT_PORT, MICROPY_SAFE_BOOT_PORT_PIN)) {
+        UtilsDelay(UTILS_DELAY_US_TO_COUNT(wait_time * 1000));
    }
-    mperror_deinit_sfe_pin();
    return MAP_GPIOPinRead(MICROPY_SAFE_BOOT_PORT, MICROPY_SAFE_BOOT_PORT_PIN) ? true : false;
 }

 //*****************************************************************************
-//! Load the proper image based on information from boot info and executes it.
+//! Check for the safe mode pin
+//*****************************************************************************
+static void wait_for_safe_boot (sBootInfo_t *psBootInfo) {
+    if (safe_boot_request_start(BOOTMGR_WAIT_SAFE_MODE_0_MS)) {
+        if (wait_while_blinking(BOOTMGR_WAIT_SAFE_MODE_1_MS, BOOTMGR_WAIT_SAFE_MODE_1_BLINK_MS, false)) {
+            // go back one step in time
+            psBootInfo->ActiveImg = psBootInfo->PrevImg;
+            if (wait_while_blinking(BOOTMGR_WAIT_SAFE_MODE_2_MS, BOOTMGR_WAIT_SAFE_MODE_2_BLINK_MS, false)) {
+                // go back directly to the factory image
+                psBootInfo->ActiveImg = IMG_ACT_FACTORY;
+                wait_while_blinking(BOOTMGR_WAIT_SAFE_MODE_3_MS, BOOTMGR_WAIT_SAFE_MODE_3_BLINK_MS, true);
+            }
+        }
+        // turn off the system led
+        MAP_GPIOPinWrite(MICROPY_SYS_LED_PORT, MICROPY_SYS_LED_PORT_PIN, 0);
+        // request a safe boot to the application
+        PRCMSetSpecialBit(PRCM_SAFE_BOOT_BIT);
+    }
+    // deinit the safe boot pin
+    mperror_deinit_sfe_pin();
+}
+
+//*****************************************************************************
+//! Load the proper image based on the information from the boot info
+//! and launch it.
 //*****************************************************************************
 static void bootmgr_image_loader(sBootInfo_t *psBootInfo) {
    _i32 fhandle;
-    if (safe_mode_boot()) {
-         _u32 count = 0;
-         while ((BOOTMGR_SAFE_MODE_ENTER_TOOGLE_MS * count++) < BOOTMGR_SAFE_MODE_ENTER_MS) {
-             // toogle the led
-             MAP_GPIOPinWrite(MICROPY_SYS_LED_PORT, MICROPY_SYS_LED_PORT_PIN, ~MAP_GPIOPinRead(MICROPY_SYS_LED_PORT, MICROPY_SYS_LED_PORT_PIN));
-             UtilsDelay(UTILS_DELAY_US_TO_COUNT(BOOTMGR_SAFE_MODE_ENTER_TOOGLE_MS * 1000));
-         }
-         psBootInfo->ActiveImg = IMG_ACT_FACTORY;
-         // turn the led off
-         MAP_GPIOPinWrite(MICROPY_SYS_LED_PORT, MICROPY_SYS_LED_PORT_PIN, 0);
-         // request a safe boot to the application
-         PRCMRequestSafeBoot();
+    _u8 *image;
+
+    // search for the active image
+    switch (psBootInfo->ActiveImg) {
+    case IMG_ACT_UPDATE1:
+        image = (unsigned char *)IMG_UPDATE1;
+        break;
+    case IMG_ACT_UPDATE2:
+        image = (unsigned char *)IMG_UPDATE2;
+        break;
+    default:
+        image = (unsigned char *)IMG_FACTORY;
+        break;
    }
-    // do we have a new update image that needs to be verified?
-    else if ((psBootInfo->ActiveImg == IMG_ACT_UPDATE) && (psBootInfo->Status == IMG_STATUS_CHECK)) {
-        if (!bootmgr_verify()) {
-            // delete the corrupted file
-            sl_FsDel((_u8 *)IMG_UPDATE, 0);
-            // switch to the factory image
-            psBootInfo->ActiveImg = IMG_ACT_FACTORY;
+
+    // do we have a new image that needs to be verified?
+    if ((psBootInfo->ActiveImg != IMG_ACT_FACTORY) && (psBootInfo->Status == IMG_STATUS_CHECK)) {
+        if (!bootmgr_verify(image)) {
+            // verification failed, delete the broken file
+            sl_FsDel(image, 0);
+            // switch to the previous image
+            psBootInfo->ActiveImg = psBootInfo->PrevImg;
+            psBootInfo->PrevImg = IMG_ACT_FACTORY;
        }
-        // in any case, set the status as "READY"
+        // in any case, change the status to "READY"
        psBootInfo->Status = IMG_STATUS_READY;
        // write the new boot info
        if (!sl_FsOpen((unsigned char *)IMG_BOOT_INFO, FS_MODE_OPEN_WRITE, NULL, &fhandle)) {
@@ -285,24 +334,34 @@ static void bootmgr_image_loader(sBootInfo_t *psBootInfo) {
        }
    }

-    // now boot the active image
-    if (IMG_ACT_UPDATE == psBootInfo->ActiveImg) {
-        bootmgr_load_and_execute((unsigned char *)IMG_UPDATE);
-    }
-    else {
-        bootmgr_load_and_execute((unsigned char *)IMG_FACTORY);
+    // this one might modify the boot info hence it MUST be called after
+    // bootmgr_verify! (so that the changes are not saved to flash)
+    wait_for_safe_boot(psBootInfo);
+
+    // select the active image again, since it might have changed
+    switch (psBootInfo->ActiveImg) {
+    case IMG_ACT_UPDATE1:
+        image = (unsigned char *)IMG_UPDATE1;
+        break;
+    case IMG_ACT_UPDATE2:
+        image = (unsigned char *)IMG_UPDATE2;
+        break;
+    default:
+        image = (unsigned char *)IMG_FACTORY;
+        break;
    }
+    bootmgr_load_and_execute(image);
 }

 //*****************************************************************************
 //! Main function
 //*****************************************************************************
 int main (void) {
-    sBootInfo_t sBootInfo = { .ActiveImg = IMG_ACT_FACTORY, .Status = IMG_STATUS_READY };
+    sBootInfo_t sBootInfo = { .ActiveImg = IMG_ACT_FACTORY, .Status = IMG_STATUS_READY, .PrevImg = IMG_ACT_FACTORY };
    bool bootapp = false;
    _i32 fhandle;

-    // Board Initialization
+    // board setup
    bootmgr_board_init();

    // start simplelink since we need it to access the sflash
@@ -315,17 +374,20 @@ int main (void) {
        }
        sl_FsClose(fhandle, 0, 0, 0);
    }
+    // boot info file not present, it means that this is the first boot after being programmed
    if (!bootapp) {
        // create a new boot info file
        _u32 BootInfoCreateFlag  = _FS_FILE_OPEN_FLAG_COMMIT | _FS_FILE_PUBLIC_WRITE | _FS_FILE_PUBLIC_READ;
        if (!sl_FsOpen ((unsigned char *)IMG_BOOT_INFO, FS_MODE_OPEN_CREATE((2 * sizeof(sBootInfo_t)),
                        BootInfoCreateFlag), NULL, &fhandle)) {
-            // Write the default boot info.
+            // write the default boot info.
            if (sizeof(sBootInfo_t) == sl_FsWrite(fhandle, 0, (unsigned char *)&sBootInfo, sizeof(sBootInfo_t))) {
                bootapp = true;
            }
            sl_FsClose(fhandle, 0, 0, 0);
        }
+        // signal the first boot to the application
+        PRCMSetSpecialBit(PRCM_FIRST_BOOT_BIT);
    }

    if (bootapp) {
@@ -336,14 +398,14 @@ int main (void) {
    // stop simplelink
    sl_Stop(SL_STOP_TIMEOUT);

-    // if we've reached this point, then it means a fatal error occurred and the application
-    // could not be loaded, so, loop forever and signal the crash to the user
+    // if we've reached this point, then it means that a fatal error has occurred and the
+    // application could not be loaded, so, loop forever and signal the crash to the user
    while (true) {
        // keep the bld on
        MAP_GPIOPinWrite(MICROPY_SYS_LED_PORT, MICROPY_SYS_LED_PORT_PIN, MICROPY_SYS_LED_PORT_PIN);
-        __asm volatile("    dsb      \n"
-                       "    isb      \n"
-                       "    wfi      \n");
+        __asm volatile(" dsb \n"
+                       " isb \n"
+                       " wfi \n");
    }
 }

@@ -352,7 +414,7 @@ int main (void) {
 //*****************************************************************************
 #include "py/qstr.h"

-const byte *qstr_data(qstr q, mp_uint_t *len) {
+const byte *qstr_data(qstr q, size_t *len) {
    *len = 0;
    return NULL;
 }
--- a/cc3200/fatfs/src/diskio.c
+++ b/cc3200/fatfs/src/diskio.c
@@ -10,21 +10,21 @@
 #include <stdbool.h>

 #include "py/mpconfig.h"
-#include "diskio.h"		        /* FatFs lower layer API */
+#include "py/runtime.h"
+#include "py/obj.h"
+#include "lib/fatfs/ff.h"
+#include "lib/fatfs/diskio.h"   /* FatFs lower layer API */
 #include "sflash_diskio.h"      /* Serial flash disk IO API */
-#if MICROPY_HW_HAS_SDCARD
-#include "sd_diskio.h"		    /* SDCARD disk IO API */
-#endif
-#include "modutime.h"
+#include "sd_diskio.h"          /* SDCARD disk IO API */
 #include "inc/hw_types.h"
 #include "inc/hw_ints.h"
 #include "inc/hw_memmap.h"
 #include "rom_map.h"
 #include "prcm.h"
-
-/* Definitions of physical drive number for each drive */
-#define SFLASH		0	/* Map SFLASH drive to drive number 0 */
-#define SDCARD	    1	/* Map SD card to drive number 1 */
+#include "pybrtc.h"
+#include "timeutils.h"
+#include "pybsd.h"
+#include "moduos.h"


 /*-----------------------------------------------------------------------*/
@@ -35,21 +35,20 @@ DSTATUS disk_status (
 	BYTE pdrv		/* Physical drive nmuber to identify the drive */
 )
 {
-	switch (pdrv) {
-	case SFLASH :
-	    return sflash_disk_status();
-#if MICROPY_HW_HAS_SDCARD
-	case SDCARD :
-	    return sd_disk_status();
-#endif
-	default:
-	    break;
-	}
-	return STA_NODISK;
+    if (pdrv == PD_FLASH) {
+        return sflash_disk_status();
+    } else {
+        os_fs_mount_t *mount_obj;
+        if ((mount_obj = osmount_find_by_volume(pdrv))) {
+            if (mount_obj->writeblocks[0] == MP_OBJ_NULL) {
+                return STA_PROTECT;
+            }
+            return 0;
+        }
+    }
+    return STA_NODISK;
 }

-
-
 /*-----------------------------------------------------------------------*/
 /* Inidialize a Drive                                                    */
 /*-----------------------------------------------------------------------*/
@@ -58,29 +57,22 @@ DSTATUS disk_initialize (
 	BYTE pdrv				/* Physical drive nmuber to identify the drive */
 )
 {
-	DSTATUS stat = 0;
-
-	switch (pdrv) {
-	case SFLASH :
-		if (RES_OK != sflash_disk_init()) {
-		    stat = STA_NOINIT;
-		}
-		return stat;
-#if MICROPY_HW_HAS_SDCARD
-    case SDCARD :
-        if (RES_OK != sd_disk_init()) {
-            stat = STA_NOINIT;
+    if (pdrv == PD_FLASH) {
+        if (RES_OK != sflash_disk_init()) {
+            return STA_NOINIT;
        }
-        return stat;
-#endif
-    default:
-        break;
-	}
-	return STA_NOINIT;
+    } else {
+        os_fs_mount_t *mount_obj;
+        if ((mount_obj = osmount_find_by_volume(pdrv))) {
+            if (mount_obj->writeblocks[0] == MP_OBJ_NULL) {
+                return STA_PROTECT;
+            }
+            return 0;
+        }
+    }
+    return STA_NODISK;
 }

-
-
 /*-----------------------------------------------------------------------*/
 /* Read Sector(s)                                                        */
 /*-----------------------------------------------------------------------*/
@@ -92,22 +84,25 @@ DRESULT disk_read (
 	UINT count		/* Number of sectors to read */
 )
 {
-	switch (pdrv) {
-	case SFLASH :
-	    return sflash_disk_read(buff, sector, count);
-#if MICROPY_HW_HAS_SDCARD
-    case SDCARD :
-        return sd_disk_read(buff, sector, count);
-#endif
-    default:
-        break;
-	}
-
-	return RES_PARERR;
+    if (pdrv == PD_FLASH) {
+        return sflash_disk_read(buff, sector, count);
+    } else {
+        os_fs_mount_t *mount_obj;
+        if ((mount_obj = osmount_find_by_volume(pdrv))) {
+            // optimization for the built-in sd card device
+            if (mount_obj->device == (mp_obj_t)&pybsd_obj) {
+                return sd_disk_read(buff, sector, count);
+            }
+            mount_obj->readblocks[2] = MP_OBJ_NEW_SMALL_INT(sector);
+            mount_obj->readblocks[3] = mp_obj_new_bytearray_by_ref(count * 512, buff);
+            return mp_obj_get_int(mp_call_method_n_kw(2, 0, mount_obj->readblocks));
+        }
+        // nothing mounted
+        return RES_ERROR;
+    }
+    return RES_PARERR;
 }

-
-
 /*-----------------------------------------------------------------------*/
 /* Write Sector(s)                                                       */
 /*-----------------------------------------------------------------------*/
@@ -120,18 +115,23 @@ DRESULT disk_write (
 	UINT count			/* Number of sectors to write */
 )
 {
-	switch (pdrv) {
-	case SFLASH :
-		return sflash_disk_write(buff, sector, count);
-#if MICROPY_HW_HAS_SDCARD
-    case SDCARD :
-        return sd_disk_write(buff, sector, count);
-#endif
-    default:
-        break;
-	}
-
-	return RES_PARERR;
+    if (pdrv == PD_FLASH) {
+        return sflash_disk_write(buff, sector, count);
+    } else {
+        os_fs_mount_t *mount_obj;
+        if ((mount_obj = osmount_find_by_volume(pdrv))) {
+            // optimization for the built-in sd card device
+            if (mount_obj->device == (mp_obj_t)&pybsd_obj) {
+                return sd_disk_write(buff, sector, count);
+            }
+            mount_obj->writeblocks[2] = MP_OBJ_NEW_SMALL_INT(sector);
+            mount_obj->writeblocks[3] = mp_obj_new_bytearray_by_ref(count * 512, (void *)buff);
+            return mp_obj_get_int(mp_call_method_n_kw(2, 0, mount_obj->writeblocks));
+        }
+        // nothing mounted
+        return RES_ERROR;
+    }
+    return RES_PARERR;
 }
 #endif

@@ -147,41 +147,47 @@ DRESULT disk_ioctl (
 	void *buff		/* Buffer to send/receive control data */
 )
 {
-    switch (pdrv) {
-    case SFLASH:
+    if (pdrv == PD_FLASH) {
        switch (cmd) {
        case CTRL_SYNC:
            return sflash_disk_flush();
        case GET_SECTOR_COUNT:
            *((DWORD*)buff) = SFLASH_SECTOR_COUNT;
            return RES_OK;
-            break;
        case GET_SECTOR_SIZE:
-            *((WORD*)buff) = SFLASH_SECTOR_SIZE;
+            *((DWORD*)buff) = SFLASH_SECTOR_SIZE;
            return RES_OK;
-            break;
        case GET_BLOCK_SIZE:
            *((DWORD*)buff) = 1; // high-level sector erase size in units of the block size
            return RES_OK;
        }
-        break;
-#if MICROPY_HW_HAS_SDCARD
-    case SDCARD:
-        switch (cmd) {
-        case CTRL_SYNC:
-            return RES_OK;
-        case GET_SECTOR_COUNT:
-            *(WORD*)buff = sd_disk_info.ulNofBlock;
-            break;
-        case GET_SECTOR_SIZE :
-            *(WORD*)buff = SD_SECTOR_SIZE;
-            break;
-        case GET_BLOCK_SIZE:
-            *((DWORD*)buff) = 1; // high-level sector erase size in units of the block size
-            return RES_OK;
+    } else {
+        os_fs_mount_t *mount_obj;
+        if ((mount_obj = osmount_find_by_volume(pdrv))) {
+            switch (cmd) {
+            case CTRL_SYNC:
+                if (mount_obj->sync[0] != MP_OBJ_NULL) {
+                    mp_call_method_n_kw(0, 0, mount_obj->sync);
+                }
+                return RES_OK;
+            case GET_SECTOR_COUNT:
+                // optimization for the built-in sd card device
+                if (mount_obj->device == (mp_obj_t)&pybsd_obj) {
+                    *((DWORD*)buff) = sd_disk_info.ulNofBlock * (sd_disk_info.ulBlockSize / 512);
+                } else {
+                    *((DWORD*)buff) = mp_obj_get_int(mp_call_method_n_kw(0, 0, mount_obj->count));
+                }
+                return RES_OK;
+            case GET_SECTOR_SIZE:
+                *((DWORD*)buff) = SD_SECTOR_SIZE;  // Sector size is fixed to 512 bytes, as with SD cards
+                return RES_OK;
+            case GET_BLOCK_SIZE:
+                *((DWORD*)buff) = 1; // high-level sector erase size in units of the block size
+                return RES_OK;
+            }
        }
-        break;
-#endif
+        // nothing mounted
+        return RES_ERROR;
    }
    return RES_PARERR;
 }
@@ -192,13 +198,8 @@ DWORD get_fattime (
    void
 )
 {
-    mod_struct_time tm;
-    uint32_t seconds;
-    uint16_t mseconds;
-
-    // Get the time from the on-chip RTC and convert it to struct_time
-    MAP_PRCMRTCGet(&seconds, &mseconds);
-    mod_time_seconds_since_2000_to_struct_time(seconds, &tm);
+    timeutils_struct_time_t tm;
+    timeutils_seconds_since_2000_to_struct_time(pyb_rtc_get_seconds(), &tm);

    return ((tm.tm_year - 1980) << 25) | ((tm.tm_mon) << 21)  |
            ((tm.tm_mday) << 16)       | ((tm.tm_hour) << 11) |
--- a/cc3200/fatfs/src/diskio.h
+++ b/cc3200/fatfs/src/diskio.h
@@ -1,62 +0,0 @@
-/*-----------------------------------------------------------------------/
-/  Low level disk interface modlue include file   (C)ChaN, 2014          /
-/-----------------------------------------------------------------------*/
-
-#ifndef _DISKIO_DEFINED
-#define _DISKIO_DEFINED
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define _USE_WRITE	1	/* 1: Enable disk_write function */
-#define _USE_IOCTL	1	/* 1: Enable disk_ioctl fucntion */
-
-#include "integer.h"
-
-
-/* Status of Disk Functions */
-typedef BYTE	DSTATUS;
-
-/* Results of Disk Functions */
-typedef enum {
-	RES_OK = 0,		/* 0: Successful */
-	RES_ERROR,		/* 1: R/W Error */
-	RES_WRPRT,		/* 2: Write Protected */
-	RES_NOTRDY,		/* 3: Not Ready */
-	RES_PARERR		/* 4: Invalid Parameter */
-} DRESULT;
-
-
-/*---------------------------------------*/
-/* Prototypes for disk control functions */
-
-
-DSTATUS disk_initialize (BYTE pdrv);
-DSTATUS disk_status (BYTE pdrv);
-DRESULT disk_read (BYTE pdrv, BYTE* buff, DWORD sector, UINT count);
-DRESULT disk_write (BYTE pdrv, const BYTE* buff, DWORD sector, UINT count);
-DRESULT disk_ioctl (BYTE pdrv, BYTE cmd, void* buff);
-
-
-/* Disk Status Bits (DSTATUS) */
-
-#define STA_NOINIT		0x01	/* Drive not initialized */
-#define STA_NODISK		0x02	/* No medium in the drive */
-#define STA_PROTECT		0x04	/* Write protected */
-
-
-/* Command code for disk_ioctrl fucntion */
-
-/* Generic command (Used by FatFs) */
-#define CTRL_SYNC			0	/* Complete pending write process (needed at _FS_READONLY == 0) */
-#define GET_SECTOR_COUNT	1	/* Get media size (needed at _USE_MKFS == 1) */
-#define GET_SECTOR_SIZE		2	/* Get sector size (needed at _MAX_SS != _MIN_SS) */
-#define GET_BLOCK_SIZE		3	/* Get erase block size (needed at _USE_MKFS == 1) */
-#define CTRL_TRIM			4	/* Inform device that the data on the block of sectors is no longer used (needed at _USE_TRIM == 1) */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
--- a/cc3200/fatfs/src/drivers/sd_diskio.c
+++ b/cc3200/fatfs/src/drivers/sd_diskio.c
@@ -38,11 +38,10 @@
 #include <stdbool.h>

 #include "py/mpconfig.h"
-#include MICROPY_HAL_H
+#include "py/mphal.h"
 #include "hw_types.h"
 #include "hw_memmap.h"
 #include "hw_ints.h"
-#include "rom.h"
 #include "rom_map.h"
 #include "diskio.h"
 #include "sd_diskio.h"
@@ -187,7 +186,7 @@ static unsigned int CardSelect (DiskInfo_t *sDiskInfo) {
    }

    // Delay 250ms for the card to become ready
-    HAL_Delay (250);
+    mp_hal_delay_ms(250);

    return ulRet;
 }
@@ -279,8 +278,6 @@ DSTATUS sd_disk_init (void) {
                sd_disk_info.bStatus = 0;
            }
        }
-        // Set card rd/wr block len
-        MAP_SDHostBlockSizeSet(SDHOST_BASE, SD_SECTOR_SIZE);
    }

    return sd_disk_info.bStatus;
@@ -302,28 +299,6 @@ void sd_disk_deinit (void) {
    sd_disk_info.usRCA = 0;
 }

-//*****************************************************************************
-//
-//! Gets the disk status.
-//!
-//! This function gets the current status of the drive.
-//!
-//! \return Returns the current status of the specified drive
-//
-//*****************************************************************************
-DSTATUS sd_disk_status (void) {
-    return sd_disk_info.bStatus;
-}
-
-//*****************************************************************************
-//
-//! Returns wether the sd card is ready to be accessed or not
-//
-//*****************************************************************************
-bool sd_disk_ready (void) {
-    return (!sd_disk_info.bStatus);
-}
-
 //*****************************************************************************
 //
 //! Reads sector(s) from the disk drive.
@@ -376,6 +351,7 @@ DRESULT sd_disk_read (BYTE* pBuffer, DWORD ulSectorNumber, UINT SectorCount) {
                    pBuffer += 4;
                }
                CardSendCmd(CMD_STOP_TRANS, 0);
+                while (!(MAP_SDHostIntStatus(SDHOST_BASE) & SDHOST_INT_TC));
                Res = RES_OK;
            }
        }
@@ -395,61 +371,62 @@ DRESULT sd_disk_read (BYTE* pBuffer, DWORD ulSectorNumber, UINT SectorCount) {
 //
 //*****************************************************************************
 DRESULT sd_disk_write (const BYTE* pBuffer, DWORD ulSectorNumber, UINT SectorCount) {
-  DRESULT Res = RES_ERROR;
-  unsigned long ulSize;
+    DRESULT Res = RES_ERROR;
+    unsigned long ulSize;

-  if (SectorCount > 0) {
-      // Return if disk not initialized
-      if (sd_disk_info.bStatus & STA_NOINIT) {
-          return RES_NOTRDY;
-      }
+    if (SectorCount > 0) {
+        // Return if disk not initialized
+        if (sd_disk_info.bStatus & STA_NOINIT) {
+            return RES_NOTRDY;
+        }

-      // SDSC uses linear address, SDHC uses block address
-      if (sd_disk_info.ulCapClass == CARD_CAP_CLASS_SDSC) {
-          ulSectorNumber = ulSectorNumber * SD_SECTOR_SIZE;
-      }
+        // SDSC uses linear address, SDHC uses block address
+        if (sd_disk_info.ulCapClass == CARD_CAP_CLASS_SDSC) {
+            ulSectorNumber = ulSectorNumber * SD_SECTOR_SIZE;
+        }

-      // Set the block count
-      MAP_SDHostBlockCountSet(SDHOST_BASE, SectorCount);
+        // Set the block count
+        MAP_SDHostBlockCountSet(SDHOST_BASE, SectorCount);

-      // Compute the number of words
-      ulSize = (SD_SECTOR_SIZE * SectorCount) / 4;
+        // Compute the number of words
+        ulSize = (SD_SECTOR_SIZE * SectorCount) / 4;

-      // Check if 1 block or multi block transfer
-      if (SectorCount == 1) {
-          // Send single block write command
-          if (CardSendCmd(CMD_WRITE_SINGLE_BLK, ulSectorNumber) == 0) {
-              // Write the data
-              while (ulSize--) {
-                  MAP_SDHostDataWrite (SDHOST_BASE, (*(unsigned long *)pBuffer));
-                  pBuffer += 4;
-              }
-              // Wait for data transfer complete
-              while (!(MAP_SDHostIntStatus(SDHOST_BASE) & SDHOST_INT_TC));
-              Res = RES_OK;
-          }
-      }
-      else {
-          // Set the card write block count
-          if (sd_disk_info.ucCardType == CARD_TYPE_SDCARD) {
-              CardSendCmd(CMD_APP_CMD,sd_disk_info.usRCA << 16);
-              CardSendCmd(CMD_SET_BLK_CNT, SectorCount);
-          }
+        // Check if 1 block or multi block transfer
+        if (SectorCount == 1) {
+            // Send single block write command
+            if (CardSendCmd(CMD_WRITE_SINGLE_BLK, ulSectorNumber) == 0) {
+                // Write the data
+                while (ulSize--) {
+                    MAP_SDHostDataWrite (SDHOST_BASE, (*(unsigned long *)pBuffer));
+                    pBuffer += 4;
+                }
+                // Wait for data transfer complete
+                while (!(MAP_SDHostIntStatus(SDHOST_BASE) & SDHOST_INT_TC));
+                Res = RES_OK;
+            }
+        }
+        else {
+            // Set the card write block count
+            if (sd_disk_info.ucCardType == CARD_TYPE_SDCARD) {
+                CardSendCmd(CMD_APP_CMD,sd_disk_info.usRCA << 16);
+                CardSendCmd(CMD_SET_BLK_CNT, SectorCount);
+            }

-          // Send multi block write command
-          if (CardSendCmd(CMD_WRITE_MULTI_BLK, ulSectorNumber) == 0) {
-              // Write the data buffer
-              while (ulSize--) {
-                  MAP_SDHostDataWrite(SDHOST_BASE, (*(unsigned long *)pBuffer));
-                  pBuffer += 4;
-              }
-              // Wait for transfer complete
-              while (!(MAP_SDHostIntStatus(SDHOST_BASE) & SDHOST_INT_TC));
-              CardSendCmd(CMD_STOP_TRANS, 0);
-              Res = RES_OK;
-          }
-      }
-  }
+            // Send multi block write command
+            if (CardSendCmd(CMD_WRITE_MULTI_BLK, ulSectorNumber) == 0) {
+                // Write the data buffer
+                while (ulSize--) {
+                    MAP_SDHostDataWrite(SDHOST_BASE, (*(unsigned long *)pBuffer));
+                    pBuffer += 4;
+                }
+                // Wait for transfer complete
+                while (!(MAP_SDHostIntStatus(SDHOST_BASE) & SDHOST_INT_TC));
+                CardSendCmd(CMD_STOP_TRANS, 0);
+                while (!(MAP_SDHostIntStatus(SDHOST_BASE) & SDHOST_INT_TC));
+                Res = RES_OK;
+            }
+        }
+    }

-  return Res;
+    return Res;
 }
--- a/cc3200/fatfs/src/drivers/sd_diskio.h
+++ b/cc3200/fatfs/src/drivers/sd_diskio.h
@@ -21,8 +21,6 @@ extern DiskInfo_t sd_disk_info;

 DSTATUS sd_disk_init (void);
 void sd_disk_deinit (void);
-DSTATUS sd_disk_status (void);
-bool sd_disk_ready (void);
 DRESULT sd_disk_read (BYTE* pBuffer, DWORD ulSectorNumber, UINT bSectorCount);
 DRESULT sd_disk_write (const BYTE* pBuffer, DWORD ulSectorNumber, UINT bSectorCount);

--- a/cc3200/fatfs/src/drivers/sflash_diskio.c
+++ b/cc3200/fatfs/src/drivers/sflash_diskio.c
@@ -3,11 +3,12 @@
 #include "std.h"

 #include "py/mpconfig.h"
-#include MICROPY_HAL_H
+#include "py/obj.h"
 #include "simplelink.h"
 #include "diskio.h"
 #include "sflash_diskio.h"
 #include "debug.h"
+#include "modnetwork.h"
 #include "modwlan.h"

 #define SFLASH_TIMEOUT_MAX_MS               5500
@@ -52,13 +53,25 @@ DRESULT sflash_disk_init (void) {
        // Allocate space for the block cache
        ASSERT ((sflash_block_cache = mem_Malloc(SFLASH_BLOCK_SIZE)) != NULL);
        sflash_init_done = true;
+        sflash_prblock = UINT32_MAX;
+        sflash_cache_is_dirty = false;

-        // Proceed to format the memory if not done yet
+        // In order too speed up booting, check the last block, if exists, then
+        // it means that the file system has been already created
+        print_block_name (SFLASH_BLOCK_COUNT - 1);
+        sl_LockObjLock (&wlan_LockObj, SL_OS_WAIT_FOREVER);
+        if (!sl_FsGetInfo(sflash_block_name, 0, &FsFileInfo)) {
+            sl_LockObjUnlock (&wlan_LockObj);
+            return RES_OK;
+        }
+        sl_LockObjUnlock (&wlan_LockObj);
+
+        // Proceed to format the memory
        for (int i = 0; i < SFLASH_BLOCK_COUNT; i++) {
            print_block_name (i);
            sl_LockObjLock (&wlan_LockObj, SL_OS_WAIT_FOREVER);
            // Create the block file if it doesn't exist
-            if (sl_FsGetInfo(sflash_block_name, 0, &FsFileInfo) < 0) {
+            if (sl_FsGetInfo(sflash_block_name, 0, &FsFileInfo) != 0) {
                if (!sl_FsOpen(sflash_block_name, FS_MODE_OPEN_CREATE(SFLASH_BLOCK_SIZE, 0), NULL, &fileHandle)) {
                    sl_FsClose(fileHandle, NULL, NULL, 0);
                    sl_LockObjUnlock (&wlan_LockObj);
@@ -75,8 +88,6 @@ DRESULT sflash_disk_init (void) {
            }
            sl_LockObjUnlock (&wlan_LockObj);
        }
-        sflash_prblock = UINT32_MAX;
-        sflash_cache_is_dirty = false;
    }
    return RES_OK;
 }
@@ -85,7 +96,7 @@ DRESULT sflash_disk_status(void) {
    if (!sflash_init_done) {
        return STA_NOINIT;
    }
-    return 0;
+    return RES_OK;
 }

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

--- a/cc3200/fatfs/src/ffconf.c
+++ b/cc3200/fatfs/src/ffconf.c
@@ -26,11 +26,11 @@

 #include <string.h>

-#include "py/mpconfig.h"
-#include "py/misc.h"
-#include "ff.h"
-#include "ffconf.h"
-#include "diskio.h"
+#include "py/mpstate.h"
+#include "lib/fatfs/ff.h"
+#include "lib/fatfs/ffconf.h"
+#include "lib/fatfs/diskio.h"
+#include "moduos.h"

 #if _FS_RPATH
 extern BYTE ff_CurrVol;
@@ -65,31 +65,29 @@ int ff_get_ldnumber (const TCHAR **path) {
    }

    if (check_path(path, "/flash", 6)) {
-        return 0;
+        return PD_FLASH;
    }
-#if MICROPY_HW_HAS_SDCARD
-    else if (check_path(path, "/sd", 3)) {
-        return 1;
-    }
-#endif
    else {
-        return -1;
+        for (mp_uint_t i = 0; i < MP_STATE_PORT(mount_obj_list).len; i++) {
+            os_fs_mount_t *mount_obj = ((os_fs_mount_t *)(MP_STATE_PORT(mount_obj_list).items[i]));
+            if (check_path(path, mount_obj->path, mount_obj->pathlen)) {
+                return mount_obj->vol;
+            }
+        }
    }
+
+    return -1;
 }

 void ff_get_volname(BYTE vol, TCHAR **dest) {
-#if MICROPY_HW_HAS_SDCARD
-    if (vol == 0)
-#endif
-    {
+    if (vol == PD_FLASH) {
        memcpy(*dest, "/flash", 6);
-        *dest += 7;
+        *dest += 6;
+    } else {
+        os_fs_mount_t *mount_obj;
+        if ((mount_obj = osmount_find_by_volume(vol))) {
+            memcpy(*dest, mount_obj->path, mount_obj->pathlen);
+            *dest += mount_obj->pathlen;
+        }
    }
-#if MICROPY_HW_HAS_SDCARD
-    else
-    {
-        memcpy(*dest, "/sd", 3);
-        *dest += 3;
-    }
-#endif
 }
--- a/cc3200/fatfs/src/ffconf.h
+++ b/cc3200/fatfs/src/ffconf.h
@@ -1,300 +0,0 @@
-/*
- * This file is part of the Micro Python project, http://micropython.org/
- *
- * Original file from:
- * FatFs - FAT file system module configuration file R0.10c (C)ChaN, 2014
- *
- * The MIT License (MIT)
- *
- * Copyright (c) 2013, 2014 Damien P. George
- * Copyright (c) 2015 Daniel Campora
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#ifndef _FFCONF
-#define _FFCONF 32020	/* Revision ID */
-
-#include <stdint.h>
-#include "py/mpconfig.h"
-#include "FreeRTOS.h"
-#include "task.h"
-#include "semphr.h"
-
-/*---------------------------------------------------------------------------/
-/ Functions and Buffer Configurations
-/---------------------------------------------------------------------------*/
-
-#define	_FS_TINY		1
-/* This option switches tiny buffer configuration. (0:Normal or 1:Tiny)
-/  At the tiny configuration, size of the file object (FIL) is reduced _MAX_SS
-/  bytes. Instead of private sector buffer eliminated from the file object,
-/  common sector buffer in the file system object (FATFS) is used for the file
-/  data transfer. */
-
-
-#define _FS_READONLY	0
-/* This option switches read-only configuration. (0:Read/Write or 1:Read-only)
-/  Read-only configuration removes writing API functions, f_write(), f_sync(),
-/  f_unlink(), f_mkdir(), f_chmod(), f_rename(), f_truncate(), f_getfree()
-/  and optional writing functions as well. */
-
-
-#define _FS_MINIMIZE	0
-/* This option defines minimization level to remove some API functions.
-/
-/   0: All basic functions are enabled.
-/   1: f_stat(), f_getfree(), f_unlink(), f_mkdir(), f_chmod(), f_utime(),
-/      f_truncate() and f_rename() function are removed.
-/   2: f_opendir(), f_readdir() and f_closedir() are removed in addition to 1.
-/   3: f_lseek() function is removed in addition to 2. */
-
-
-#define	_USE_STRFUNC	0
-/* This option switches string functions, f_gets(), f_putc(), f_puts() and
-/  f_printf().
-/
-/  0: Disable string functions.
-/  1: Enable without LF-CRLF conversion.
-/  2: Enable with LF-CRLF conversion. */
-
-
-#define _USE_FIND		0
-/* This option switches filtered directory read feature and related functions,
-/  f_findfirst() and f_findnext(). (0:Disable or 1:Enable) */
-
-
-#define	_USE_MKFS		1
-/* This option switches f_mkfs() function. (0:Disable or 1:Enable) */
-
-
-#define	_USE_FASTSEEK	0
-/* This option switches fast seek feature. (0:Disable or 1:Enable) */
-
-
-#define _USE_LABEL		0
-/* This option switches volume label functions, f_getlabel() and f_setlabel().
-/  (0:Disable or 1:Enable) */
-
-
-#define	_USE_FORWARD	0
-/* This option switches f_forward() function. (0:Disable or 1:Enable)
-/  To enable it, also _FS_TINY need to be set to 1. */
-
-
-/*---------------------------------------------------------------------------/
-/ Locale and Namespace Configurations
-/---------------------------------------------------------------------------*/
-
-#define _CODE_PAGE	(MICROPY_LFN_CODE_PAGE)
-/* This option specifies the OEM code page to be used on the target system.
-/  Incorrect setting of the code page can cause a file open failure.
-/
-/   1    - ASCII (No extended character. Non-LFN cfg. only)
-/   437  - U.S.
-/   720  - Arabic
-/   737  - Greek
-/   775  - Baltic
-/   850  - Multilingual Latin 1
-/   852  - Latin 2
-/   855  - Cyrillic
-/   857  - Turkish
-/   858  - Multilingual Latin 1 + Euro
-/   862  - Hebrew
-/   866  - Russian
-/   874  - Thai
-/   932  - Japanese Shift_JIS (DBCS)
-/   936  - Simplified Chinese GBK (DBCS)
-/   949  - Korean (DBCS)
-/   950  - Traditional Chinese Big5 (DBCS)
-*/
-
-
-#define	_USE_LFN	(MICROPY_ENABLE_LFN)
-#define	_MAX_LFN	(MICROPY_ALLOC_PATH_MAX)
-/* The _USE_LFN option switches the LFN feature.
-/
-/   0: Disable LFN feature. _MAX_LFN has no effect.
-/   1: Enable LFN with static working buffer on the BSS. Always NOT thread-safe.
-/   2: Enable LFN with dynamic working buffer on the STACK.
-/   3: Enable LFN with dynamic working buffer on the HEAP.
-/
-/  When enable the LFN feature, Unicode handling functions (option/unicode.c) must
-/  be added to the project. The LFN working buffer occupies (_MAX_LFN + 1) * 2 bytes.
-/  When use stack for the working buffer, take care on stack overflow. When use heap
-/  memory for the working buffer, memory management functions, ff_memalloc() and
-/  ff_memfree(), must be added to the project. */
-
-
-#define	_LFN_UNICODE	0
-/* This option switches character encoding on the API. (0:ANSI/OEM or 1:Unicode)
-/  To use Unicode string for the path name, enable LFN feature and set _LFN_UNICODE
-/  to 1. This option also affects behavior of string I/O functions. */
-
-
-#define _STRF_ENCODE	3
-/* When _LFN_UNICODE is 1, this option selects the character encoding on the file to
-/  be read/written via string I/O functions, f_gets(), f_putc(), f_puts and f_printf().
-/
-/  0: ANSI/OEM
-/  1: UTF-16LE
-/  2: UTF-16BE
-/  3: UTF-8
-/
-/  When _LFN_UNICODE is 0, this option has no effect. */
-
-
-#define _FS_RPATH	2
-/* This option configures relative path feature.
-/
-/   0: Disable relative path feature and remove related functions.
-/   1: Enable relative path feature. f_chdir() and f_chdrive() are available.
-/   2: f_getcwd() function is available in addition to 1.
-/
-/  Note that directory items read via f_readdir() are affected by this option. */
-
-
-/*---------------------------------------------------------------------------/
-/ Drive/Volume Configurations
-/---------------------------------------------------------------------------*/
-
-#define _VOLUMES	2
-/* Number of volumes (logical drives) to be used. */
-
-
-#define _STR_VOLUME_ID	0
-#define _VOLUME_STRS	"RAM","NAND","CF","SD1","SD2","USB1","USB2","USB3"
-/* _STR_VOLUME_ID option switches string volume ID feature.
-/  When _STR_VOLUME_ID is set to 1, also pre-defined strings can be used as drive
-/  number in the path name. _VOLUME_STRS defines the drive ID strings for each
-/  logical drives. Number of items must be equal to _VOLUMES. Valid characters for
-/  the drive ID strings are: A-Z and 0-9. */
-
-
-#define	_MULTI_PARTITION	0
-/* This option switches multi-partition feature. By default (0), each logical drive
-/  number is bound to the same physical drive number and only an FAT volume found on
-/  the physical drive will be mounted. When multi-partition feature is enabled (1),
-/  each logical drive number is bound to arbitrary physical drive and partition
-/  listed in the VolToPart[]. Also f_fdisk() funciton will be available. */
-
-
-#define	_MIN_SS		512
-#define	_MAX_SS		512
-/* These options configure the range of sector size to be supported. (512, 1024,
-/  2048 or 4096) Always set both 512 for most systems, all type of memory cards and
-/  harddisk. But a larger value may be required for on-board flash memory and some
-/  type of optical media. When _MAX_SS is larger than _MIN_SS, FatFs is configured
-/  to variable sector size and GET_SECTOR_SIZE command must be implemented to the
-/  disk_ioctl() function. */
-
-
-#define	_USE_TRIM	0
-/* This option switches ATA-TRIM feature. (0:Disable or 1:Enable)
-/  To enable Trim feature, also CTRL_TRIM command should be implemented to the
-/  disk_ioctl() function. */
-
-
-#define _FS_NOFSINFO	0
-/* If you need to know correct free space on the FAT32 volume, set bit 0 of this
-/  option, and f_getfree() function at first time after volume mount will force
-/  a full FAT scan. Bit 1 controls the use of last allocated cluster number.
-/
-/  bit0=0: Use free cluster count in the FSINFO if available.
-/  bit0=1: Do not trust free cluster count in the FSINFO.
-/  bit1=0: Use last allocated cluster number in the FSINFO if available.
-/  bit1=1: Do not trust last allocated cluster number in the FSINFO.
-*/
-
-
-
-/*---------------------------------------------------------------------------/
-/ System Configurations
-/---------------------------------------------------------------------------*/
-
-#define _FS_NORTC	0
-#define _NORTC_MON	2
-#define _NORTC_MDAY	1
-#define _NORTC_YEAR	2015
-/* The _FS_NORTC option switches timestamp feature. If the system does not have
-/  an RTC function or valid timestamp is not needed, set _FS_NORTC to 1 to disable
-/  the timestamp feature. All objects modified by FatFs will have a fixed timestamp
-/  defined by _NORTC_MON, _NORTC_MDAY and _NORTC_YEAR.
-/  When timestamp feature is enabled (_FS_NORTC	== 0), get_fattime() function need
-/  to be added to the project to read current time form RTC. _NORTC_MON,
-/  _NORTC_MDAY and _NORTC_YEAR have no effect. 
-/  These options have no effect at read-only configuration (_FS_READONLY == 1). */
-
-
-#define	_FS_LOCK	2
-/* The _FS_LOCK option switches file lock feature to control duplicated file open
-/  and illegal operation to open objects. This option must be 0 when _FS_READONLY
-/  is 1.
-/
-/  0:  Disable file lock feature. To avoid volume corruption, application program
-/      should avoid illegal open, remove and rename to the open objects.
-/  >0: Enable file lock feature. The value defines how many files/sub-directories
-/      can be opened simultaneously under file lock control. Note that the file
-/      lock feature is independent of re-entrancy. */
-
-
-#define _FS_REENTRANT	1
-#define _FS_TIMEOUT		2500    // milliseconds
-#define	_SYNC_t			SemaphoreHandle_t
-/* The _FS_REENTRANT option switches the re-entrancy (thread safe) of the FatFs
-/  module itself. Note that regardless of this option, file access to different
-/  volume is always re-entrant and volume control functions, f_mount(), f_mkfs()
-/  and f_fdisk() function, are always not re-entrant. Only file/directory access
-/  to the same volume is under control of this feature.
-/
-/   0: Disable re-entrancy. _FS_TIMEOUT and _SYNC_t have no effect.
-/   1: Enable re-entrancy. Also user provided synchronization handlers,
-/      ff_req_grant(), ff_rel_grant(), ff_del_syncobj() and ff_cre_syncobj()
-/      function, must be added to the project. Samples are available in
-/      option/syscall.c.
-/
-/  The _FS_TIMEOUT defines timeout period in unit of time tick.
-/  The _SYNC_t defines O/S dependent sync object type. e.g. HANDLE, ID, OS_EVENT*,
-/  SemaphoreHandle_t and etc.. */
-
-
-#define _WORD_ACCESS	0
-/* The _WORD_ACCESS option is an only platform dependent option. It defines
-/  which access method is used to the word data on the FAT volume.
-/
-/   0: Byte-by-byte access. Always compatible with all platforms.
-/   1: Word access. Do not choose this unless under both the following conditions.
-/
-/  * Address misaligned memory access is always allowed to ALL instructions.
-/  * Byte order on the memory is little-endian.
-/
-/  If it is the case, _WORD_ACCESS can also be set to 1 to reduce code size.
-/  Following table shows allowable settings of some processor types.
-/
-/   ARM7TDMI    0           ColdFire    0           V850E       0
-/   Cortex-M3   0           Z80         0/1         V850ES      0/1
-/   Cortex-M0   0           x86         0/1         TLCS-870    0/1
-/   AVR         0/1         RX600(LE)   0/1         TLCS-900    0/1
-/   AVR32       0           RL78        0           R32C        0
-/   PIC18       0/1         SH-2        0           M16C        0/1
-/   PIC24       0           H8S         0           MSP430      0
-/   PIC32       0           H8/300H     0           8051        0/1
-*/
-
-#endif // _FFCONF
--- a/cc3200/ftp/ftp.c
+++ b/cc3200/ftp/ftp.c
@@ -28,8 +28,7 @@
 #include <ctype.h>
 #include "std.h"

-#include "py/mpconfig.h"
-#include MICROPY_HAL_H
+#include "py/mpstate.h"
 #include "py/obj.h"
 #include "inc/hw_types.h"
 #include "inc/hw_ints.h"
@@ -39,17 +38,17 @@
 #include "pybrtc.h"
 #include "ftp.h"
 #include "simplelink.h"
+#include "modnetwork.h"
 #include "modwlan.h"
-#include "modutime.h"
+#include "modusocket.h"
 #include "debug.h"
 #include "serverstask.h"
 #include "ff.h"
 #include "fifo.h"
 #include "socketfifo.h"
-#include "diskio.h"
-#include "sd_diskio.h"
 #include "updater.h"
-
+#include "timeutils.h"
+#include "moduos.h"

 /******************************************************************************
 DEFINE PRIVATE CONSTANTS
@@ -67,7 +66,6 @@
 #define FTP_UNIX_TIME_20150101              1420070400
 #define FTP_UNIX_SECONDS_180_DAYS           15552000
 #define FTP_DATA_TIMEOUT_MS                 5000            // 5 seconds
-#define FTP_CMD_TIMEOUT_MS                  120000          // 2 minutes
 #define FTP_SOCKETFIFO_ELEMENTS_MAX         4
 #define FTP_CYCLE_TIME_MS                   (SERVERS_CYCLE_TIME_MS * 2)

@@ -94,16 +92,12 @@ typedef enum {
    E_FTP_STE_SUB_DISCONNECTED = 0,
    E_FTP_STE_SUB_LISTEN_FOR_DATA,
    E_FTP_STE_SUB_DATA_CONNECTED
-} ftp_data_substate_t;
-
-typedef union {
-    ftp_data_substate_t data;
 } ftp_substate_t;

 typedef struct {
    bool            uservalid : 1;
    bool            passvalid : 1;
-}ftp_loggin_t;
+} ftp_loggin_t;

 typedef enum {
    E_FTP_NOTHING_OPEN = 0,
@@ -129,25 +123,26 @@ typedef struct {
    int16_t             c_sd;
    int16_t             d_sd;
    int16_t             dtimeout;
-    ftp_state_t         state;
-    ftp_substate_t      substate;
+    uint16_t            volcount;
+    uint8_t             state;
+    uint8_t             substate;
    uint8_t             txRetries;
    uint8_t             logginRetries;
    ftp_loggin_t        loggin;
    uint8_t             e_open;
    bool                closechild;
    bool                enabled;
-    bool                swupdating;
-
+    bool                special_file;
+    bool                listroot;
 } ftp_data_t;

 typedef struct {
    char * cmd;
-}ftp_cmd_t;
+} ftp_cmd_t;

 typedef struct {
    char * month;
-}ftp_month_t;
+} ftp_month_t;

 typedef enum {
    E_FTP_CMD_NOT_SUPPORTED = -1,
@@ -174,7 +169,7 @@ typedef enum {
    E_FTP_CMD_NOOP,
    E_FTP_CMD_QUIT,
    E_FTP_NUM_FTP_CMDS
-}ftp_cmd_index_t;
+} ftp_cmd_index_t;

 /******************************************************************************
 DECLARE PRIVATE DATA
@@ -194,7 +189,7 @@ static const ftp_month_t ftp_month[] = { { "Jan" }, { "Feb" }, { "Mar" }, { "Apr
                                         { "May" }, { "Jun" }, { "Jul" }, { "Ago" },
                                         { "Sep" }, { "Oct" }, { "Nov" }, { "Dec" } };

-static SocketFifoElement_t *ftp_fifoelements;
+static SocketFifoElement_t ftp_fifoelements[FTP_SOCKETFIFO_ELEMENTS_MAX];
 static FIFO_t ftp_socketfifo;

 /******************************************************************************
@@ -219,12 +214,11 @@ static int ftp_print_eplf_drive (char *dest, uint32_t destsize, char *name);
 static bool ftp_open_file (const char *path, int mode);
 static ftp_result_t ftp_read_file (char *filebuf, uint32_t desiredsize, uint32_t *actualsize);
 static ftp_result_t ftp_write_file (char *filebuf, uint32_t size);
-static ftp_result_t ftp_open_dir_for_listing (const char *path, char *list, uint32_t maxlistsize, uint32_t *listsize);
+static ftp_result_t ftp_open_dir_for_listing (const char *path);
 static ftp_result_t ftp_list_dir (char *list, uint32_t maxlistsize, uint32_t *listsize);
 static void ftp_open_child (char *pwd, char *dir);
 static void ftp_close_child (char *pwd);
 static void ftp_return_to_previous_path (char *pwd, char *dir);
-static void ftp_reset (void);

 /******************************************************************************
 DEFINE PUBLIC FUNCTIONS
@@ -235,7 +229,6 @@ void ftp_init (void) {
    ASSERT ((ftp_path = mem_Malloc(FTP_MAX_PARAM_SIZE)) != NULL);
    ASSERT ((ftp_scratch_buffer = mem_Malloc(FTP_MAX_PARAM_SIZE)) != NULL);
    ASSERT ((ftp_cmd_buffer = mem_Malloc(FTP_MAX_PARAM_SIZE + FTP_CMD_SIZE_MAX)) != NULL);
-    ASSERT ((ftp_fifoelements = mem_Malloc(FTP_SOCKETFIFO_ELEMENTS_MAX * sizeof(SocketFifoElement_t))) != NULL);
    SOCKETFIFO_Init (&ftp_socketfifo, (void *)ftp_fifoelements, FTP_SOCKETFIFO_ELEMENTS_MAX);
    ftp_data.c_sd  = -1;
    ftp_data.d_sd  = -1;
@@ -243,8 +236,9 @@ void ftp_init (void) {
    ftp_data.ld_sd = -1;
    ftp_data.e_open = E_FTP_NOTHING_OPEN;
    ftp_data.state = E_FTP_STE_DISABLED;
-    ftp_data.substate.data = E_FTP_STE_SUB_DISCONNECTED;
-    ftp_data.swupdating = false;
+    ftp_data.substate = E_FTP_STE_SUB_DISCONNECTED;
+    ftp_data.special_file = false;
+    ftp_data.volcount = 0;
 }

 void ftp_run (void) {
@@ -253,12 +247,12 @@ void ftp_run (void) {
            ftp_wait_for_enabled();
            break;
        case E_FTP_STE_START:
-            if (ftp_create_listening_socket(&ftp_data.lc_sd, FTP_CMD_PORT, FTP_CMD_CLIENTS_MAX )) {
+            if (wlan_is_connected() && ftp_create_listening_socket(&ftp_data.lc_sd, FTP_CMD_PORT, FTP_CMD_CLIENTS_MAX - 1)) {
                ftp_data.state = E_FTP_STE_READY;
            }
            break;
        case E_FTP_STE_READY:
-            if (ftp_data.c_sd < 0 && ftp_data.substate.data == E_FTP_STE_SUB_DISCONNECTED) {
+            if (ftp_data.c_sd < 0 && ftp_data.substate == E_FTP_STE_SUB_DISCONNECTED) {
                if (E_FTP_RESULT_OK == ftp_wait_for_connection(ftp_data.lc_sd, &ftp_data.c_sd)) {
                    ftp_data.txRetries = 0;
                    ftp_data.logginRetries = 0;
@@ -271,7 +265,7 @@ void ftp_run (void) {
                }
            }
            if (SOCKETFIFO_IsEmpty()) {
-                if (ftp_data.c_sd > 0 && ftp_data.substate.data != E_FTP_STE_SUB_LISTEN_FOR_DATA) {
+                if (ftp_data.c_sd > 0 && ftp_data.substate != E_FTP_STE_SUB_LISTEN_FOR_DATA) {
                    ftp_process_cmd();
                    if (ftp_data.state != E_FTP_STE_READY) {
                        break;
@@ -288,8 +282,7 @@ void ftp_run (void) {
                ftp_list_dir((char *)ftp_data.dBuffer, FTP_BUFFER_SIZE, &listsize);
                if (listsize > 0) {
                    ftp_send_data(listsize);
-                }
-                else {
+                } else {
                    ftp_send_reply(226, NULL);
                    ftp_data.state = E_FTP_STE_END_TRANSFER;
                }
@@ -326,7 +319,7 @@ void ftp_run (void) {
                    ftp_data.dtimeout = 0;
                    ftp_data.ctimeout = 0;
                    // its a software update
-                    if (ftp_data.swupdating) {
+                    if (ftp_data.special_file) {
                        if (updater_write(ftp_data.dBuffer, len)) {
                            break;
                        }
@@ -346,8 +339,8 @@ void ftp_run (void) {
                    }
                }
                else {
-                    if (ftp_data.swupdating) {
-                        ftp_data.swupdating = false;
+                    if (ftp_data.special_file) {
+                        ftp_data.special_file = false;
                        updater_finnish();
                    }
                    ftp_close_files();
@@ -360,19 +353,19 @@ void ftp_run (void) {
            break;
    }

-    switch (ftp_data.substate.data) {
+    switch (ftp_data.substate) {
    case E_FTP_STE_SUB_DISCONNECTED:
        break;
    case E_FTP_STE_SUB_LISTEN_FOR_DATA:
        if (E_FTP_RESULT_OK == ftp_wait_for_connection(ftp_data.ld_sd, &ftp_data.d_sd)) {
            ftp_data.dtimeout = 0;
-            ftp_data.substate.data = E_FTP_STE_SUB_DATA_CONNECTED;
+            ftp_data.substate = E_FTP_STE_SUB_DATA_CONNECTED;
        }
        else if (ftp_data.dtimeout++ > FTP_DATA_TIMEOUT_MS / FTP_CYCLE_TIME_MS) {
            ftp_data.dtimeout = 0;
            // close the listening socket
            servers_close_socket(&ftp_data.ld_sd);
-            ftp_data.substate.data = E_FTP_STE_SUB_DISCONNECTED;
+            ftp_data.substate = E_FTP_STE_SUB_DISCONNECTED;
        }
        break;
    case E_FTP_STE_SUB_DATA_CONNECTED:
@@ -381,7 +374,7 @@ void ftp_run (void) {
            servers_close_socket(&ftp_data.ld_sd);
            servers_close_socket(&ftp_data.d_sd);
            ftp_close_filesystem_on_error ();
-            ftp_data.substate.data = E_FTP_STE_SUB_DISCONNECTED;
+            ftp_data.substate = E_FTP_STE_SUB_DISCONNECTED;
        }
        break;
    default:
@@ -393,7 +386,7 @@ void ftp_run (void) {

    // check the state of the data sockets
    if (ftp_data.d_sd < 0 && (ftp_data.state > E_FTP_STE_READY)) {
-        ftp_data.substate.data = E_FTP_STE_SUB_DISCONNECTED;
+        ftp_data.substate = E_FTP_STE_SUB_DISCONNECTED;
        ftp_data.state = E_FTP_STE_READY;
    }
 }
@@ -408,6 +401,17 @@ void ftp_disable (void) {
    ftp_data.state = E_FTP_STE_DISABLED;
 }

+void ftp_reset (void) {
+    // close all connections and start all over again
+    servers_close_socket(&ftp_data.lc_sd);
+    servers_close_socket(&ftp_data.ld_sd);
+    ftp_close_cmd_data();
+    ftp_data.state = E_FTP_STE_START;
+    ftp_data.substate = E_FTP_STE_SUB_DISCONNECTED;
+    ftp_data.volcount = 0;
+    SOCKETFIFO_Flush();
+}
+
 /******************************************************************************
 DEFINE PRIVATE FUNCTIONS
 ******************************************************************************/
@@ -429,21 +433,27 @@ static bool ftp_create_listening_socket (_i16 *sd, _u16 port, _u8 backlog) {
    _sd = *sd;

    if (_sd > 0) {
+        // add the new socket to the network administration
+        modusocket_socket_add(_sd, false);
+
        // Enable non-blocking mode
        nonBlockingOption.NonblockingEnabled = 1;
-        ASSERT (sl_SetSockOpt(_sd, SOL_SOCKET, SL_SO_NONBLOCKING, &nonBlockingOption, sizeof(nonBlockingOption)) == SL_SOC_OK);
+        ASSERT ((result = sl_SetSockOpt(_sd, SOL_SOCKET, SL_SO_NONBLOCKING, &nonBlockingOption, sizeof(nonBlockingOption))) == SL_SOC_OK);

        // Bind the socket to a port number
        sServerAddress.sin_family = AF_INET;
        sServerAddress.sin_addr.s_addr = INADDR_ANY;
        sServerAddress.sin_port = htons(port);

-        ASSERT (sl_Bind(_sd, (const SlSockAddr_t *)&sServerAddress, sizeof(sServerAddress)) == SL_SOC_OK);
+        ASSERT ((result |= sl_Bind(_sd, (const SlSockAddr_t *)&sServerAddress, sizeof(sServerAddress))) == SL_SOC_OK);

        // Start listening
-        ASSERT ((result = sl_Listen (_sd, backlog)) == SL_SOC_OK);
+        ASSERT ((result |= sl_Listen (_sd, backlog)) == SL_SOC_OK);

-        return (result == SL_SOC_OK) ? true : false;
+        if (result == SL_SOC_OK) {
+            return true;
+        }
+        servers_close_socket(sd);
    }
    return false;
 }
@@ -464,6 +474,9 @@ static ftp_result_t ftp_wait_for_connection (_i16 l_sd, _i16 *n_sd) {
        return E_FTP_RESULT_FAILED;
    }

+    // add the new socket to the network administration
+    modusocket_socket_add(_sd, false);
+
    // client connected, so go on
    return E_FTP_RESULT_OK;
 }
@@ -539,7 +552,7 @@ static void ftp_send_from_fifo (void) {
                        servers_close_socket(&ftp_data.ld_sd);
                        // this one is the command socket
                        servers_close_socket(fifoelement.sd);
-                        ftp_data.substate.data = E_FTP_STE_SUB_DISCONNECTED;
+                        ftp_data.substate = E_FTP_STE_SUB_DISCONNECTED;
                    }
                    ftp_close_filesystem_on_error();
                }
@@ -560,8 +573,8 @@ static void ftp_send_from_fifo (void) {
        // close the listening and the data sockets
        servers_close_socket(&ftp_data.ld_sd);
        servers_close_socket(&ftp_data.d_sd);
-        if (ftp_data.swupdating) {
-            ftp_data.swupdating = false;
+        if (ftp_data.special_file) {
+            ftp_data.special_file = false;
        }
    }
 }
@@ -589,7 +602,6 @@ static void ftp_process_cmd (void) {
    _i32 len;
    char *bufptr = (char *)ftp_cmd_buffer;
    ftp_result_t result;
-    uint32_t listsize;
    FRESULT fres;
    FILINFO fno;
 #if _USE_LFN
@@ -599,7 +611,7 @@ static void ftp_process_cmd (void) {

    ftp_data.closechild = false;
    // also use the reply buffer to receive new commands
-    if (E_FTP_RESULT_OK == (result = ftp_recv_non_blocking(ftp_data.c_sd, ftp_cmd_buffer, FTP_BUFFER_SIZE, &len))) {
+    if (E_FTP_RESULT_OK == (result = ftp_recv_non_blocking(ftp_data.c_sd, ftp_cmd_buffer, FTP_MAX_PARAM_SIZE + FTP_CMD_SIZE_MAX, &len))) {
        // bufptr is moved as commands are being popped
        ftp_cmd_index_t cmd = ftp_pop_command(&bufptr);
        if (!ftp_data.loggin.passvalid && (cmd != E_FTP_CMD_USER && cmd != E_FTP_CMD_PASS && cmd != E_FTP_CMD_QUIT)) {
@@ -671,7 +683,7 @@ static void ftp_process_cmd (void) {
        case E_FTP_CMD_USER:
            ftp_pop_param (&bufptr, ftp_scratch_buffer);
            if (!memcmp(ftp_scratch_buffer, servers_user, MAX(strlen(ftp_scratch_buffer), strlen(servers_user)))) {
-                ftp_data.loggin.uservalid = true;
+                ftp_data.loggin.uservalid = true && (strlen(servers_user) == strlen(ftp_scratch_buffer));
            }
            ftp_send_reply(331, NULL);
            break;
@@ -679,21 +691,22 @@ static void ftp_process_cmd (void) {
            ftp_pop_param (&bufptr, ftp_scratch_buffer);
            if (!memcmp(ftp_scratch_buffer, servers_pass, MAX(strlen(ftp_scratch_buffer), strlen(servers_pass))) &&
                    ftp_data.loggin.uservalid) {
-                ftp_data.loggin.passvalid = true;
-                ftp_send_reply(230, NULL);
-            }
-            else {
-                ftp_send_reply(530, NULL);
+                ftp_data.loggin.passvalid = true && (strlen(servers_pass) == strlen(ftp_scratch_buffer));
+                if (ftp_data.loggin.passvalid) {
+                    ftp_send_reply(230, NULL);
+                    break;
+                }
            }
+            ftp_send_reply(530, NULL);
            break;
        case E_FTP_CMD_PASV:
            {
                // some servers (e.g. google chrome) send PASV several times very quickly
                servers_close_socket(&ftp_data.d_sd);
-                ftp_data.substate.data = E_FTP_STE_SUB_DISCONNECTED;
+                ftp_data.substate = E_FTP_STE_SUB_DISCONNECTED;
                bool socketcreated = true;
                if (ftp_data.ld_sd < 0) {
-                    socketcreated = ftp_create_listening_socket(&ftp_data.ld_sd, FTP_PASIVE_DATA_PORT, FTP_DATA_CLIENTS_MAX);
+                    socketcreated = ftp_create_listening_socket(&ftp_data.ld_sd, FTP_PASIVE_DATA_PORT, FTP_DATA_CLIENTS_MAX - 1);
                }
                if (socketcreated) {
                    uint32_t ip;
@@ -702,7 +715,7 @@ static void ftp_process_cmd (void) {
                    wlan_get_ip(&ip);
                    snprintf((char *)ftp_data.dBuffer, FTP_BUFFER_SIZE, "(%u,%u,%u,%u,%u,%u)",
                             pip[3], pip[2], pip[1], pip[0], (FTP_PASIVE_DATA_PORT >> 8), (FTP_PASIVE_DATA_PORT & 0xFF));
-                    ftp_data.substate.data = E_FTP_STE_SUB_LISTEN_FOR_DATA;
+                    ftp_data.substate = E_FTP_STE_SUB_LISTEN_FOR_DATA;
                    ftp_send_reply(227, (char *)ftp_data.dBuffer);
                }
                else {
@@ -711,13 +724,7 @@ static void ftp_process_cmd (void) {
            }
            break;
        case E_FTP_CMD_LIST:
-            if ((result = ftp_open_dir_for_listing(ftp_path, (char *)ftp_data.dBuffer, FTP_BUFFER_SIZE, &listsize)) == E_FTP_RESULT_OK) {
-                ftp_data.state = E_FTP_STE_END_TRANSFER;
-                ftp_send_reply(150, NULL);
-                ftp_send_data(listsize);
-                ftp_send_reply(226, NULL);
-            }
-            else if (result == E_FTP_RESULT_CONTINUE) {
+            if (ftp_open_dir_for_listing(ftp_path) == E_FTP_RESULT_CONTINUE) {
                ftp_data.state = E_FTP_STE_CONTINUE_LISTING;
                ftp_send_reply(150, NULL);
            }
@@ -740,15 +747,14 @@ static void ftp_process_cmd (void) {
            ftp_get_param_and_open_child (&bufptr);
            // first check if a software update is being requested
            if (updater_check_path (ftp_path)) {
-                // start by erasing the previous status file
-                // must be done before starting the updater
-                f_unlink(ftp_path);
                if (updater_start()) {
-                    ftp_data.swupdating = true;
+                    ftp_data.special_file = true;
                    ftp_data.state = E_FTP_STE_CONTINUE_FILE_RX;
                    ftp_send_reply(150, NULL);
                }
                else {
+                    // to unlock the updater
+                    updater_finnish();
                    ftp_data.state = E_FTP_STE_END_TRANSFER;
                    ftp_send_reply(550, NULL);
                }
@@ -821,7 +827,7 @@ static void ftp_process_cmd (void) {
        }
    }
    else if (result == E_FTP_RESULT_CONTINUE) {
-        if (ftp_data.ctimeout++ > (FTP_CMD_TIMEOUT_MS / FTP_CYCLE_TIME_MS)) {
+        if (ftp_data.ctimeout++ > (servers_get_timeout() / FTP_CYCLE_TIME_MS)) {
            ftp_send_reply(221, NULL);
        }
    }
@@ -842,9 +848,9 @@ static void ftp_close_files (void) {

 static void ftp_close_filesystem_on_error (void) {
    ftp_close_files();
-    if (ftp_data.swupdating) {
+    if (ftp_data.special_file) {
        updater_finnish ();
-        ftp_data.swupdating = false;
+        ftp_data.special_file = false;
    }
 }

@@ -880,16 +886,15 @@ static int ftp_print_eplf_item (char *dest, uint32_t destsize, FILINFO *fno) {

    char *type = (fno->fattrib & AM_DIR) ? "d" : "-";
    uint32_t tseconds;
-    uint16_t mseconds;
    uint mindex = (((fno->fdate >> 5) & 0x0f) > 0) ? (((fno->fdate >> 5) & 0x0f) - 1) : 0;
    uint day = ((fno->fdate & 0x1f) > 0) ? (fno->fdate & 0x1f) : 1;
-    uint fseconds = mod_time_seconds_since_2000(1980 + ((fno->fdate >> 9) & 0x7f),
+    uint fseconds = timeutils_seconds_since_2000(1980 + ((fno->fdate >> 9) & 0x7f),
                                                        (fno->fdate >> 5) & 0x0f,
                                                        fno->fdate & 0x1f,
                                                        (fno->ftime >> 11) & 0x1f,
                                                        (fno->ftime >> 5) & 0x3f,
                                                        2 * (fno->ftime & 0x1f));
-    MAP_PRCMRTCGet(&tseconds, &mseconds);
+    tseconds = pyb_rtc_get_seconds();
    if (FTP_UNIX_SECONDS_180_DAYS < tseconds - fseconds) {
        return snprintf(dest, destsize, "%srw-rw-r--   1 root  root %9u %s %2u %5u %s\r\n",
                        type, (_u32)fno->fsize, ftp_month[mindex].month, day,
@@ -911,14 +916,13 @@ static int ftp_print_eplf_item (char *dest, uint32_t destsize, FILINFO *fno) {
 }

 static int ftp_print_eplf_drive (char *dest, uint32_t destsize, char *name) {
-    mod_struct_time tm;
+    timeutils_struct_time_t tm;
    uint32_t tseconds;
-    uint16_t mseconds;
    char *type = "d";

-    mod_time_seconds_since_2000_to_struct_time((FTP_UNIX_TIME_20150101 - FTP_UNIX_TIME_20000101), &tm);
+    timeutils_seconds_since_2000_to_struct_time((FTP_UNIX_TIME_20150101 - FTP_UNIX_TIME_20000101), &tm);

-    MAP_PRCMRTCGet(&tseconds, &mseconds);
+    tseconds = pyb_rtc_get_seconds();
    if (FTP_UNIX_SECONDS_180_DAYS < tseconds - (FTP_UNIX_TIME_20150101 - FTP_UNIX_TIME_20000101)) {
        return snprintf(dest, destsize, "%srw-rw-r--   1 root  root %9u %s %2u %5u %s\r\n",
                        type, 0, ftp_month[(tm.tm_mon - 1)].month, tm.tm_mday, tm.tm_year, name);
@@ -966,32 +970,25 @@ static ftp_result_t ftp_write_file (char *filebuf, uint32_t size) {
    return result;
 }

-static ftp_result_t ftp_open_dir_for_listing (const char *path, char *list, uint32_t maxlistsize, uint32_t *listsize) {
-    uint next = 0;
-    // "hack" to list root directory
+static ftp_result_t ftp_open_dir_for_listing (const char *path) {
+    // "hack" to detect the root directory
    if (path[0] == '/' && path[1] == '\0') {
-        next += ftp_print_eplf_drive((list + next), (maxlistsize - next), "flash");
-#if MICROPY_HW_HAS_SDCARD
-        if (sd_disk_ready()) {
-            next += ftp_print_eplf_drive((list + next), (maxlistsize - next), "sd");
+        ftp_data.listroot = true;
+    } else {
+        FRESULT res;
+        res = f_opendir(&ftp_data.dp, path);                       /* Open the directory */
+        if (res != FR_OK) {
+            return E_FTP_RESULT_FAILED;
        }
-#endif
-        *listsize = next;
-        return E_FTP_RESULT_OK;
+        ftp_data.e_open = E_FTP_DIR_OPEN;
+        ftp_data.listroot = false;
    }
-
-    FRESULT res;
-    res = f_opendir(&ftp_data.dp, path);                       /* Open the directory */
-    if (res != FR_OK) {
-        return E_FTP_RESULT_FAILED;
-    }
-    ftp_data.e_open = E_FTP_DIR_OPEN;
    return E_FTP_RESULT_CONTINUE;
 }

 static ftp_result_t ftp_list_dir (char *list, uint32_t maxlistsize, uint32_t *listsize) {
    uint next = 0;
-    uint count = 0;
+    uint listcount = 0;
    FRESULT res;
    ftp_result_t result = E_FTP_RESULT_CONTINUE;
    FILINFO fno;
@@ -1000,22 +997,40 @@ static ftp_result_t ftp_list_dir (char *list, uint32_t maxlistsize, uint32_t *li
    fno.lfsize = _MAX_LFN;

    // read up to 2 directory items
-    while (count < 2) {
+    while (listcount < 2) {
 #else
    // read up to 4 directory items
-    while (count < 4) {
+    while (listcount < 4) {
 #endif
-        res = f_readdir(&ftp_data.dp, &fno);                                                       /* Read a directory item */
-        if (res != FR_OK || fno.fname[0] == 0) {
-            result = E_FTP_RESULT_OK;
-            break;                                                                                 /* Break on error or end of dp */
-        }
-        if (fno.fname[0] == '.' && fno.fname[1] == 0) continue;                                    /* Ignore . entry */
-        if (fno.fname[0] == '.' && fno.fname[1] == '.' && fno.fname[2] == 0) continue;             /* Ignore .. entry */
+        if (ftp_data.listroot) {
+            // root directory "hack"
+            if (0 == ftp_data.volcount) {
+                next += ftp_print_eplf_drive((list + next), (maxlistsize - next), "flash");
+            } else if (ftp_data.volcount <= MP_STATE_PORT(mount_obj_list).len) {
+                os_fs_mount_t *mount_obj = ((os_fs_mount_t *)(MP_STATE_PORT(mount_obj_list).items[(ftp_data.volcount - 1)]));
+                next += ftp_print_eplf_drive((list + next), (maxlistsize - next), (char *)&mount_obj->path[1]);
+            } else {
+                if (!next) {
+                    // no volume found this time, we are done
+                    ftp_data.volcount = 0;
+                }
+                break;
+            }
+            ftp_data.volcount++;
+        } else {
+            // a "normal" directory
+            res = f_readdir(&ftp_data.dp, &fno);                                                       /* Read a directory item */
+            if (res != FR_OK || fno.fname[0] == 0) {
+                result = E_FTP_RESULT_OK;
+                break;                                                                                 /* Break on error or end of dp */
+            }
+            if (fno.fname[0] == '.' && fno.fname[1] == 0) continue;                                    /* Ignore . entry */
+            if (fno.fname[0] == '.' && fno.fname[1] == '.' && fno.fname[2] == 0) continue;             /* Ignore .. entry */

-        // add the entry to the list
-        next += ftp_print_eplf_item((list + next), (maxlistsize - next), &fno);
-        count++;
+            // add the entry to the list
+            next += ftp_print_eplf_item((list + next), (maxlistsize - next), &fno);
+        }
+        listcount++;
    }
    if (result == E_FTP_RESULT_OK) {
        ftp_close_files();
@@ -1030,8 +1045,7 @@ static ftp_result_t ftp_list_dir (char *list, uint32_t maxlistsize, uint32_t *li
 static void ftp_open_child (char *pwd, char *dir) {
    if (dir[0] == '/') {
        strcpy (pwd, dir);
-    }
-    else {
+    } else {
        if (strlen(pwd) > 1) {
            strcat (pwd, "/");
        }
@@ -1051,8 +1065,7 @@ static void ftp_close_child (char *pwd) {
    }
    if (len == 0) {
        strcpy (pwd, "/");
-    }
-    else {
+    } else {
        pwd[len] = '\0';
    }
 }
@@ -1065,19 +1078,9 @@ static void ftp_return_to_previous_path (char *pwd, char *dir) {
    else {
        if (newlen == 0) {
            strcpy (pwd, "/");
-        }
-        else {
+        } else {
            pwd[newlen] = '\0';
        }
    }
 }

-static void ftp_reset (void) {
-    // close all connections and start all over again
-    servers_close_socket(&ftp_data.lc_sd);
-    servers_close_socket(&ftp_data.ld_sd);
-    ftp_close_cmd_data();
-    ftp_data.state = E_FTP_STE_START;
-    ftp_data.substate.data = E_FTP_STE_SUB_DISCONNECTED;
-    SOCKETFIFO_Flush();
-}
--- a/cc3200/ftp/ftp.h
+++ b/cc3200/ftp/ftp.h
@@ -34,5 +34,6 @@ extern void ftp_init (void);
 extern void ftp_run (void);
 extern void ftp_enable (void);
 extern void ftp_disable (void);
+extern void ftp_reset (void);

 #endif /* FTP_H_ */
--- a/cc3200/ftp/updater.c
+++ b/cc3200/ftp/updater.c
@@ -1,14 +1,42 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 Daniel Campora
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
 #include <stdint.h>
 #include <stdbool.h>

 #include "py/mpconfig.h"
-#include MICROPY_HAL_H
+#include "py/obj.h"
 #include "simplelink.h"
 #include "flc.h"
 #include "updater.h"
 #include "shamd5.h"
+#include "modnetwork.h"
 #include "modwlan.h"
 #include "debug.h"
+#include "osi.h"

 /******************************************************************************
 DEFINE PRIVATE CONSTANTS
@@ -16,6 +44,9 @@
 #define UPDATER_IMG_PATH            "/flash/sys/mcuimg.bin"
 #define UPDATER_SRVPACK_PATH        "/flash/sys/servicepack.ucf"
 #define UPDATER_SIGN_PATH           "/flash/sys/servicepack.sig"
+#define UPDATER_CA_PATH             "/flash/cert/ca.pem"
+#define UPDATER_CERT_PATH           "/flash/cert/cert.pem"
+#define UPDATER_KEY_PATH            "/flash/cert/private.key"

 /******************************************************************************
 DEFINE TYPES
@@ -30,33 +61,65 @@ typedef struct {
 /******************************************************************************
 DECLARE PRIVATE DATA
 ******************************************************************************/
-static updater_data_t updater_data;
+static updater_data_t updater_data = { .path = NULL, .fhandle = -1, .fsize = 0, .foffset = 0 };
+static OsiLockObj_t updater_LockObj;
+static sBootInfo_t sBootInfo;

 /******************************************************************************
 DEFINE PUBLIC FUNCTIONS
 ******************************************************************************/
+__attribute__ ((section (".boot")))
+void updater_pre_init (void) {
+    // create the updater lock
+    ASSERT(OSI_OK == sl_LockObjCreate(&updater_LockObj, "UpdaterLock"));
+}
+
 bool updater_check_path (void *path) {
+    sl_LockObjLock (&updater_LockObj, SL_OS_WAIT_FOREVER);
    if (!strcmp(UPDATER_IMG_PATH, path)) {
-        updater_data.path = IMG_UPDATE;
        updater_data.fsize = IMG_SIZE;
-        return true;
-    }
-    else if (!strcmp(UPDATER_SRVPACK_PATH, path)) {
+        updater_data.path = IMG_UPDATE1;
+// the launchxl doesn't have enough flash space for 2 user update images
+#ifdef WIPY
+        // check which one should be the next active image
+         _i32 fhandle;
+        if (!sl_FsOpen((unsigned char *)IMG_BOOT_INFO, FS_MODE_OPEN_READ, NULL, &fhandle)) {
+            ASSERT (sizeof(sBootInfo_t) == sl_FsRead(fhandle, 0, (unsigned char *)&sBootInfo, sizeof(sBootInfo_t)));
+            sl_FsClose(fhandle, 0, 0, 0);
+            // if we still have an image pending for verification, keep overwriting it
+            if ((sBootInfo.Status == IMG_STATUS_CHECK && sBootInfo.ActiveImg == IMG_ACT_UPDATE2) ||
+                 (sBootInfo.ActiveImg == IMG_ACT_UPDATE1 && sBootInfo.Status != IMG_STATUS_CHECK)) {
+                updater_data.path = IMG_UPDATE2;
+            }
+        }
+#endif
+    } else if (!strcmp(UPDATER_SRVPACK_PATH, path)) {
        updater_data.path = IMG_SRVPACK;
        updater_data.fsize = SRVPACK_SIZE;
-        return true;
-    }
-    else if (!strcmp(UPDATER_SIGN_PATH, path)) {
+    } else if (!strcmp(UPDATER_SIGN_PATH, path)) {
        updater_data.path = SRVPACK_SIGN;
        updater_data.fsize = SIGN_SIZE;
-        return true;
+    } else if (!strcmp(UPDATER_CA_PATH, path)) {
+        updater_data.path = CA_FILE;
+        updater_data.fsize = CA_KEY_SIZE;
+    } else if (!strcmp(UPDATER_CERT_PATH, path)) {
+        updater_data.path = CERT_FILE;
+        updater_data.fsize = CA_KEY_SIZE;
+    } else if (!strcmp(UPDATER_KEY_PATH, path)) {
+        updater_data.path = KEY_FILE;
+        updater_data.fsize = CA_KEY_SIZE;
+    } else {
+        sl_LockObjUnlock (&updater_LockObj);
+        return false;
    }
-    return false;
+    return true;
 }

 bool updater_start (void) {
    _u32 AccessModeAndMaxSize = FS_MODE_OPEN_WRITE;
    SlFsFileInfo_t FsFileInfo;
+    bool result = false;
+
    sl_LockObjLock (&wlan_LockObj, SL_OS_WAIT_FOREVER);
    if (0 != sl_FsGetInfo((_u8 *)updater_data.path, 0, &FsFileInfo)) {
        // file doesn't exist, create it
@@ -64,49 +127,76 @@ bool updater_start (void) {
    }
    if (!sl_FsOpen((_u8 *)updater_data.path, AccessModeAndMaxSize, NULL, &updater_data.fhandle)) {
        updater_data.foffset = 0;
-        return true;
+        result = true;
    }
    sl_LockObjUnlock (&wlan_LockObj);
-    return false;
+    return result;
 }

 bool updater_write (uint8_t *buf, uint32_t len) {
+    bool result = false;
+
+    sl_LockObjLock (&wlan_LockObj, SL_OS_WAIT_FOREVER);
    if (len == sl_FsWrite(updater_data.fhandle, updater_data.foffset, buf, len)) {
        updater_data.foffset += len;
-        return true;
+        result = true;
    }
-    return false;
+    sl_LockObjUnlock (&wlan_LockObj);
+
+    return result;
 }

 void updater_finnish (void) {
-    sBootInfo_t sBootInfo;
    _i32 fhandle;

    if (updater_data.fhandle > 0) {
+        sl_LockObjLock (&wlan_LockObj, SL_OS_WAIT_FOREVER);
        // close the file being updated
        sl_FsClose(updater_data.fhandle, NULL, NULL, 0);
-
-        if (!strcmp (IMG_UPDATE, updater_data.path)) {
-            // open the boot info file for reading
+#ifdef WIPY
+        // if we still have an image pending for verification, leave the boot info as it is
+        if (!strncmp(IMG_PREFIX, updater_data.path, strlen(IMG_PREFIX)) && sBootInfo.Status != IMG_STATUS_CHECK) {
+#else
+        if (!strncmp(IMG_PREFIX, updater_data.path, strlen(IMG_PREFIX))) {
+#endif
+#ifdef DEBUG
            if (!sl_FsOpen((unsigned char *)IMG_BOOT_INFO, FS_MODE_OPEN_READ, NULL, &fhandle)) {
+
                ASSERT (sizeof(sBootInfo_t) == sl_FsRead(fhandle, 0, (unsigned char *)&sBootInfo, sizeof(sBootInfo_t)));
                sl_FsClose(fhandle, 0, 0, 0);
-                // open the file for writing
+#endif
+                // open the boot info file for writing
                ASSERT (sl_FsOpen((unsigned char *)IMG_BOOT_INFO, FS_MODE_OPEN_WRITE, NULL, &fhandle) == 0);
+#ifdef DEBUG
            }
            else {
+                // the boot info file doesn't exist yet
                _u32 BootInfoCreateFlag  = _FS_FILE_OPEN_FLAG_COMMIT | _FS_FILE_PUBLIC_WRITE | _FS_FILE_PUBLIC_READ;
                ASSERT (sl_FsOpen ((unsigned char *)IMG_BOOT_INFO, FS_MODE_OPEN_CREATE((2 * sizeof(sBootInfo_t)),
                                   BootInfoCreateFlag), NULL, &fhandle) == 0);
            }
+#endif

-            // write the new boot info
-            sBootInfo.ActiveImg = IMG_ACT_UPDATE;
+            // save the new boot info
+#ifdef WIPY
+            sBootInfo.PrevImg = sBootInfo.ActiveImg;
+            if (sBootInfo.ActiveImg == IMG_ACT_UPDATE1) {
+                sBootInfo.ActiveImg = IMG_ACT_UPDATE2;
+            } else {
+                sBootInfo.ActiveImg = IMG_ACT_UPDATE1;
+            }
+// the launchxl doesn't have enough flash space for 2 user updates
+#else
+            sBootInfo.PrevImg = IMG_ACT_FACTORY;
+            sBootInfo.ActiveImg = IMG_ACT_UPDATE1;
+#endif
            sBootInfo.Status = IMG_STATUS_CHECK;
            ASSERT (sizeof(sBootInfo_t) == sl_FsWrite(fhandle, 0, (unsigned char *)&sBootInfo, sizeof(sBootInfo_t)));
            sl_FsClose(fhandle, 0, 0, 0);
        }
+        sl_LockObjUnlock (&wlan_LockObj);
+        updater_data.fhandle = -1;
    }
-    updater_data.fhandle = -1;
-    sl_LockObjUnlock (&wlan_LockObj);
+    sl_LockObjUnlock (&updater_LockObj);
 }
+
--- a/cc3200/ftp/updater.h
+++ b/cc3200/ftp/updater.h
@@ -1,11 +1,38 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 Daniel Campora
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+

 #ifndef UPDATER_H_
 #define UPDATER_H_

-bool updater_check_path (void *path);
-bool updater_start (void);
-bool updater_write (uint8_t *buf, uint32_t len);
-void updater_finnish (void);
-bool updater_verify (uint8_t *rbuff, uint8_t *hasbuff);
+extern void updater_pre_init (void);
+extern bool updater_check_path (void *path);
+extern bool updater_start (void);
+extern bool updater_write (uint8_t *buf, uint32_t len);
+extern void updater_finnish (void);
+extern bool updater_verify (uint8_t *rbuff, uint8_t *hasbuff);

 #endif /* UPDATER_H_ */
--- a/cc3200/hal/cc3200_asm.h
+++ b/cc3200/hal/cc3200_asm.h
@@ -67,6 +67,18 @@ static inline void __set_PRIMASK(uint32_t priMask) {
    __asm volatile ("msr primask, %0" : : "r" (priMask) : "memory");
 }

+__attribute__(( always_inline ))
+static inline uint32_t __get_BASEPRI(void) {
+    uint32_t result;
+    __asm volatile ("mrs %0, basepri" : "=r" (result));
+    return(result);
+}
+
+__attribute__(( always_inline ))
+static inline void __set_BASEPRI(uint32_t value) {
+    __asm volatile ("msr basepri, %0" : : "r" (value) : "memory");
+}
+
 __attribute__(( always_inline ))
 static inline void enable_irq(mp_uint_t state) {
    __set_PRIMASK(state);
--- a/cc3200/hal/cc3200_hal.c
+++ b/cc3200/hal/cc3200_hal.c
@@ -31,12 +31,16 @@
 #include <stdio.h>
 #include <stdint.h>
 #include <string.h>
+
+
+#include "py/mpstate.h"
+#include "py/mphal.h"
+#include "py/runtime.h"
+#include "py/objstr.h"
 #include "inc/hw_types.h"
 #include "inc/hw_ints.h"
 #include "inc/hw_nvic.h"
 #include "hw_memmap.h"
-#include "py/mpstate.h"
-#include MICROPY_HAL_H
 #include "rom_map.h"
 #include "interrupt.h"
 #include "systick.h"
@@ -45,6 +49,9 @@
 #include "mpexception.h"
 #include "telnet.h"
 #include "pybuart.h"
+#include "utils.h"
+#include "irq.h"
+#include "moduos.h"

 #ifdef USE_FREERTOS
 #include "FreeRTOS.h"
@@ -65,11 +72,6 @@ static void hal_TickInit (void);
 ******************************************************************************/
 static volatile uint32_t HAL_tickCount;

-/******************************************************************************
- DECLARE PUBLIC DATA
- ******************************************************************************/
-struct _pyb_uart_obj_t *pyb_stdio_uart;
-
 /******************************************************************************
 DECLARE IMPORTED DATA
 ******************************************************************************/
@@ -102,21 +104,32 @@ void HAL_IncrementTick(void) {
    HAL_tickCount++;
 }

-uint32_t HAL_GetTick(void) {
+mp_uint_t mp_hal_ticks_ms(void) {
    return HAL_tickCount;
 }

-void HAL_Delay(uint32_t delay) {
-#ifdef USE_FREERTOS
-    vTaskDelay (delay / portTICK_PERIOD_MS);
-#else
-    uint32_t start = HAL_tickCount;
-    // Wraparound of tick is taken care of by 2's complement arithmetic.
-    while (HAL_tickCount - start < delay) {
-        // Enter sleep mode, waiting for (at least) the SysTick interrupt.
-        __WFI();
+void mp_hal_delay_ms(mp_uint_t delay) {
+    // only if we are not within interrupt context and interrupts are enabled
+    if ((HAL_NVIC_INT_CTRL_REG & HAL_VECTACTIVE_MASK) == 0 && query_irq() == IRQ_STATE_ENABLED) {
+        #ifdef USE_FREERTOS
+            vTaskDelay (delay / portTICK_PERIOD_MS);
+        #else
+            uint32_t start = HAL_tickCount;
+            // wraparound of tick is taken care of by 2's complement arithmetic.
+            while (HAL_tickCount - start < delay) {
+                // enter sleep mode, waiting for (at least) the SysTick interrupt.
+                __WFI();
+            }
+        #endif
+    } else {
+        for (int ms = 0; ms < delay; ms++) {
+            UtilsDelay(UTILS_DELAY_US_TO_COUNT(1000));
+        }
    }
-#endif
+}
+
+NORETURN void mp_hal_raise(int errno) {
+    nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, mp_obj_new_int(errno)));
 }

 void mp_hal_set_interrupt_char (int c) {
@@ -127,37 +140,60 @@ void mp_hal_stdout_tx_str(const char *str) {
    mp_hal_stdout_tx_strn(str, strlen(str));
 }

-void mp_hal_stdout_tx_strn(const char *str, uint32_t len) {
-    // send stdout to UART
-    if (pyb_stdio_uart != NULL) {
-        uart_tx_strn(pyb_stdio_uart, str, len);
+void mp_hal_stdout_tx_strn(const char *str, size_t len) {
+    if (MP_STATE_PORT(os_term_dup_obj)) {
+        if (MP_OBJ_IS_TYPE(MP_STATE_PORT(os_term_dup_obj)->stream_o, &pyb_uart_type)) {
+            uart_tx_strn(MP_STATE_PORT(os_term_dup_obj)->stream_o, str, len);
+        } else {
+            MP_STATE_PORT(os_term_dup_obj)->write[2] = mp_obj_new_str_of_type(&mp_type_str, (const byte *)str, len);
+            mp_call_method_n_kw(1, 0, MP_STATE_PORT(os_term_dup_obj)->write);
+        }
    }
    // and also to telnet
-    if (telnet_is_active()) {
-        telnet_tx_strn(str, len);
-    }
+    telnet_tx_strn(str, len);
 }

-void mp_hal_stdout_tx_strn_cooked(const char *str, uint32_t len) {
-    // send stdout to UART
-    if (pyb_stdio_uart != NULL) {
-        uart_tx_strn_cooked(pyb_stdio_uart, str, len);
+void mp_hal_stdout_tx_strn_cooked (const char *str, size_t len) {
+    int32_t nslen = 0;
+    const char *_str = str;
+
+    for (int i = 0; i < len; i++) {
+        if (str[i] == '\n') {
+            mp_hal_stdout_tx_strn(_str, nslen);
+            mp_hal_stdout_tx_strn("\r\n", 2);
+            _str += nslen + 1;
+            nslen = 0;
+        } else {
+            nslen++;
+        }
    }
-    // and also to telnet
-    if (telnet_is_active()) {
-        telnet_tx_strn_cooked(str, len);
+    if (_str < str + len) {
+        mp_hal_stdout_tx_strn(_str, nslen);
    }
 }

 int mp_hal_stdin_rx_chr(void) {
    for ( ;; ) {
+        // read telnet first
        if (telnet_rx_any()) {
            return telnet_rx_char();
+        } else if (MP_STATE_PORT(os_term_dup_obj)) { // then the stdio_dup
+            if (MP_OBJ_IS_TYPE(MP_STATE_PORT(os_term_dup_obj)->stream_o, &pyb_uart_type)) {
+                if (uart_rx_any(MP_STATE_PORT(os_term_dup_obj)->stream_o)) {
+                    return uart_rx_char(MP_STATE_PORT(os_term_dup_obj)->stream_o);
+                }
+            } else {
+                MP_STATE_PORT(os_term_dup_obj)->read[2] = mp_obj_new_int(1);
+                mp_obj_t data = mp_call_method_n_kw(1, 0, MP_STATE_PORT(os_term_dup_obj)->read);
+                // data len is > 0
+                if (mp_obj_is_true(data)) {
+                    mp_buffer_info_t bufinfo;
+                    mp_get_buffer_raise(data, &bufinfo, MP_BUFFER_READ);
+                    return ((int *)(bufinfo.buf))[0];
+                }
+            }
        }
-        else if (pyb_stdio_uart != NULL && uart_rx_any(pyb_stdio_uart)) {
-            return uart_rx_char(pyb_stdio_uart);
-        }
-        HAL_Delay(1);
+        mp_hal_delay_ms(1);
    }
 }

--- a/cc3200/hal/cc3200_hal.h
+++ b/cc3200/hal/cc3200_hal.h
@@ -37,7 +37,7 @@
 #define HAL_FCPU_MHZ                        80U
 #define HAL_FCPU_HZ                         (1000000U * HAL_FCPU_MHZ)
 #define HAL_SYSTICK_PERIOD_US               1000U
-#define UTILS_DELAY_US_TO_COUNT(us)         (((us) * HAL_FCPU_MHZ) / 3)
+#define UTILS_DELAY_US_TO_COUNT(us)         (((us) * HAL_FCPU_MHZ) / 6)

 #define HAL_NVIC_INT_CTRL_REG               (*((volatile uint32_t *) 0xE000ED04 ) )
 #define HAL_VECTACTIVE_MASK                 (0x1FUL)
@@ -55,11 +55,6 @@
                                              " isb \n");   \
                                     }

-/******************************************************************************
- DECLARE PUBLIC DATA
- ******************************************************************************/
-extern struct _pyb_uart_obj_t *pyb_stdio_uart;
-
 /******************************************************************************
 DECLARE PUBLIC FUNCTIONS
 ******************************************************************************/
@@ -67,13 +62,7 @@ extern struct _pyb_uart_obj_t *pyb_stdio_uart;
 extern void HAL_SystemInit (void);
 extern void HAL_SystemDeInit (void);
 extern void HAL_IncrementTick(void);
-extern uint32_t HAL_GetTick(void);
-extern void HAL_Delay(uint32_t delay);
+extern NORETURN void mp_hal_raise(int errno);
 extern void mp_hal_set_interrupt_char (int c);

-int mp_hal_stdin_rx_chr(void);
-void mp_hal_stdout_tx_str(const char *str);
-void mp_hal_stdout_tx_strn(const char *str, uint32_t len);
-void mp_hal_stdout_tx_strn_cooked(const char *str, uint32_t len);
-
 #endif /* CC3200_LAUNCHXL_HAL_CC3200_HAL_H_ */
--- a/cc3200/hal/pin.c
+++ b/cc3200/hal/pin.c
@@ -49,15 +49,6 @@
 #include "inc/hw_ocp_shared.h"
 #include "pin.h"

-//*****************************************************************************
-// Macros
-//*****************************************************************************
-#define PAD_MODE_MASK		0x0000000F
-#define PAD_STRENGTH_MASK	0x000000E0
-#define PAD_TYPE_MASK		0x00000310
-#define PAD_CONFIG_BASE		((OCP_SHARED_BASE + \
-                                  OCP_SHARED_O_GPIO_PAD_CONFIG_0))
-
 //*****************************************************************************
 // PIN to PAD matrix
 //*****************************************************************************
--- a/cc3200/hal/pin.h
+++ b/cc3200/hal/pin.h
@@ -143,6 +143,13 @@ extern "C"
 #define PIN_TYPE_OD_PD    0x00000210
 #define PIN_TYPE_ANALOG   0x10000000

+//*****************************************************************************
+// Macros for mode and type
+//*****************************************************************************
+#define PAD_MODE_MASK       0x0000000F
+#define PAD_STRENGTH_MASK   0x000000E0
+#define PAD_TYPE_MASK       0x00000310
+#define PAD_CONFIG_BASE     ((OCP_SHARED_BASE + OCP_SHARED_O_GPIO_PAD_CONFIG_0))

 //*****************************************************************************
 //
--- a/cc3200/hal/prcm.c
+++ b/cc3200/hal/prcm.c
@@ -112,28 +112,29 @@
 // following wrapper can be used to convert the value from cycles to
 // millisecond:
 //
-// CYCLES_U16MS(cycles) ((cycles *1000)/ 1024),
+// CYCLES_U16MS(cycles) ((cycles * 1000) / 1024),
 //
 // Similarly, before setting the value, it must be first converted (from ms to
 // cycles).
 //
-// U16MS_CYCLES(msec)   ((msec *1024)/1000)
+// U16MS_CYCLES(msec)   ((msec * 1024) / 1000)
 //
 // Note: There is a precision loss of 1 ms with the above scheme.
 //
 //
-#define SCC_U64MSEC_GET()                (MAP_PRCMSlowClkCtrGet() >> 5)
+#define SCC_U64MSEC_GET()                (RTCFastDomainCounterGet() >> 5)
 #define SCC_U64MSEC_MATCH_SET(u64Msec)   (MAP_PRCMSlowClkCtrMatchSet(u64Msec << 5))
 #define SCC_U64MSEC_MATCH_GET()          (MAP_PRCMSlowClkCtrMatchGet() >> 5)

 //*****************************************************************************
 //
 // Bit:  31 is used to indicate use of RTC. If set as '1', RTC feature is used.
-// Bit:  30 is used to indicate that a safe boot should be performed
-// bit:  29 is used to indicate that the last reset was caused by the WDT
-// Bits: 28 to 26 are unused
+// Bit:  30 is used to indicate that a safe boot should be performed.
+// bit:  29 is used to indicate that the last reset was caused by the WDT.
+// bit:  28 is used to indicate that the board is booting for the first time after being programmed in factory.
+// Bits: 27 and 26 are unused.
 // Bits: 25 to 16 are used to save millisecond part of RTC reference.
-// Bits: 15 to 0 are being used for HW Changes / ECO
+// Bits: 15 to 0 are being used for HW Changes / ECO.
 //
 //*****************************************************************************

@@ -207,6 +208,39 @@ static void RTCU32SecRegWrite(unsigned long u32Msec)
  MAP_PRCMHIBRegWrite(RTC_SECS_U32_REG_ADDR, u32Msec);
 }

+//*****************************************************************************
+// Fast function to get the most accurate RTC counter value
+//*****************************************************************************
+static unsigned long long RTCFastDomainCounterGet (void) {
+
+    #define BRK_IF_RTC_CTRS_ALIGN(c2, c1)       if (c2 - c1 <= 1) {     \
+                                                    itr++;              \
+                                                    break;              \
+                                                }
+
+    unsigned long long rtc_count1, rtc_count2, rtc_count3;
+    unsigned int itr;
+
+    do {
+        rtc_count1 = PRCMSlowClkCtrFastGet();
+        rtc_count2 = PRCMSlowClkCtrFastGet();
+        rtc_count3 = PRCMSlowClkCtrFastGet();
+        itr = 0;
+
+        BRK_IF_RTC_CTRS_ALIGN(rtc_count2, rtc_count1);
+        BRK_IF_RTC_CTRS_ALIGN(rtc_count3, rtc_count2);
+        BRK_IF_RTC_CTRS_ALIGN(rtc_count3, rtc_count1);
+
+        // Consistent values in two consecutive reads implies a correct
+        // value of the counter. Do note, the counter does not give the
+        // calendar time but a hardware that ticks upwards continuously.
+        // The 48-bit counter operates at 32,768 HZ.
+
+    } while (true);
+
+    return (1 == itr) ? rtc_count2 : rtc_count3;
+}
+
 //*****************************************************************************
 // Macros
 //*****************************************************************************
@@ -254,94 +288,49 @@ static const PRCM_PeriphRegs_t PRCM_PeriphRegsList[] =

 //*****************************************************************************
 //
-//! Requests a safe boot
+//! Set a special bit
 //!
 //! \return None.
 //
 //*****************************************************************************
-void PRCMRequestSafeBoot(void)
+void PRCMSetSpecialBit(unsigned char bit)
 {
    unsigned int uiRegValue;

-    uiRegValue = MAP_PRCMHIBRegRead(RTC_MSEC_U32_REG_ADDR) | (1 << 30);
+    uiRegValue = MAP_PRCMHIBRegRead(RTC_MSEC_U32_REG_ADDR) | (1 << bit);

    PRCMHIBRegWrite(RTC_MSEC_U32_REG_ADDR, uiRegValue);
 }

 //*****************************************************************************
 //
-//! Clear the safe boot request
+//! Clear a special bit
 //!
 //! \return None.
 //
 //*****************************************************************************
-void PRCMClearSafeBootRequest(void)
+void PRCMClearSpecialBit(unsigned char bit)
 {
    unsigned int uiRegValue;

-    uiRegValue = MAP_PRCMHIBRegRead(RTC_MSEC_U32_REG_ADDR) & (~(1 << 30));
+    uiRegValue = MAP_PRCMHIBRegRead(RTC_MSEC_U32_REG_ADDR) & (~(1 << bit));

    PRCMHIBRegWrite(RTC_MSEC_U32_REG_ADDR, uiRegValue);
 }

 //*****************************************************************************
 //
-//! Read the safe boot request bit. This bit is cleared after reading.
+//! Read a special bit
 //!
-//! \return Value of the safe boot bit
+//! \return Value of the bit
 //
 //*****************************************************************************
-tBoolean PRCMIsSafeBootRequested(void)
+tBoolean PRCMGetSpecialBit(unsigned char bit)
 {
-    tBoolean safeboot = (MAP_PRCMHIBRegRead(RTC_MSEC_U32_REG_ADDR) & (1 << 30)) ? true : false;
-
-    PRCMClearSafeBootRequest();
-
-    return safeboot;
-}
-
-//*****************************************************************************
-//
-//! Signals that a WDT reset has occurred
-//!
-//! \return None.
-//
-//*****************************************************************************
-void PRCMSignalWDTReset(void)
-{
-    unsigned int uiRegValue;
-
-    uiRegValue = MAP_PRCMHIBRegRead(RTC_MSEC_U32_REG_ADDR) | (1 << 29);
-
-    PRCMHIBRegWrite(RTC_MSEC_U32_REG_ADDR, uiRegValue);
-}
-
-//*****************************************************************************
-//
-//! Clear the WDT reset signal
-//!
-//! \return None.
-//
-//*****************************************************************************
-void PRCMClearWDTResetSignal(void)
-{
-    unsigned int uiRegValue;
-
-    uiRegValue = MAP_PRCMHIBRegRead(RTC_MSEC_U32_REG_ADDR) & (~(1 << 29));
-
-    PRCMHIBRegWrite(RTC_MSEC_U32_REG_ADDR, uiRegValue);
-}
-
-//*****************************************************************************
-//
-//! Read the WDT reset signal bit
-//!
-//! \return Value of the WDT reset signal bit
-//
-//*****************************************************************************
-tBoolean PRCMWasResetBecauseOfWDT(void)
-{
-    return (MAP_PRCMHIBRegRead(RTC_MSEC_U32_REG_ADDR) & (1 << 29)) ? true : false;
+    tBoolean value = (MAP_PRCMHIBRegRead(RTC_MSEC_U32_REG_ADDR) & (1 << bit)) ? true : false;
+    // special bits must be cleared immediatelly after reading
+    PRCMClearSpecialBit(bit);
+    return value;
 }

 //*****************************************************************************
@@ -1289,6 +1278,35 @@ unsigned long long PRCMSlowClkCtrGet(void)
  return ullRTCVal;
 }

+//*****************************************************************************
+//
+//! Gets the current value of the internal slow clock counter
+//!
+//! This function is similar to \sa PRCMSlowClkCtrGet() but reads the counter
+//! value from a relatively faster interface using an auto-latch mechainsm.
+//!
+//! \note Due to the nature of implemetation of auto latching, when using this
+//! API, the recommendation is to read the value thrice and identify the right
+//! value (as 2 out the 3 read values will always be correct and with a max. of
+//! 1 LSB change)
+//!
+//! \return 64-bit current counter vlaue.
+//
+//*****************************************************************************
+unsigned long long PRCMSlowClkCtrFastGet(void)
+{
+  unsigned long long ullRTCVal;
+
+  //
+  // Read as 2 32-bit values
+  //
+  ullRTCVal = HWREG(HIB1P2_BASE + HIB1P2_O_HIB_RTC_TIMER_MSW_1P2);
+  ullRTCVal = ullRTCVal << 32;
+  ullRTCVal |= HWREG(HIB1P2_BASE + HIB1P2_O_HIB_RTC_TIMER_LSW_1P2);
+
+  return ullRTCVal;
+
+}

 //*****************************************************************************
 //
--- a/cc3200/hal/prcm.h
+++ b/cc3200/hal/prcm.h
@@ -192,17 +192,21 @@ unsigned char ulRstReg;
 // PRCM_ADC should never be used in any user code. 
 #define PRCM_ADC                  0x000000FF 

+//*****************************************************************************
+// User bits in the PRCM persistent registers
+//*****************************************************************************
+#define PRCM_SAFE_BOOT_BIT              30
+#define PRCM_WDT_RESET_BIT              29
+#define PRCM_FIRST_BOOT_BIT             28
+
 //*****************************************************************************
 //
 // API Function prototypes
 //
 //*****************************************************************************
-extern void PRCMRequestSafeBoot(void);
-extern void PRCMClearSafeBootRequest(void);
-extern tBoolean PRCMIsSafeBootRequested(void);
-extern void PRCMSignalWDTReset(void);
-extern void PRCMClearWDTResetSignal(void);
-extern tBoolean PRCMWasResetBecauseOfWDT(void);
+extern void PRCMSetSpecialBit(unsigned char bit);
+extern void PRCMClearSpecialBit(unsigned char bit);
+extern tBoolean PRCMGetSpecialBit(unsigned char bit);
 extern void PRCMSOCReset(void);
 extern void PRCMMCUReset(tBoolean bIncludeSubsystem);
 extern unsigned long PRCMSysResetCauseGet(void);
@@ -243,6 +247,7 @@ extern void PRCMHibernateWakeupSourceDisable(unsigned long ulHIBWakupSrc);
 extern void PRCMHibernateIntervalSet(unsigned long long ullTicks);

 extern unsigned long long PRCMSlowClkCtrGet(void);
+extern unsigned long long PRCMSlowClkCtrFastGet(void);
 extern void PRCMSlowClkCtrMatchSet(unsigned long long ullTicks);
 extern unsigned long long PRCMSlowClkCtrMatchGet(void);

--- a/cc3200/hal/spi.c
+++ b/cc3200/hal/spi.c
@@ -782,15 +782,9 @@ SPIConfigSetExpClk(unsigned long ulBase,unsigned long ulSPIClk,
  }

  //
-  // Mask the configurations and set clock divider granularity
-  // to 1 cycle
+  // set clock divider granularity to 1 cycle
  //
-  ulRegData = (ulRegData & (~(MCSPI_CH0CONF_WL_M |
-                             MCSPI_CH0CONF_EPOL |
-                             MCSPI_CH0CONF_POL  |
-                             MCSPI_CH0CONF_PHA  |
-                             MCSPI_CH0CONF_TURBO ) |
-               MCSPI_CH0CONF_CLKG));
+  ulRegData |= MCSPI_CH0CONF_CLKG;

  //
  // Get the divider value
@@ -798,7 +792,7 @@ SPIConfigSetExpClk(unsigned long ulBase,unsigned long ulSPIClk,
  ulDivider = ((ulSPIClk/ulBitRate) - 1);

  //
-  // The least significant four bits of the divider is used fo configure
+  // The least significant four bits of the divider is used to configure
  // CLKD in MCSPI_CHCONF next eight least significant bits are used to
  // configure the EXTCLK in MCSPI_CHCTRL
  //
--- a/cc3200/main.c
+++ b/cc3200/main.c
@@ -29,11 +29,12 @@
 #include <ctype.h>

 #include "py/mpconfig.h"
-#include MICROPY_HAL_H
+#include "py/mphal.h"
 #include "mptask.h"
 #include "simplelink.h"
 #include "pybwdt.h"
 #include "debug.h"
+#include "antenna.h"
 #include "mperror.h"

 /******************************************************************************
@@ -65,6 +66,11 @@ int main (void) {
    // Initialize the clocks and the interrupt system
    HAL_SystemInit();

+#if MICROPY_HW_ANTENNA_DIVERSITY
+    // configure the antenna selection pins
+    antenna_init0();
+#endif
+
    // Init the watchdog
    pybwdt_init0();

--- a/cc3200/misc/FreeRTOSHooks.c
+++ b/cc3200/misc/FreeRTOSHooks.c
@@ -29,12 +29,11 @@
 #include <string.h>

 #include "py/mpconfig.h"
-#include MICROPY_HAL_H
+#include "py/mphal.h"
 #include "py/obj.h"
 #include "inc/hw_memmap.h"
 #include "pybuart.h"
 #include "osi.h"
-#include "pybwdt.h"
 #include "mperror.h"


@@ -49,8 +48,6 @@
 //*****************************************************************************
 void vApplicationIdleHook (void)
 {
-    // kick the watchdog
-    pybwdt_kick();
    // signal that we are alive and kicking
    mperror_heartbeat_signal();
    // gate the processor's clock to save power
@@ -73,10 +70,7 @@ void vApplicationMallocFailedHook (void)
    __asm volatile ("bkpt #0  \n");
 #endif

-    for ( ; ; )
-    {
-        __fatal_error("FreeRTOS malloc failed!");
-    }
+    __fatal_error("FreeRTOS malloc failed!");
 }

 //*****************************************************************************
@@ -95,10 +89,7 @@ void vApplicationStackOverflowHook (OsiTaskHandle *pxTask, signed char *pcTaskNa
    __asm volatile ("bkpt #0  \n");
 #endif

-    for ( ; ; )
-    {
-        __fatal_error("Stack overflow!");
-    }
+    __fatal_error("Stack overflow!");
 }

 //*****************************************************************************
--- a/cc3200/misc/antenna.c
+++ b/cc3200/misc/antenna.c
@@ -0,0 +1,97 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 Daniel Campora
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdint.h>
+
+#include "mpconfigboard.h"
+#include "inc/hw_types.h"
+#include "inc/hw_gpio.h"
+#include "inc/hw_ints.h"
+#include "inc/hw_memmap.h"
+#include "rom_map.h"
+#include "pin.h"
+#include "prcm.h"
+#include "gpio.h"
+#include "antenna.h"
+
+
+#if MICROPY_HW_ANTENNA_DIVERSITY
+
+/******************************************************************************
+DEFINE CONSTANTS
+******************************************************************************/
+#define REG_PAD_CONFIG_26           (0x4402E108)
+#define REG_PAD_CONFIG_27           (0x4402E10C)
+
+/******************************************************************************
+DEFINE PRIVATE DATA
+******************************************************************************/
+static antenna_type_t antenna_type_selected = ANTENNA_TYPE_INTERNAL;
+
+/******************************************************************************
+DEFINE PUBLIC FUNCTIONS
+******************************************************************************/
+void antenna_init0(void) {
+    // enable the peripheral clock and set the gpio direction for
+    // both antenna 1 and antenna 2 pins
+    MAP_PRCMPeripheralClkEnable(PRCM_GPIOA3, PRCM_RUN_MODE_CLK | PRCM_SLP_MODE_CLK);
+    MAP_GPIODirModeSet(GPIOA3_BASE, 0x0C, GPIO_DIR_MODE_OUT);
+
+    // configure antenna 1 pin type and strength
+    HWREG(REG_PAD_CONFIG_26) = ((HWREG(REG_PAD_CONFIG_26) & ~(PAD_STRENGTH_MASK | PAD_TYPE_MASK)) | (0x00000020 | 0x00000000));
+    // set the mode
+    HWREG(REG_PAD_CONFIG_26) = ((HWREG(REG_PAD_CONFIG_26) & ~PAD_MODE_MASK) | 0x00000000) & ~(3 << 10);
+    // set the direction
+    HWREG(REG_PAD_CONFIG_26) = ((HWREG(REG_PAD_CONFIG_26) & ~0xC00) | 0x00000800);
+
+    // configure antenna 2 pin type and strength
+    HWREG(REG_PAD_CONFIG_27) = ((HWREG(REG_PAD_CONFIG_27) & ~(PAD_STRENGTH_MASK | PAD_TYPE_MASK)) | (0x00000020 | 0x00000000));
+    // set the mode
+    HWREG(REG_PAD_CONFIG_27) = ((HWREG(REG_PAD_CONFIG_27) & ~PAD_MODE_MASK) | 0x00000000) & ~(3 << 10);
+    // set the direction
+    HWREG(REG_PAD_CONFIG_27) = ((HWREG(REG_PAD_CONFIG_27) & ~0xC00) | 0x00000800);
+
+    // select the currently active antenna
+    antenna_select(antenna_type_selected);
+}
+
+void antenna_select (antenna_type_t _antenna) {
+    if (_antenna == ANTENNA_TYPE_INTERNAL) {
+        MAP_GPIOPinWrite(GPIOA3_BASE, 0x0C, 0x04);
+        // also configure the pull-up and pull-down accordingly
+        HWREG(REG_PAD_CONFIG_26) = ((HWREG(REG_PAD_CONFIG_26) & ~PAD_TYPE_MASK)) | PIN_TYPE_STD_PU;
+        HWREG(REG_PAD_CONFIG_27) = ((HWREG(REG_PAD_CONFIG_27) & ~PAD_TYPE_MASK)) | PIN_TYPE_STD_PD;
+    } else {
+        MAP_GPIOPinWrite(GPIOA3_BASE, 0x0C, 0x08);
+        // also configure the pull-up and pull-down accordingly
+        HWREG(REG_PAD_CONFIG_26) = ((HWREG(REG_PAD_CONFIG_26) & ~PAD_TYPE_MASK)) | PIN_TYPE_STD_PD;
+        HWREG(REG_PAD_CONFIG_27) = ((HWREG(REG_PAD_CONFIG_27) & ~PAD_TYPE_MASK)) | PIN_TYPE_STD_PU;
+    }
+    antenna_type_selected = _antenna;
+}
+
+#endif
+
--- a/cc3200/misc/antenna.h
+++ b/cc3200/misc/antenna.h
@@ -3,7 +3,7 @@
 *
 * The MIT License (MIT)
 *
- * Copyright (c) 2014 Damien P. George
+ * Copyright (c) 2015 Daniel Campora
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
@@ -24,16 +24,15 @@
 * THE SOFTWARE.
 */

-typedef struct _fs_user_mount_t {
-    const char *str;
-    mp_uint_t len;
-    mp_obj_t readblocks[4];
-    mp_obj_t writeblocks[4];
-    mp_obj_t sync[2];
-    mp_obj_t count[2];
-    FATFS fatfs;
-} fs_user_mount_t;
+#ifndef _ANTENNA_H_
+#define _ANTENNA_H_

-extern fs_user_mount_t *fs_user_mount;
+typedef enum {
+    ANTENNA_TYPE_INTERNAL = 0,
+    ANTENNA_TYPE_EXTERNAL
+} antenna_type_t;

-MP_DECLARE_CONST_FUN_OBJ(pyb_mount_obj);
+extern void antenna_init0 (void);
+extern void antenna_select (antenna_type_t antenna_type);
+
+#endif /* _ANTENNA_H_ */
--- a/cc3200/misc/help.c
+++ b/cc3200/misc/help.c
@@ -27,21 +27,12 @@

 #include <stdio.h>

-#include "py/mpconfig.h"
-#include "py/obj.h"
+#include "lib/utils/pyhelp.h"

-STATIC const char help_text[] = "Welcome to Micro Python!\n"
+STATIC const char help_text[] = "Welcome to MicroPython!\n"
                                "For online help please visit http://micropython.org/help/.\n"
                                "For further help on a specific object, type help(obj)\n";

-STATIC void pyb_help_print_info_about_object(mp_obj_t name_o, mp_obj_t value) {
-    printf("  ");
-    mp_obj_print(name_o, PRINT_STR);
-    printf(" -- ");
-    mp_obj_print(value, PRINT_STR);
-    printf("\n");
-}
-
 STATIC mp_obj_t pyb_help(uint n_args, const mp_obj_t *args) {
    if (n_args == 0) {
        // print a general help message
@@ -49,31 +40,7 @@ STATIC mp_obj_t pyb_help(uint n_args, const mp_obj_t *args) {
    }
    else {
        // try to print something sensible about the given object
-        printf("object ");
-        mp_obj_print(args[0], PRINT_STR);
-        printf(" is of type %s\n", mp_obj_get_type_str(args[0]));
-
-        mp_map_t *map = NULL;
-        if (MP_OBJ_IS_TYPE(args[0], &mp_type_module)) {
-            map = mp_obj_dict_get_map(mp_obj_module_get_globals(args[0]));
-        } else {
-            mp_obj_type_t *type;
-            if (MP_OBJ_IS_TYPE(args[0], &mp_type_type)) {
-                type = args[0];
-            } else {
-                type = mp_obj_get_type(args[0]);
-            }
-            if (type->locals_dict != MP_OBJ_NULL && MP_OBJ_IS_TYPE(type->locals_dict, &mp_type_dict)) {
-                map = mp_obj_dict_get_map(type->locals_dict);
-            }
-        }
-        if (map != NULL) {
-            for (uint i = 0; i < map->alloc; i++) {
-                if (map->table[i].key != MP_OBJ_NULL) {
-                    pyb_help_print_info_about_object(map->table[i].key, map->table[i].value);
-                }
-            }
-        }
+        pyhelp_print_obj(args[0]);
    }
    return mp_const_none;
 }
--- a/cc3200/misc/mpcallback.c
+++ b/cc3200/misc/mpcallback.c
@@ -1,210 +0,0 @@
-/*
- * This file is part of the Micro Python project, http://micropython.org/
- *
- * The MIT License (MIT)
- *
- * Copyright (c) 2015 Daniel Campora
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include "py/mpconfig.h"
-#include MICROPY_HAL_H
-#include "py/obj.h"
-#include "py/runtime.h"
-#include "py/gc.h"
-#include "inc/hw_types.h"
-#include "interrupt.h"
-#include "pybsleep.h"
-#include "mpcallback.h"
-#include "mpexception.h"
-#include "mperror.h"
-
-
-/******************************************************************************
- DEFINE PUBLIC DATA
- ******************************************************************************/
-const mp_arg_t mpcallback_init_args[] = {
-    { MP_QSTR_intmode,      MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
-    { MP_QSTR_handler,      MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
-    { MP_QSTR_priority,     MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 1} },
-    { MP_QSTR_value,        MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 0} },
-    { MP_QSTR_wakes,        MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = PYB_PWR_MODE_ACTIVE} },
-};
-
-/******************************************************************************
- DEFINE PUBLIC FUNCTIONS
- ******************************************************************************/
-void mpcallback_init0 (void) {
-    // initialize the callback objects list
-    mp_obj_list_init(&MP_STATE_PORT(mpcallback_obj_list), 0);
-}
-
-mp_obj_t mpcallback_new (mp_obj_t parent, mp_obj_t handler, const mp_cb_methods_t *methods) {
-    mpcallback_obj_t *self = m_new_obj(mpcallback_obj_t);
-    self->base.type = &pyb_callback_type;
-    self->handler = handler;
-    self->parent = parent;
-    self->methods = (mp_cb_methods_t *)methods;
-    self->isenabled = true;
-    // remove any old callback if present
-    mpcallback_remove(self->parent);
-    mp_obj_list_append(&MP_STATE_PORT(mpcallback_obj_list), self);
-    return self;
-}
-
-mpcallback_obj_t *mpcallback_find (mp_obj_t parent) {
-    for (mp_uint_t i = 0; i < MP_STATE_PORT(mpcallback_obj_list).len; i++) {
-        // search for the object and then remove it
-        mpcallback_obj_t *callback_obj = ((mpcallback_obj_t *)(MP_STATE_PORT(mpcallback_obj_list).items[i]));
-        if (callback_obj->parent == parent) {
-            return callback_obj;
-        }
-    }
-    return NULL;
-}
-
-void mpcallback_wake_all (void) {
-    // re-enable all active callback objects one by one
-    for (mp_uint_t i = 0; i < MP_STATE_PORT(mpcallback_obj_list).len; i++) {
-        mpcallback_obj_t *callback_obj = ((mpcallback_obj_t *)(MP_STATE_PORT(mpcallback_obj_list).items[i]));
-        if (callback_obj->isenabled) {
-            callback_obj->methods->enable(callback_obj->parent);
-        }
-    }
-}
-
-void mpcallback_remove (const mp_obj_t parent) {
-    mpcallback_obj_t *callback_obj;
-    if ((callback_obj = mpcallback_find(parent))) {
-        mp_obj_list_remove(&MP_STATE_PORT(mpcallback_obj_list), callback_obj);
-    }
-}
-
-uint mpcallback_translate_priority (uint priority) {
-    if (priority < 1 || priority > 7) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
-    }
-
-   switch (priority) {
-   case 1:
-       return INT_PRIORITY_LVL_7;
-   case 2:
-       return INT_PRIORITY_LVL_6;
-   case 3:
-       return INT_PRIORITY_LVL_5;
-   case 4:
-       return INT_PRIORITY_LVL_4;
-   case 5:
-       return INT_PRIORITY_LVL_3;
-   case 6:
-       return INT_PRIORITY_LVL_2;
-   case 7:
-       return INT_PRIORITY_LVL_1;
-   default:
-       return INT_PRIORITY_LVL_7;
-   }
-}
-
-void mpcallback_handler (mp_obj_t self_in) {
-    mpcallback_obj_t *self = self_in;
-    if (self && self->handler != mp_const_none) {
-        // disable interrupts to avoid nesting
-        uint primsk = disable_irq();
-        // when executing code within a handler we must lock the GC to prevent
-        // any memory allocations.  We must also catch any exceptions.
-        gc_lock();
-        nlr_buf_t nlr;
-        if (nlr_push(&nlr) == 0) {
-            mp_call_function_1(self->handler, self->parent);
-            nlr_pop();
-        }
-        else {
-            // uncaught exception; disable the callback so that it doesn't run again
-            self->methods->disable (self->parent);
-            self->handler = mp_const_none;
-            // printing an exception here will cause a stack overflow that will end up in
-            // a hard fault, so is better to signal the uncaught (probably non-recoverable)
-            // exception by blinking the system led instead.
-            mperror_signal_error();
-        }
-        gc_unlock();
-        enable_irq(primsk);
-    }
-}
-
-/******************************************************************************/
-// Micro Python bindings
-
-/// \method init()
-/// Initializes the interrupt callback. With no parameters passed, everything will default
-/// to the values assigned to mpcallback_init_args[].
-STATIC mp_obj_t callback_init(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    mpcallback_obj_t *self = pos_args[0];
-    // this is a bit of a hack, but it let us reuse the callback_create method from our parent
-    ((mp_obj_t *)pos_args)[0] = self->parent;
-    self->methods->init (n_args, pos_args, kw_args);
-    return mp_const_none;
-}
-MP_DEFINE_CONST_FUN_OBJ_KW(callback_init_obj, 1, callback_init);
-
-/// \method enable()
-/// Enables the interrupt callback
-STATIC mp_obj_t callback_enable (mp_obj_t self_in) {
-    mpcallback_obj_t *self = self_in;
-    self->methods->enable(self->parent);
-    self->isenabled = true;
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(callback_enable_obj, callback_enable);
-
-/// \method disable()
-/// Disables the interrupt callback
-STATIC mp_obj_t callback_disable (mp_obj_t self_in) {
-    mpcallback_obj_t *self = self_in;
-    self->methods->disable(self->parent);
-    self->isenabled = false;
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(callback_disable_obj, callback_disable);
-
-/// \method \call()
-/// Triggers the interrupt callback
-STATIC mp_obj_t callback_call(mp_obj_t self_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
-    mp_arg_check_num(n_args, n_kw, 0, 0, false);
-    mpcallback_handler (self_in);
-    return mp_const_none;
-}
-
-STATIC const mp_map_elem_t callback_locals_dict_table[] = {
-    // instance methods
-    { MP_OBJ_NEW_QSTR(MP_QSTR_init),                (mp_obj_t)&callback_init_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_enable),              (mp_obj_t)&callback_enable_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_disable),             (mp_obj_t)&callback_disable_obj },
-};
-
-STATIC MP_DEFINE_CONST_DICT(callback_locals_dict, callback_locals_dict_table);
-
-const mp_obj_type_t pyb_callback_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_callback,
-    .call = callback_call,
-    .locals_dict = (mp_obj_t)&callback_locals_dict,
-};
-
--- a/cc3200/misc/mperror.c
+++ b/cc3200/misc/mperror.c
@@ -30,8 +30,9 @@
 #include <string.h>

 #include "py/mpconfig.h"
-#include MICROPY_HAL_H
 #include "py/obj.h"
+#include "py/runtime.h"
+#include "py/mphal.h"
 #include "hw_ints.h"
 #include "hw_types.h"
 #include "hw_gpio.h"
@@ -44,7 +45,6 @@
 #include "pybpin.h"
 #include "pins.h"
 #endif
-#include "rom.h"
 #include "rom_map.h"
 #include "prcm.h"
 #include "pybuart.h"
@@ -55,20 +55,25 @@
 /******************************************************************************
 DEFINE CONSTANTS
 ******************************************************************************/
-#define MPERROR_TOOGLE_MS                           (40)
-#define MPERROR_SIGNAL_ERROR_MS                     (1000)
+#define MPERROR_TOOGLE_MS                           (50)
+#define MPERROR_SIGNAL_ERROR_MS                     (1200)
 #define MPERROR_HEARTBEAT_ON_MS                     (80)
-#define MPERROR_HEARTBEAT_OFF_MS                    (4920)
+#define MPERROR_HEARTBEAT_OFF_MS                    (3920)

 /******************************************************************************
 DECLARE PRIVATE DATA
 ******************************************************************************/
+#ifndef BOOTLOADER
+STATIC const mp_obj_base_t pyb_heartbeat_obj = {&pyb_heartbeat_type};
+#endif
+
 struct mperror_heart_beat {
    uint32_t off_time;
    uint32_t on_time;
    bool beating;
    bool enabled;
-} mperror_heart_beat = {.off_time = 0, .on_time = 0, .beating = false, .enabled = false};
+    bool do_disable;
+} mperror_heart_beat = {.off_time = 0, .on_time = 0, .beating = false, .enabled = false, .do_disable = false};

 /******************************************************************************
 DEFINE PUBLIC FUNCTIONS
@@ -88,8 +93,9 @@ void mperror_init0 (void) {
    MAP_GPIODirModeSet(MICROPY_SYS_LED_PORT, MICROPY_SYS_LED_PORT_PIN, GPIO_DIR_MODE_OUT);
 #else
    // configure the system led
-    pin_config ((pin_obj_t *)&MICROPY_SYS_LED_GPIO, PIN_MODE_0, GPIO_DIR_MODE_OUT, PIN_TYPE_STD, PIN_STRENGTH_6MA);
+    pin_config ((pin_obj_t *)&MICROPY_SYS_LED_GPIO, PIN_MODE_0, GPIO_DIR_MODE_OUT, PIN_TYPE_STD, 0, PIN_STRENGTH_6MA);
 #endif
+    mperror_heart_beat.enabled = true;
    mperror_heartbeat_switch_off();
 }

@@ -108,7 +114,7 @@ void mperror_bootloader_check_reset_cause (void) {

        // since the reset cause will be changed, we must store the right reason
        // so that the application knows it when booting for the next time
-        PRCMSignalWDTReset();
+        PRCMSetSpecialBit(PRCM_WDT_RESET_BIT);

        MAP_PRCMHibernateWakeupSourceEnable(PRCM_HIB_SLOW_CLK_CTR);
        // set the sleep interval to 10ms
@@ -131,31 +137,25 @@ void mperror_signal_error (void) {
    }
 }

-void mperror_enable_heartbeat (void) {
-    mperror_heart_beat.enabled = true;
-}
-
 void mperror_heartbeat_switch_off (void) {
-    mperror_heart_beat.on_time = 0;
-    mperror_heart_beat.off_time = 0;
-    MAP_GPIOPinWrite(MICROPY_SYS_LED_PORT, MICROPY_SYS_LED_PORT_PIN, 0);
-}
-
-void mperror_disable_heartbeat (void) {
-    mperror_heart_beat.enabled = false;
-    mperror_heartbeat_switch_off();
+    if (mperror_heart_beat.enabled) {
+        mperror_heart_beat.on_time = 0;
+        mperror_heart_beat.off_time = 0;
+        MAP_GPIOPinWrite(MICROPY_SYS_LED_PORT, MICROPY_SYS_LED_PORT_PIN, 0);
+    }
 }

 void mperror_heartbeat_signal (void) {
-    if (mperror_heart_beat.enabled) {
+    if (mperror_heart_beat.do_disable) {
+        mperror_heart_beat.do_disable = false;
+    } else if (mperror_heart_beat.enabled) {
        if (!mperror_heart_beat.beating) {
-            if ((mperror_heart_beat.on_time = HAL_GetTick()) - mperror_heart_beat.off_time > MPERROR_HEARTBEAT_OFF_MS) {
+            if ((mperror_heart_beat.on_time = mp_hal_ticks_ms()) - mperror_heart_beat.off_time > MPERROR_HEARTBEAT_OFF_MS) {
                MAP_GPIOPinWrite(MICROPY_SYS_LED_PORT, MICROPY_SYS_LED_PORT_PIN, MICROPY_SYS_LED_PORT_PIN);
                mperror_heart_beat.beating = true;
            }
-        }
-        else {
-            if ((mperror_heart_beat.off_time = HAL_GetTick()) - mperror_heart_beat.on_time > MPERROR_HEARTBEAT_ON_MS) {
+        } else {
+            if ((mperror_heart_beat.off_time = mp_hal_ticks_ms()) - mperror_heart_beat.on_time > MPERROR_HEARTBEAT_ON_MS) {
                MAP_GPIOPinWrite(MICROPY_SYS_LED_PORT, MICROPY_SYS_LED_PORT_PIN, 0);
                mperror_heart_beat.beating = false;
            }
@@ -194,37 +194,21 @@ void nlr_jump_fail(void *val) {
 #endif
 }

-#ifndef BOOTLOADER
-/******************************************************************************/
-// Micro Python bindings
-
-/// \function enable()
-/// Enables the heartbeat signal
-STATIC mp_obj_t pyb_enable_heartbeat(mp_obj_t self) {
-    mperror_enable_heartbeat ();
-    return mp_const_none;
+void mperror_enable_heartbeat (bool enable) {
+    if (enable) {
+    #ifndef BOOTLOADER
+        // configure the led again
+        pin_config ((pin_obj_t *)&MICROPY_SYS_LED_GPIO, PIN_MODE_0, GPIO_DIR_MODE_OUT, PIN_TYPE_STD, 0, PIN_STRENGTH_6MA);
+    #endif
+        mperror_heart_beat.enabled = true;
+        mperror_heart_beat.do_disable = false;
+        mperror_heartbeat_switch_off();
+    } else {
+        mperror_heart_beat.do_disable = true;
+        mperror_heart_beat.enabled = false;
+    }
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_enable_heartbeat_obj, pyb_enable_heartbeat);

-/// \function disable()
-/// Disables the heartbeat signal
-STATIC mp_obj_t pyb_disable_heartbeat(mp_obj_t self) {
-    mperror_disable_heartbeat ();
-    return mp_const_none;
+bool mperror_is_heartbeat_enabled (void) {
+    return mperror_heart_beat.enabled;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_disable_heartbeat_obj, pyb_disable_heartbeat);
-
-STATIC const mp_map_elem_t pyb_heartbeat_locals_dict_table[] = {
-    { MP_OBJ_NEW_QSTR(MP_QSTR_enable),    (mp_obj_t)&pyb_enable_heartbeat_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_disable),   (mp_obj_t)&pyb_disable_heartbeat_obj },
-};
-STATIC MP_DEFINE_CONST_DICT(pyb_heartbeat_locals_dict, pyb_heartbeat_locals_dict_table);
-
-static const mp_obj_type_t pyb_heartbeat_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_HeartBeat,
-    .locals_dict = (mp_obj_t)&pyb_heartbeat_locals_dict,
-};
-
-const mp_obj_base_t pyb_heartbeat_obj = {&pyb_heartbeat_type};
-#endif
--- a/cc3200/misc/mperror.h
+++ b/cc3200/misc/mperror.h
@@ -29,7 +29,7 @@
 #define MPERROR_H_

 #ifndef BOOTLOADER
-extern const mp_obj_base_t pyb_heartbeat_obj;
+extern const mp_obj_type_t pyb_heartbeat_type;
 #endif

 extern void NORETURN __fatal_error(const char *msg);
@@ -38,9 +38,9 @@ void mperror_init0 (void);
 void mperror_bootloader_check_reset_cause (void);
 void mperror_deinit_sfe_pin (void);
 void mperror_signal_error (void);
-void mperror_enable_heartbeat (void);
 void mperror_heartbeat_switch_off (void);
-void mperror_disable_heartbeat (void);
 void mperror_heartbeat_signal (void);
+void mperror_enable_heartbeat (bool enable);
+bool mperror_is_heartbeat_enabled (void);

 #endif // MPERROR_H_
--- a/cc3200/misc/mpirq.c
+++ b/cc3200/misc/mpirq.c
@@ -0,0 +1,201 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 Daniel Campora
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "std.h"
+
+#include "py/mpconfig.h"
+#include "py/obj.h"
+#include "py/runtime.h"
+#include "py/gc.h"
+#include "inc/hw_types.h"
+#include "interrupt.h"
+#include "pybsleep.h"
+#include "mpexception.h"
+#include "mperror.h"
+#include "mpirq.h"
+
+
+/******************************************************************************
+ DECLARE PUBLIC DATA
+ ******************************************************************************/
+const mp_arg_t mp_irq_init_args[] = {
+    { MP_QSTR_trigger,      MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+    { MP_QSTR_priority,     MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 1} }, // the lowest priority
+    { MP_QSTR_handler,      MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+    { MP_QSTR_wake,         MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+};
+
+/******************************************************************************
+ DECLARE PRIVATE DATA
+ ******************************************************************************/
+STATIC uint8_t mp_irq_priorities[] = { INT_PRIORITY_LVL_7, INT_PRIORITY_LVL_6, INT_PRIORITY_LVL_5, INT_PRIORITY_LVL_4,
+                                       INT_PRIORITY_LVL_3, INT_PRIORITY_LVL_2, INT_PRIORITY_LVL_1 };
+
+/******************************************************************************
+ DEFINE PUBLIC FUNCTIONS
+ ******************************************************************************/
+void mp_irq_init0 (void) {
+    // initialize the callback objects list
+    mp_obj_list_init(&MP_STATE_PORT(mp_irq_obj_list), 0);
+}
+
+mp_obj_t mp_irq_new (mp_obj_t parent, mp_obj_t handler, const mp_irq_methods_t *methods) {
+    mp_irq_obj_t *self = m_new_obj(mp_irq_obj_t);
+    self->base.type = &mp_irq_type;
+    self->handler = handler;
+    self->parent = parent;
+    self->methods = (mp_irq_methods_t *)methods;
+    self->isenabled = true;
+    // remove it in case it was already registered
+    mp_irq_remove(parent);
+    mp_obj_list_append(&MP_STATE_PORT(mp_irq_obj_list), self);
+    return self;
+}
+
+mp_irq_obj_t *mp_irq_find (mp_obj_t parent) {
+    for (mp_uint_t i = 0; i < MP_STATE_PORT(mp_irq_obj_list).len; i++) {
+        mp_irq_obj_t *callback_obj = ((mp_irq_obj_t *)(MP_STATE_PORT(mp_irq_obj_list).items[i]));
+        if (callback_obj->parent == parent) {
+            return callback_obj;
+        }
+    }
+    return NULL;
+}
+
+void mp_irq_wake_all (void) {
+    // re-enable all active callback objects one by one
+    for (mp_uint_t i = 0; i < MP_STATE_PORT(mp_irq_obj_list).len; i++) {
+        mp_irq_obj_t *callback_obj = ((mp_irq_obj_t *)(MP_STATE_PORT(mp_irq_obj_list).items[i]));
+        if (callback_obj->isenabled) {
+            callback_obj->methods->enable(callback_obj->parent);
+        }
+    }
+}
+
+void mp_irq_disable_all (void) {
+    // re-enable all active callback objects one by one
+    for (mp_uint_t i = 0; i < MP_STATE_PORT(mp_irq_obj_list).len; i++) {
+        mp_irq_obj_t *callback_obj = ((mp_irq_obj_t *)(MP_STATE_PORT(mp_irq_obj_list).items[i]));
+        callback_obj->methods->disable(callback_obj->parent);
+    }
+}
+
+void mp_irq_remove (const mp_obj_t parent) {
+    mp_irq_obj_t *callback_obj;
+    if ((callback_obj = mp_irq_find(parent))) {
+        mp_obj_list_remove(&MP_STATE_PORT(mp_irq_obj_list), callback_obj);
+    }
+}
+
+uint mp_irq_translate_priority (uint priority) {
+    if (priority < 1 || priority > MP_ARRAY_SIZE(mp_irq_priorities)) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
+    }
+    return mp_irq_priorities[priority - 1];
+}
+
+void mp_irq_handler (mp_obj_t self_in) {
+    mp_irq_obj_t *self = self_in;
+    if (self && self->handler != mp_const_none) {
+        // when executing code within a handler we must lock the GC to prevent
+        // any memory allocations.
+        gc_lock();
+        nlr_buf_t nlr;
+        if (nlr_push(&nlr) == 0) {
+            mp_call_function_1(self->handler, self->parent);
+            nlr_pop();
+        }
+        else {
+            // uncaught exception; disable the callback so that it doesn't run again
+            self->methods->disable (self->parent);
+            self->handler = mp_const_none;
+            // signal the error using the heart beat led and
+            // by printing a message
+            printf("Uncaught exception in callback handler\n");
+            mp_obj_print_exception(&mp_plat_print, (mp_obj_t)nlr.ret_val);
+            mperror_signal_error();
+        }
+        gc_unlock();
+    }
+}
+
+/******************************************************************************/
+// Micro Python bindings
+
+STATIC mp_obj_t mp_irq_init (mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    mp_irq_obj_t *self = pos_args[0];
+    // this is a bit of a hack, but it let us reuse the callback_create method from our parent
+    ((mp_obj_t *)pos_args)[0] = self->parent;
+    self->methods->init (n_args, pos_args, kw_args);
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_KW(mp_irq_init_obj, 1, mp_irq_init);
+
+STATIC mp_obj_t mp_irq_enable (mp_obj_t self_in) {
+    mp_irq_obj_t *self = self_in;
+    self->methods->enable(self->parent);
+    self->isenabled = true;
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_irq_enable_obj, mp_irq_enable);
+
+STATIC mp_obj_t mp_irq_disable (mp_obj_t self_in) {
+    mp_irq_obj_t *self = self_in;
+    self->methods->disable(self->parent);
+    self->isenabled = false;
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_irq_disable_obj, mp_irq_disable);
+
+STATIC mp_obj_t mp_irq_flags (mp_obj_t self_in) {
+    mp_irq_obj_t *self = self_in;
+    return mp_obj_new_int(self->methods->flags(self->parent));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_irq_flags_obj, mp_irq_flags);
+
+STATIC mp_obj_t mp_irq_call (mp_obj_t self_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
+    mp_arg_check_num(n_args, n_kw, 0, 0, false);
+    mp_irq_handler (self_in);
+    return mp_const_none;
+}
+
+STATIC const mp_map_elem_t mp_irq_locals_dict_table[] = {
+    // instance methods
+    { MP_OBJ_NEW_QSTR(MP_QSTR_init),                (mp_obj_t)&mp_irq_init_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_enable),              (mp_obj_t)&mp_irq_enable_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_disable),             (mp_obj_t)&mp_irq_disable_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_flags),               (mp_obj_t)&mp_irq_flags_obj },
+};
+
+STATIC MP_DEFINE_CONST_DICT(mp_irq_locals_dict, mp_irq_locals_dict_table);
+
+const mp_obj_type_t mp_irq_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_irq,
+    .call = mp_irq_call,
+    .locals_dict = (mp_obj_t)&mp_irq_locals_dict,
+};
+
--- a/cc3200/misc/mpcallback.h
+++ b/cc3200/misc/mpcallback.h
@@ -24,50 +24,52 @@
 * THE SOFTWARE.
 */

-#ifndef MPCALLBACK_H_
-#define MPCALLBACK_H_
+#ifndef MPIRQ_H_
+#define MPIRQ_H_

 /******************************************************************************
 DEFINE CONSTANTS
 ******************************************************************************/
-#define mpcallback_INIT_NUM_ARGS                  5
+#define mp_irq_INIT_NUM_ARGS                    4

 /******************************************************************************
 DEFINE TYPES
 ******************************************************************************/
-typedef void (*mp_cb_method_t) (mp_obj_t self);
-typedef mp_obj_t (*mp_cb_init_t) (mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+typedef mp_obj_t (*mp_irq_init_t) (mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+typedef void (*mp_irq_void_method_t) (mp_obj_t self);
+typedef int (*mp_irq_int_method_t)  (mp_obj_t self);

 typedef struct {
-    mp_cb_init_t init;
-    mp_cb_method_t enable;
-    mp_cb_method_t disable;
-} mp_cb_methods_t;
+    mp_irq_init_t init;
+    mp_irq_void_method_t enable;
+    mp_irq_void_method_t disable;
+    mp_irq_int_method_t flags;
+} mp_irq_methods_t;

 typedef struct {
    mp_obj_base_t base;
    mp_obj_t parent;
    mp_obj_t handler;
-    mp_cb_methods_t *methods;
+    mp_irq_methods_t *methods;
    bool isenabled;
-} mpcallback_obj_t;
+} mp_irq_obj_t;

 /******************************************************************************
 DECLARE EXPORTED DATA
 ******************************************************************************/
-extern const mp_arg_t mpcallback_init_args[];
-extern const mp_obj_type_t pyb_callback_type;
+extern const mp_arg_t mp_irq_init_args[];
+extern const mp_obj_type_t mp_irq_type;

 /******************************************************************************
 DECLARE PUBLIC FUNCTIONS
 ******************************************************************************/
-void mpcallback_init0 (void);
-mp_obj_t mpcallback_new (mp_obj_t parent, mp_obj_t handler, const mp_cb_methods_t *methods);
-mpcallback_obj_t *mpcallback_find (mp_obj_t parent);
-void mpcallback_wake_all (void);
-void mpcallback_remove (const mp_obj_t parent);
-void mpcallback_handler (mp_obj_t self_in);
-uint mpcallback_translate_priority (uint priority);
-mp_obj_t mpcallback_new (mp_obj_t parent, mp_obj_t handler, const mp_cb_methods_t *methods);
+void mp_irq_init0 (void);
+mp_obj_t mp_irq_new (mp_obj_t parent, mp_obj_t handler, const mp_irq_methods_t *methods);
+mp_irq_obj_t *mp_irq_find (mp_obj_t parent);
+void mp_irq_wake_all (void);
+void mp_irq_disable_all (void);
+void mp_irq_remove (const mp_obj_t parent);
+void mp_irq_handler (mp_obj_t self_in);
+uint mp_irq_translate_priority (uint priority);

-#endif /* MPCALLBACK_H_ */
+#endif /* MPIRQ_H_ */
--- a/cc3200/misc/mpsystick.c
+++ b/cc3200/misc/mpsystick.c
@@ -26,9 +26,8 @@
 */

 #include "py/mpconfig.h"
-#include MICROPY_HAL_H
 #include "py/obj.h"
-#include "irq.h"
+#include "py/mphal.h"
 #include "mpsystick.h"
 #include "systick.h"
 #include "inc/hw_types.h"
@@ -41,12 +40,12 @@


 bool sys_tick_has_passed(uint32_t start_tick, uint32_t delay_ms) {
-    return HAL_GetTick() - start_tick >= delay_ms;
+    return mp_hal_ticks_ms() - start_tick >= delay_ms;
 }

 // waits until at least delay_ms milliseconds have passed from the sampling of
 // startTick. Handles overflow properly. Assumes stc was taken from
-// HAL_GetTick() some time before calling this function.
+// mp_hal_ticks_ms() some time before calling this function.
 void sys_tick_wait_at_least(uint32_t start_tick, uint32_t delay_ms) {
 #ifdef USE_FREERTOS
    vTaskDelay (delay_ms / portTICK_PERIOD_MS);
@@ -59,32 +58,14 @@ void sys_tick_wait_at_least(uint32_t start_tick, uint32_t delay_ms) {

 // The SysTick timer counts down at HAL_FCPU_HZ, so we can use that knowledge
 // to grab a microsecond counter.
-//
-// We assume that HAL_GetTick returns milliseconds.
+// We assume that mp_hal_ticks_ms returns milliseconds.
 uint32_t sys_tick_get_microseconds(void) {
    mp_uint_t irq_state = disable_irq();
    uint32_t counter = SysTickValueGet();
-    uint32_t milliseconds = HAL_GetTick();
-    uint32_t status  = (HWREG(NVIC_ST_CTRL));
+    uint32_t milliseconds = mp_hal_ticks_ms();
    enable_irq(irq_state);

-    // It's still possible for the countflag bit to get set if the counter was
-    // reloaded between reading VAL and reading CTRL. With interrupts  disabled
-    // it definitely takes less than 50 HCLK cycles between reading VAL and
-    // reading CTRL, so the test (counter > 50) is to cover the case where VAL
-    // is +ve and very close to zero, and the COUNTFLAG bit is also set.
-    if ((status & NVIC_ST_CTRL_COUNT) && counter > 50) {
-        // This means that the HW reloaded VAL between the time we read VAL and the
-        // time we read CTRL, which implies that there is an interrupt pending
-        // to increment the tick counter.
-        milliseconds++;
-    }
-    uint32_t load = (HWREG(NVIC_ST_RELOAD));
+    uint32_t load = SysTickPeriodGet();
    counter = load - counter; // Convert from decrementing to incrementing
-
-    // ((load + 1) / 1000) is the number of counts per microsecond.
-    //
-    // counter / ((load + 1) / 1000) scales from the systick clock to microseconds
-    // and is the same thing as (counter * 1000) / (load + 1)
-    return milliseconds * 1000 + (counter * 1000) / (load + 1);
+    return (milliseconds * 1000) + ((counter * 1000) / load);
 }
--- a/cc3200/misc/pin_named_pins.c
+++ b/cc3200/misc/pin_named_pins.c
@@ -1,80 +0,0 @@
-/*
- * This file is part of the Micro Python project, http://micropython.org/
- *
- * The MIT License (MIT)
- *
- * Copyright (c) 2013, 2014 Damien P. George
- * Copyright (c) 2015 Daniel Campora
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include <stdio.h>
-#include <stdint.h>
-#include <string.h>
-
-#include "py/mpconfig.h"
-#include "py/obj.h"
-#include "inc/hw_types.h"
-#include "inc/hw_ints.h"
-#include "inc/hw_memmap.h"
-#include "pybpin.h"
-#include MICROPY_HAL_H
-
-STATIC void pin_named_pins_obj_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
-    pin_named_pins_obj_t *self = self_in;
-    mp_printf(print, "<Pin.%q>", self->name);
-}
-
-const mp_obj_type_t pin_cpu_pins_obj_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_cpu,
-    .print = pin_named_pins_obj_print,
-    .locals_dict = (mp_obj_t)&pin_cpu_pins_locals_dict,
-};
-
-pin_obj_t *pin_find_named_pin(const mp_obj_dict_t *named_pins, mp_obj_t name) {
-    mp_map_t *named_map = mp_obj_dict_get_map((mp_obj_t)named_pins);
-    mp_map_elem_t *named_elem = mp_map_lookup(named_map, name, MP_MAP_LOOKUP);
-    if (named_elem != NULL && named_elem->value != NULL) {
-        return named_elem->value;
-    }
-    return NULL;
-}
-
-pin_obj_t *pin_find_pin(const mp_obj_dict_t *named_pins, uint pin_num) {
-    mp_map_t *named_map = mp_obj_dict_get_map((mp_obj_t)named_pins);
-    for (uint i = 0; i < named_map->used; i++) {
-        if (((pin_obj_t *)named_map->table[i].value)->pin_num == pin_num) {
-            return named_map->table[i].value;
-        }
-    }
-    return NULL;
-}
-
-pin_obj_t *pin_find_pin_by_port_bit (const mp_obj_dict_t *named_pins, uint port, uint bit) {
-    mp_map_t *named_map = mp_obj_dict_get_map((mp_obj_t)named_pins);
-    for (uint i = 0; i < named_map->used; i++) {
-        if ((((pin_obj_t *)named_map->table[i].value)->port == port) &&
-                (((pin_obj_t *)named_map->table[i].value)->bit == bit)) {
-            return named_map->table[i].value;
-        }
-    }
-    return NULL;
-}
--- a/cc3200/mods/modmachine.c
+++ b/cc3200/mods/modmachine.c
@@ -0,0 +1,217 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2013, 2014 Damien P. George
+ * Copyright (c) 2015 Daniel Campora
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdint.h>
+#include "std.h"
+
+#include "py/mpstate.h"
+#include "py/runtime.h"
+#include "py/mphal.h"
+#include "irq.h"
+#include "inc/hw_types.h"
+#include "inc/hw_gpio.h"
+#include "inc/hw_ints.h"
+#include "inc/hw_memmap.h"
+#include "inc/hw_uart.h"
+#include "rom_map.h"
+#include "prcm.h"
+#include "pybuart.h"
+#include "pybpin.h"
+#include "pybrtc.h"
+#include "simplelink.h"
+#include "modnetwork.h"
+#include "modwlan.h"
+#include "moduos.h"
+#include "FreeRTOS.h"
+#include "portable.h"
+#include "task.h"
+#include "mpexception.h"
+#include "random.h"
+#include "pybadc.h"
+#include "pybi2c.h"
+#include "pybsd.h"
+#include "pybwdt.h"
+#include "pybsleep.h"
+#include "pybspi.h"
+#include "pybtimer.h"
+#include "utils.h"
+#include "gccollect.h"
+
+
+#ifdef DEBUG
+extern OsiTaskHandle    mpTaskHandle;
+extern OsiTaskHandle    svTaskHandle;
+extern OsiTaskHandle    xSimpleLinkSpawnTaskHndl;
+#endif
+
+
+/// \module machine - functions related to the SoC
+///
+
+/******************************************************************************/
+// Micro Python bindings;
+
+STATIC mp_obj_t machine_reset(void) {
+    // disable wlan
+    wlan_stop(SL_STOP_TIMEOUT_LONG);
+    // reset the cpu and it's peripherals
+    MAP_PRCMMCUReset(true);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(machine_reset_obj, machine_reset);
+
+#ifdef DEBUG
+STATIC mp_obj_t machine_info(uint n_args, const mp_obj_t *args) {
+    // FreeRTOS info
+    {
+        printf("---------------------------------------------\n");
+        printf("FreeRTOS\n");
+        printf("---------------------------------------------\n");
+        printf("Total heap: %u\n", configTOTAL_HEAP_SIZE);
+        printf("Free heap: %u\n", xPortGetFreeHeapSize());
+        printf("MpTask min free stack: %u\n", (unsigned int)uxTaskGetStackHighWaterMark((TaskHandle_t)mpTaskHandle));
+        printf("ServersTask min free stack: %u\n", (unsigned int)uxTaskGetStackHighWaterMark((TaskHandle_t)svTaskHandle));
+        printf("SlTask min free stack: %u\n", (unsigned int)uxTaskGetStackHighWaterMark(xSimpleLinkSpawnTaskHndl));
+        printf("IdleTask min free stack: %u\n", (unsigned int)uxTaskGetStackHighWaterMark(xTaskGetIdleTaskHandle()));
+
+        uint32_t *pstack = (uint32_t *)&_stack;
+        while (*pstack == 0x55555555) {
+            pstack++;
+        }
+        printf("MAIN min free stack: %u\n", pstack - ((uint32_t *)&_stack));
+        printf("---------------------------------------------\n");
+    }
+
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_info_obj, 0, 1, machine_info);
+#endif
+
+STATIC mp_obj_t machine_freq(void) {
+    mp_obj_t tuple[1] = {
+       mp_obj_new_int(HAL_FCPU_HZ),
+    };
+    return mp_obj_new_tuple(1, tuple);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(machine_freq_obj, machine_freq);
+
+STATIC mp_obj_t machine_unique_id(void) {
+    uint8_t mac[SL_BSSID_LENGTH];
+    wlan_get_mac (mac);
+    return mp_obj_new_bytes(mac, SL_BSSID_LENGTH);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(machine_unique_id_obj, machine_unique_id);
+
+STATIC mp_obj_t machine_main(mp_obj_t main) {
+    if (MP_OBJ_IS_STR(main)) {
+        MP_STATE_PORT(machine_config_main) = main;
+    } else {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
+    }
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_1(machine_main_obj, machine_main);
+
+STATIC mp_obj_t machine_idle(void) {
+    __WFI();
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(machine_idle_obj, machine_idle);
+
+STATIC mp_obj_t machine_sleep (void) {
+    pyb_sleep_sleep();
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(machine_sleep_obj, machine_sleep);
+
+STATIC mp_obj_t machine_deepsleep (void) {
+    pyb_sleep_deepsleep();
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(machine_deepsleep_obj, machine_deepsleep);
+
+STATIC mp_obj_t machine_reset_cause (void) {
+    return mp_obj_new_int(pyb_sleep_get_reset_cause());
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(machine_reset_cause_obj, machine_reset_cause);
+
+STATIC mp_obj_t machine_wake_reason (void) {
+    return mp_obj_new_int(pyb_sleep_get_wake_reason());
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(machine_wake_reason_obj, machine_wake_reason);
+
+STATIC const mp_map_elem_t machine_module_globals_table[] = {
+    { MP_OBJ_NEW_QSTR(MP_QSTR___name__),            MP_OBJ_NEW_QSTR(MP_QSTR_umachine) },
+
+    { MP_OBJ_NEW_QSTR(MP_QSTR_reset),               (mp_obj_t)&machine_reset_obj },
+#ifdef DEBUG
+    { MP_OBJ_NEW_QSTR(MP_QSTR_info),                (mp_obj_t)&machine_info_obj },
+#endif
+    { MP_OBJ_NEW_QSTR(MP_QSTR_freq),                (mp_obj_t)&machine_freq_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_unique_id),           (mp_obj_t)&machine_unique_id_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_main),                (mp_obj_t)&machine_main_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_rng),                 (mp_obj_t)&machine_rng_get_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_idle),                (mp_obj_t)&machine_idle_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_sleep),               (mp_obj_t)&machine_sleep_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_deepsleep),           (mp_obj_t)&machine_deepsleep_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_reset_cause),         (mp_obj_t)&machine_reset_cause_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_wake_reason),         (mp_obj_t)&machine_wake_reason_obj },
+
+    { MP_OBJ_NEW_QSTR(MP_QSTR_disable_irq),         (mp_obj_t)&pyb_disable_irq_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_enable_irq),          (mp_obj_t)&pyb_enable_irq_obj },
+
+    { MP_OBJ_NEW_QSTR(MP_QSTR_RTC),                 (mp_obj_t)&pyb_rtc_type },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_Pin),                 (mp_obj_t)&pin_type },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_ADC),                 (mp_obj_t)&pyb_adc_type },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_I2C),                 (mp_obj_t)&pyb_i2c_type },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_SPI),                 (mp_obj_t)&pyb_spi_type },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_UART),                (mp_obj_t)&pyb_uart_type },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_Timer),               (mp_obj_t)&pyb_timer_type },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_WDT),                 (mp_obj_t)&pyb_wdt_type },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_SD),                  (mp_obj_t)&pyb_sd_type },
+
+    // class constants
+    { MP_OBJ_NEW_QSTR(MP_QSTR_IDLE),                MP_OBJ_NEW_SMALL_INT(PYB_PWR_MODE_ACTIVE) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_SLEEP),               MP_OBJ_NEW_SMALL_INT(PYB_PWR_MODE_LPDS) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_DEEPSLEEP),           MP_OBJ_NEW_SMALL_INT(PYB_PWR_MODE_HIBERNATE) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_POWER_ON),            MP_OBJ_NEW_SMALL_INT(PYB_SLP_PWRON_RESET) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_HARD_RESET),          MP_OBJ_NEW_SMALL_INT(PYB_SLP_HARD_RESET) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_WDT_RESET),           MP_OBJ_NEW_SMALL_INT(PYB_SLP_WDT_RESET) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_DEEPSLEEP_RESET),     MP_OBJ_NEW_SMALL_INT(PYB_SLP_HIB_RESET) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_SOFT_RESET),          MP_OBJ_NEW_SMALL_INT(PYB_SLP_SOFT_RESET) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_WLAN_WAKE),           MP_OBJ_NEW_SMALL_INT(PYB_SLP_WAKED_BY_WLAN) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_PIN_WAKE),            MP_OBJ_NEW_SMALL_INT(PYB_SLP_WAKED_BY_GPIO) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_RTC_WAKE),            MP_OBJ_NEW_SMALL_INT(PYB_SLP_WAKED_BY_RTC) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(machine_module_globals, machine_module_globals_table);
+
+const mp_obj_module_t machine_module = {
+    .base = { &mp_type_module },
+    .name = MP_QSTR_umachine,
+    .globals = (mp_obj_dict_t*)&machine_module_globals,
+};
--- a/cc3200/mods/modnetwork.c
+++ b/cc3200/mods/modnetwork.c
@@ -25,87 +25,135 @@
 * THE SOFTWARE.
 */

-#include <stdio.h>
-#include <stdint.h>
-#include <string.h>
+#include <std.h>

 #include "py/mpstate.h"
-#include MICROPY_HAL_H
+#include "py/obj.h"
+#include "py/nlr.h"
+#include "py/runtime.h"
+#include "py/mphal.h"
 #include "modnetwork.h"
 #include "mpexception.h"
 #include "serverstask.h"
+#include "simplelink.h"
+
+
+/******************************************************************************
+ DEFINE TYPES
+ ******************************************************************************/
+typedef struct {
+    mp_obj_base_t base;
+} network_server_obj_t;
+
+/******************************************************************************
+ DECLARE PRIVATE DATA
+ ******************************************************************************/
+STATIC network_server_obj_t network_server_obj;
+STATIC const mp_obj_type_t network_server_type;

 /// \module network - network configuration
 ///
-/// This module provides network drivers and routing configuration.
+/// This module provides network drivers and server configuration.

 void mod_network_init0(void) {
-    mp_obj_list_init(&MP_STATE_PORT(mod_network_nic_list), 0);
 }

-void mod_network_register_nic(mp_obj_t nic) {
-    for (mp_uint_t i = 0; i < MP_STATE_PORT(mod_network_nic_list).len; i++) {
-        if (MP_STATE_PORT(mod_network_nic_list).items[i] == nic) {
-            // nic already registered
-            return;
-        }
-    }
-    // nic not registered so add to list
-    mp_obj_list_append(&MP_STATE_PORT(mod_network_nic_list), nic);
-}
-
-mp_obj_t mod_network_find_nic(const uint8_t *ip) {
-    // find a NIC that is suited to given IP address
-    for (mp_uint_t i = 0; i < MP_STATE_PORT(mod_network_nic_list).len; i++) {
-        mp_obj_t nic = MP_STATE_PORT(mod_network_nic_list).items[i];
-        return nic;
-    }
-
-    nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_resource_not_avaliable));
-}
-
-STATIC mp_obj_t network_route(void) {
-    return &MP_STATE_PORT(mod_network_nic_list);
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_0(network_route_obj, network_route);
-
 #if (MICROPY_PORT_HAS_TELNET || MICROPY_PORT_HAS_FTP)
-STATIC mp_obj_t network_server_start(void) {
+STATIC mp_obj_t network_server_init_helper(mp_obj_t self, const mp_arg_val_t *args) {
+    const char *user = SERVERS_DEF_USER;
+    const char *pass = SERVERS_DEF_PASS;
+    if (args[0].u_obj != MP_OBJ_NULL) {
+        mp_obj_t *login;
+        mp_obj_get_array_fixed_n(args[0].u_obj, 2, &login);
+        user = mp_obj_str_get_str(login[0]);
+        pass = mp_obj_str_get_str(login[1]);
+    }
+
+    uint32_t timeout = SERVERS_DEF_TIMEOUT_MS / 1000;
+    if (args[1].u_obj != MP_OBJ_NULL) {
+        timeout = mp_obj_get_int(args[1].u_obj);
+    }
+
+    // configure the new login
+    servers_set_login ((char *)user, (char *)pass);
+
+    // configure the timeout
+    servers_set_timeout(timeout * 1000);
+
+    // start the servers
    servers_start();
+
    return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_0(network_server_start_obj, network_server_start);

-STATIC mp_obj_t network_server_stop(void) {
+STATIC const mp_arg_t network_server_args[] = {
+    { MP_QSTR_id,                            MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+    { MP_QSTR_login,        MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+    { MP_QSTR_timeout,      MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+};
+STATIC mp_obj_t network_server_make_new(const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
+    // parse args
+    mp_map_t kw_args;
+    mp_map_init_fixed_table(&kw_args, n_kw, all_args + n_args);
+    mp_arg_val_t args[MP_ARRAY_SIZE(network_server_args)];
+    mp_arg_parse_all(n_args, all_args, &kw_args, MP_ARRAY_SIZE(args), network_server_args, args);
+
+    // check the server id
+    if (args[0].u_obj != MP_OBJ_NULL) {
+        if (mp_obj_get_int(args[0].u_obj) != 0) {
+            nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_resource_not_avaliable));
+        }
+    }
+
+    // setup the object and initialize it
+    network_server_obj_t *self = &network_server_obj;
+    self->base.type = &network_server_type;
+    network_server_init_helper(self, &args[1]);
+
+    return (mp_obj_t)self;
+}
+
+STATIC mp_obj_t network_server_init(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    // parse args
+    mp_arg_val_t args[MP_ARRAY_SIZE(network_server_args) - 1];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(args), &network_server_args[1], args);
+    return network_server_init_helper(pos_args[0], args);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(network_server_init_obj, 1, network_server_init);
+
+// timeout value given in seconds
+STATIC mp_obj_t network_server_timeout(mp_uint_t n_args, const mp_obj_t *args) {
+    if (n_args > 1) {
+        uint32_t timeout = mp_obj_get_int(args[1]);
+        servers_set_timeout(timeout * 1000);
+        return mp_const_none;
+    } else {
+        // get
+        return mp_obj_new_int(servers_get_timeout() / 1000);
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(network_server_timeout_obj, 1, 2, network_server_timeout);
+
+STATIC mp_obj_t network_server_running(mp_obj_t self_in) {
+    // get
+    return mp_obj_new_bool(servers_are_enabled());
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(network_server_running_obj, network_server_running);
+
+STATIC mp_obj_t network_server_deinit(mp_obj_t self_in) {
+    // simply stop the servers
    servers_stop();
    return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_0(network_server_stop_obj, network_server_stop);
-
-STATIC mp_obj_t network_server_enabled(void) {
-    return MP_BOOL(servers_are_enabled());
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_0(network_server_enabled_obj, network_server_enabled);
-
-STATIC mp_obj_t network_server_login(mp_obj_t user, mp_obj_t pass) {
-    const char *_user = mp_obj_str_get_str(user);
-    const char *_pass = mp_obj_str_get_str(pass);
-    servers_set_login ((char *)_user, (char *)_pass);
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(network_server_login_obj, network_server_login);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(network_server_deinit_obj, network_server_deinit);
 #endif

 STATIC const mp_map_elem_t mp_module_network_globals_table[] = {
    { MP_OBJ_NEW_QSTR(MP_QSTR___name__),            MP_OBJ_NEW_QSTR(MP_QSTR_network) },
    { MP_OBJ_NEW_QSTR(MP_QSTR_WLAN),                (mp_obj_t)&mod_network_nic_type_wlan },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_route),               (mp_obj_t)&network_route_obj },

 #if (MICROPY_PORT_HAS_TELNET || MICROPY_PORT_HAS_FTP)
-    { MP_OBJ_NEW_QSTR(MP_QSTR_start_server),        (mp_obj_t)&network_server_start_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_stop_server),         (mp_obj_t)&network_server_stop_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_server_enabled),      (mp_obj_t)&network_server_enabled_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_server_login),        (mp_obj_t)&network_server_login_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_Server),              (mp_obj_t)&network_server_type },
 #endif
 };

@@ -117,59 +165,20 @@ const mp_obj_module_t mp_module_network = {
    .globals = (mp_obj_dict_t*)&mp_module_network_globals,
 };

-/******************************************************************************/
-// Miscellaneous helpers
+#if (MICROPY_PORT_HAS_TELNET || MICROPY_PORT_HAS_FTP)
+STATIC const mp_map_elem_t network_server_locals_dict_table[] = {
+    { MP_OBJ_NEW_QSTR(MP_QSTR_init),                (mp_obj_t)&network_server_init_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_deinit),              (mp_obj_t)&network_server_deinit_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_timeout),             (mp_obj_t)&network_server_timeout_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_isrunning),           (mp_obj_t)&network_server_running_obj },
+};

-// Takes an address of the form '192.168.0.1' and converts it to integer
-// in out_ip (little endian, so the 192 is the last byte).
-void mod_network_parse_ipv4_addr(mp_obj_t addr_in, uint8_t *out_ip) {
-    mp_uint_t addr_len;
-    const char *addr_str = mp_obj_str_get_data(addr_in, &addr_len);
-    if (addr_len == 0) {
-        // special case of no address given
-        memset(out_ip, 0, MOD_NETWORK_IPV4ADDR_BUF_SIZE);
-        return;
-    }
-    const char *s = addr_str;
-    const char *s_top = addr_str + addr_len;
-    for (mp_uint_t i = 3 ; ; i--) {
-        mp_uint_t val = 0;
-        for (; s < s_top && *s != '.'; s++) {
-            val = val * 10 + *s - '0';
-        }
-        out_ip[i] = val;
-        if (i == 0 && s == s_top) {
-            return;
-        } else if (i > 0 && s < s_top && *s == '.') {
-            s++;
-        } else {
-            nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
-        }
-    }
-}
+STATIC MP_DEFINE_CONST_DICT(network_server_locals_dict, network_server_locals_dict_table);

-// Takes an address of the form ('192.168.0.1', 8080), returns the port and
-// puts IP in out_ip (which must take at least IPADDR_BUF_SIZE bytes).
-mp_uint_t mod_network_parse_inet_addr(mp_obj_t addr_in, uint8_t *out_ip) {
-    mp_obj_t *addr_items;
-    mp_obj_get_array_fixed_n(addr_in, 2, &addr_items);
-    mod_network_parse_ipv4_addr(addr_items[0], out_ip);
-    return mp_obj_get_int(addr_items[1]);
-}
-
-// Takes an array with a raw IPv4 address and returns something like '192.168.0.1'.
-mp_obj_t mod_network_format_ipv4_addr(uint8_t *ip) {
-    char ip_str[16];
-    mp_uint_t ip_len = snprintf(ip_str, 16, "%u.%u.%u.%u", ip[3], ip[2], ip[1], ip[0]);
-    return mp_obj_new_str(ip_str, ip_len, false);
-}
-
-// Takes an array with a raw IP address, and a port, and returns a net-address
-// tuple such as ('192.168.0.1', 8080).
-mp_obj_t mod_network_format_inet_addr(uint8_t *ip, mp_uint_t port) {
-    mp_obj_t tuple[2] = {
-        tuple[0] = mod_network_format_ipv4_addr(ip),
-        tuple[1] = mp_obj_new_int(port),
-    };
-    return mp_obj_new_tuple(2, tuple);
-}
+STATIC const mp_obj_type_t network_server_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_Server,
+    .make_new = network_server_make_new,
+    .locals_dict = (mp_obj_t)&network_server_locals_dict,
+};
+#endif
--- a/cc3200/mods/modnetwork.h
+++ b/cc3200/mods/modnetwork.h
@@ -28,58 +28,47 @@
 #ifndef MODNETWORK_H_
 #define MODNETWORK_H_

+/******************************************************************************
+ DEFINE CONSTANTS
+ ******************************************************************************/
 #define MOD_NETWORK_IPV4ADDR_BUF_SIZE             (4)

-// Forward declaration
-struct _mod_network_socket_obj_t;
-
+/******************************************************************************
+ DEFINE TYPES
+ ******************************************************************************/
 typedef struct _mod_network_nic_type_t {
    mp_obj_type_t base;
-
-    // API for non-socket operations
-    int (*gethostbyname)(mp_obj_t nic, const char *name, mp_uint_t len, uint8_t *ip_out, uint8_t family);
-
-    // API for socket operations; return -1 on error
-    int (*socket)(struct _mod_network_socket_obj_t *s, int *_errno);
-    void (*close)(struct _mod_network_socket_obj_t *socket);
-    int (*bind)(struct _mod_network_socket_obj_t *s, byte *ip, mp_uint_t port, int *_errno);
-    int (*listen)(struct _mod_network_socket_obj_t *s, mp_int_t backlog, int *_errno);
-    int (*accept)(struct _mod_network_socket_obj_t *s, struct _mod_network_socket_obj_t *s2, byte *ip, mp_uint_t *port, int *_errno);
-    int (*connect)(struct _mod_network_socket_obj_t *s, byte *ip, mp_uint_t port, int *_errno);
-    int (*send)(struct _mod_network_socket_obj_t *s, const byte *buf, mp_uint_t len, int *_errno);
-    int (*recv)(struct _mod_network_socket_obj_t *s, byte *buf, mp_uint_t len, int *_errno);
-    int (*sendto)(struct _mod_network_socket_obj_t *s, const byte *buf, mp_uint_t len, byte *ip, mp_uint_t port, int *_errno);
-    int (*recvfrom)(struct _mod_network_socket_obj_t *s, byte *buf, mp_uint_t len, byte *ip, mp_uint_t *port, int *_errno);
-    int (*setsockopt)(struct _mod_network_socket_obj_t *s, mp_uint_t level, mp_uint_t opt, const void *optval, mp_uint_t optlen, int *_errno);
-    int (*settimeout)(struct _mod_network_socket_obj_t *s, mp_uint_t timeout_ms, int *_errno);
-    int (*ioctl)(struct _mod_network_socket_obj_t *s, mp_uint_t request, mp_uint_t arg, int *_errno);
 } mod_network_nic_type_t;

-typedef struct _mod_network_socket_obj_t {
-    mp_obj_base_t base;
-    mp_obj_t nic;
-    mod_network_nic_type_t *nic_type;
+typedef struct _mod_network_socket_base_t {
    union {
        struct {
+            // this order is important so that fileno gets > 0 once
+            // the socket descriptor is assigned after being created.
            uint8_t domain;
+            int8_t fileno;
            uint8_t type;
            uint8_t proto;
-            int8_t fileno;
        } u_param;
        int16_t sd;
    };
-    bool  closed;
+    bool has_timeout;
+    bool cert_req;
+} mod_network_socket_base_t;
+
+typedef struct _mod_network_socket_obj_t {
+    mp_obj_base_t base;
+    mod_network_socket_base_t sock_base;
 } mod_network_socket_obj_t;

+/******************************************************************************
+ EXPORTED DATA
+ ******************************************************************************/
 extern const mod_network_nic_type_t mod_network_nic_type_wlan;

+/******************************************************************************
+ DECLARE FUNCTIONS
+ ******************************************************************************/
 void mod_network_init0(void);
-void mod_network_register_nic(mp_obj_t nic);
-mp_obj_t mod_network_find_nic(const uint8_t *ip);
-
-void mod_network_parse_ipv4_addr(mp_obj_t addr_in, uint8_t *out_ip);
-mp_uint_t mod_network_parse_inet_addr(mp_obj_t addr_in, uint8_t *out_ip);
-mp_obj_t mod_network_format_ipv4_addr(uint8_t *ip);
-mp_obj_t mod_network_format_inet_addr(uint8_t *ip, mp_uint_t port);

 #endif  // MODNETWORK_H_
--- a/cc3200/mods/modpyb.c
+++ b/cc3200/mods/modpyb.c
@@ -1,299 +0,0 @@
-/*
- * This file is part of the Micro Python project, http://micropython.org/
- *
- * The MIT License (MIT)
- *
- * Copyright (c) 2013, 2014 Damien P. George
- * Copyright (c) 2015 Daniel Campora
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include <stdint.h>
-#include "std.h"
-
-#include "py/mpstate.h"
-#include "py/runtime.h"
-#include MICROPY_HAL_H
-#include "irq.h"
-#include "inc/hw_types.h"
-#include "inc/hw_gpio.h"
-#include "inc/hw_ints.h"
-#include "inc/hw_memmap.h"
-#include "inc/hw_uart.h"
-#include "prcm.h"
-#include "pyexec.h"
-#include "pybuart.h"
-#include "pybpin.h"
-#include "pybrtc.h"
-#include "mpsystick.h"
-#include "simplelink.h"
-#include "modwlan.h"
-#include "moduos.h"
-#include "telnet.h"
-#include "ff.h"
-#include "diskio.h"
-#include "sflash_diskio.h"
-#include "FreeRTOS.h"
-#include "portable.h"
-#include "task.h"
-#include "mpexception.h"
-#include "mpcallback.h"
-#include "random.h"
-#include "pybadc.h"
-#include "pybi2c.h"
-#include "pybsd.h"
-#include "pybwdt.h"
-#include "pybsleep.h"
-#include "pybspi.h"
-#include "utils.h"
-#include "gccollect.h"
-#include "mperror.h"
-#include "genhdr/py-version.h"
-
-
-#ifdef DEBUG
-extern OsiTaskHandle    mpTaskHandle;
-extern OsiTaskHandle    svTaskHandle;
-extern OsiTaskHandle    xSimpleLinkSpawnTaskHndl;
-#endif
-
-
-/// \module pyb - functions related to the pyboard
-///
-/// The `pyb` module contains specific functions related to the pyboard.
-
-/// \function hard_reset()
-/// Resets the pyboard in a manner similar to pushing the external RESET
-/// button.
-STATIC mp_obj_t pyb_hard_reset(void) {
-    // disable wlan
-    wlan_stop(SL_STOP_TIMEOUT_LONG);
-    // perform a SoC reset
-    PRCMSOCReset();
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_0(pyb_hard_reset_obj, pyb_hard_reset);
-
-#ifdef DEBUG
-/// \function info([dump_alloc_table])
-/// Print out some run time info which is helpful duirng development.
-STATIC mp_obj_t pyb_info(uint n_args, const mp_obj_t *args) {
-    // FreeRTOS info
-    {
-        printf("---------------------------------------------\n");
-        printf("FreeRTOS\n");
-        printf("---------------------------------------------\n");
-        printf("Total heap: %u\n", configTOTAL_HEAP_SIZE);
-        printf("Free heap: %u\n", xPortGetFreeHeapSize());
-        printf("MpTask min free stack: %u\n", (unsigned int)uxTaskGetStackHighWaterMark((TaskHandle_t)mpTaskHandle));
-        printf("ServersTask min free stack: %u\n", (unsigned int)uxTaskGetStackHighWaterMark((TaskHandle_t)svTaskHandle));
-        printf("SlTask min free stack: %u\n", (unsigned int)uxTaskGetStackHighWaterMark(xSimpleLinkSpawnTaskHndl));
-        printf("IdleTask min free stack: %u\n", (unsigned int)uxTaskGetStackHighWaterMark(xTaskGetIdleTaskHandle()));
-
-        uint32_t *pstack = (uint32_t *)&_stack;
-        while (*pstack == 0x55555555) {
-            pstack++;
-        }
-        printf("MAIN min free stack: %u\n", pstack - ((uint32_t *)&_stack));
-        printf("---------------------------------------------\n");
-    }
-
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_info_obj, 0, 1, pyb_info);
-#endif
-
-/// \function freq()
-/// Returns the CPU frequency: (F_CPU).
-STATIC mp_obj_t pyb_freq(void) {
-    return mp_obj_new_int(HAL_FCPU_HZ);
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_0(pyb_freq_obj, pyb_freq);
-
-/// \function millis()
-/// Returns the number of milliseconds since the board was last reset.
-///
-/// The result is always a micropython smallint (31-bit signed number), so
-/// after 2^30 milliseconds (about 12.4 days) this will start to return
-/// negative numbers.
-STATIC mp_obj_t pyb_millis(void) {
-    // We want to "cast" the 32 bit unsigned into a small-int.  This means
-    // copying the MSB down 1 bit (extending the sign down), which is
-    // equivalent to just using the MP_OBJ_NEW_SMALL_INT macro.
-    return MP_OBJ_NEW_SMALL_INT(HAL_GetTick());
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_0(pyb_millis_obj, pyb_millis);
-
-/// \function elapsed_millis(start)
-/// Returns the number of milliseconds which have elapsed since `start`.
-///
-/// This function takes care of counter wrap, and always returns a positive
-/// number. This means it can be used to measure periods upto about 12.4 days.
-///
-/// Example:
-///     start = pyb.millis()
-///     while pyb.elapsed_millis(start) < 1000:
-///         # Perform some operation
-STATIC mp_obj_t pyb_elapsed_millis(mp_obj_t start) {
-    uint32_t startMillis = mp_obj_get_int(start);
-    uint32_t currMillis = HAL_GetTick();
-    return MP_OBJ_NEW_SMALL_INT((currMillis - startMillis) & 0x3fffffff);
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_elapsed_millis_obj, pyb_elapsed_millis);
-
-/// \function micros()
-/// Returns the number of microseconds since the board was last reset.
-///
-/// The result is always a micropython smallint (31-bit signed number), so
-/// after 2^30 microseconds (about 17.8 minutes) this will start to return
-/// negative numbers.
-STATIC mp_obj_t pyb_micros(void) {
-    // We want to "cast" the 32 bit unsigned into a small-int.  This means
-    // copying the MSB down 1 bit (extending the sign down), which is
-    // equivalent to just using the MP_OBJ_NEW_SMALL_INT macro.
-    return MP_OBJ_NEW_SMALL_INT(sys_tick_get_microseconds());
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_0(pyb_micros_obj, pyb_micros);
-
-/// \function elapsed_micros(start)
-/// Returns the number of microseconds which have elapsed since `start`.
-///
-/// This function takes care of counter wrap, and always returns a positive
-/// number. This means it can be used to measure periods upto about 17.8 minutes.
-///
-/// Example:
-///     start = pyb.micros()
-///     while pyb.elapsed_micros(start) < 1000:
-///         # Perform some operation
-STATIC mp_obj_t pyb_elapsed_micros(mp_obj_t start) {
-    uint32_t startMicros = mp_obj_get_int(start);
-    uint32_t currMicros = sys_tick_get_microseconds();
-    return MP_OBJ_NEW_SMALL_INT((currMicros - startMicros) & 0x3fffffff);
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_elapsed_micros_obj, pyb_elapsed_micros);
-
-/// \function delay(ms)
-/// Delay for the given number of milliseconds.
-STATIC mp_obj_t pyb_delay(mp_obj_t ms_in) {
-    mp_int_t ms = mp_obj_get_int(ms_in);
-    if (ms > 0) {
-        HAL_Delay(ms);
-    }
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_delay_obj, pyb_delay);
-
-/// \function udelay(us)
-/// Delay for the given number of microseconds.
-STATIC mp_obj_t pyb_udelay(mp_obj_t usec_in) {
-    mp_int_t usec = mp_obj_get_int(usec_in);
-    if (usec > 0) {
-        UtilsDelay(UTILS_DELAY_US_TO_COUNT(usec));
-    }
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_udelay_obj, pyb_udelay);
-
-/// \function repl_uart(uart)
-/// Get or set the UART object that the REPL is repeated on.
-STATIC mp_obj_t pyb_repl_uart(uint n_args, const mp_obj_t *args) {
-    if (n_args == 0) {
-        if (pyb_stdio_uart == NULL) {
-            return mp_const_none;
-        } else {
-            return pyb_stdio_uart;
-        }
-    } else {
-        if (args[0] == mp_const_none) {
-            pyb_stdio_uart = NULL;
-        } else if (mp_obj_get_type(args[0]) == &pyb_uart_type) {
-            pyb_stdio_uart = args[0];
-        } else {
-            nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, mpexception_num_type_invalid_arguments));
-        }
-        return mp_const_none;
-    }
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_repl_uart_obj, 0, 1, pyb_repl_uart);
-
-/// \function version()
-/// Prints the software version (MicroPython + Port)
-STATIC mp_obj_t pyb_version(void) {
-    char version[128];
-    snprintf(version, sizeof(version), "Micro Python " MICROPY_GIT_TAG " on " MICROPY_BUILD_DATE "; " MICROPY_HW_BOARD_NAME " with " MICROPY_HW_MCU_NAME);
-    return mp_obj_new_str(version, strlen(version), false);
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_0(pyb_version_obj, pyb_version);
-
-MP_DECLARE_CONST_FUN_OBJ(pyb_main_obj); // defined in main.c
-
-STATIC const mp_map_elem_t pyb_module_globals_table[] = {
-    { MP_OBJ_NEW_QSTR(MP_QSTR___name__),            MP_OBJ_NEW_QSTR(MP_QSTR_pyb) },
-
-    { MP_OBJ_NEW_QSTR(MP_QSTR_reset),               (mp_obj_t)&pyb_hard_reset_obj },
-#ifdef DEBUG
-    { MP_OBJ_NEW_QSTR(MP_QSTR_info),                (mp_obj_t)&pyb_info_obj },
-#endif
-    { MP_OBJ_NEW_QSTR(MP_QSTR_freq),                (mp_obj_t)&pyb_freq_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_repl_info),           (mp_obj_t)&pyb_set_repl_info_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_repl_uart),           (mp_obj_t)&pyb_repl_uart_obj },
-
-    { MP_OBJ_NEW_QSTR(MP_QSTR_disable_irq),         (mp_obj_t)&pyb_disable_irq_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_enable_irq),          (mp_obj_t)&pyb_enable_irq_obj },
-
-    { MP_OBJ_NEW_QSTR(MP_QSTR_main),                (mp_obj_t)&pyb_main_obj },
-
-    { MP_OBJ_NEW_QSTR(MP_QSTR_millis),              (mp_obj_t)&pyb_millis_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_elapsed_millis),      (mp_obj_t)&pyb_elapsed_millis_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_micros),              (mp_obj_t)&pyb_micros_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_elapsed_micros),      (mp_obj_t)&pyb_elapsed_micros_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_delay),               (mp_obj_t)&pyb_delay_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_udelay),              (mp_obj_t)&pyb_udelay_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_version),             (mp_obj_t)&pyb_version_obj },
-
-#if MICROPY_HW_ENABLE_RNG
-    { MP_OBJ_NEW_QSTR(MP_QSTR_rng),                 (mp_obj_t)&pyb_rng_get_obj },
-#endif
-
-#if MICROPY_HW_ENABLE_RTC
-    { MP_OBJ_NEW_QSTR(MP_QSTR_RTC),                 (mp_obj_t)&pyb_rtc_obj },
-#endif
-
-    { MP_OBJ_NEW_QSTR(MP_QSTR_Pin),                 (mp_obj_t)&pin_type },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_ADC),                 (mp_obj_t)&pyb_adc_type },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_I2C),                 (mp_obj_t)&pyb_i2c_type },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_SPI),                 (mp_obj_t)&pyb_spi_type },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_UART),                (mp_obj_t)&pyb_uart_type },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_WDT),                 (mp_obj_t)&pyb_wdt_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_Sleep),               (mp_obj_t)&pyb_sleep_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_HeartBeat),           (mp_obj_t)&pyb_heartbeat_obj },
-
-#if MICROPY_HW_HAS_SDCARD
-    { MP_OBJ_NEW_QSTR(MP_QSTR_SD),                  (mp_obj_t)&pyb_sd_type },
-#endif
-};
-
-STATIC MP_DEFINE_CONST_DICT(pyb_module_globals, pyb_module_globals_table);
-
-const mp_obj_module_t pyb_module = {
-    .base = { &mp_type_module },
-    .name = MP_QSTR_pyb,
-    .globals = (mp_obj_dict_t*)&pyb_module_globals,
-};
--- a/cc3200/mods/modubinascii.c
+++ b/cc3200/mods/modubinascii.c
@@ -0,0 +1,63 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2014 Paul Sokolovsky
+ * Copyright (c) 2015 Daniel Campora
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/mpconfig.h"
+#include "py/nlr.h"
+#include "py/runtime.h"
+#include "py/binary.h"
+#include "extmod/modubinascii.h"
+#include "modubinascii.h"
+#include "inc/hw_types.h"
+#include "inc/hw_ints.h"
+#include "inc/hw_nvic.h"
+#include "inc/hw_dthe.h"
+#include "hw_memmap.h"
+#include "rom_map.h"
+#include "prcm.h"
+#include "crc.h"
+#include "cryptohash.h"
+#include "mpexception.h"
+
+
+/******************************************************************************/
+// Micro Python bindings
+
+STATIC const mp_map_elem_t mp_module_binascii_globals_table[] = {
+    { MP_OBJ_NEW_QSTR(MP_QSTR___name__),        MP_OBJ_NEW_QSTR(MP_QSTR_ubinascii) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_hexlify),         (mp_obj_t)&mod_binascii_hexlify_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_unhexlify),       (mp_obj_t)&mod_binascii_unhexlify_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_a2b_base64),      (mp_obj_t)&mod_binascii_a2b_base64_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_b2a_base64),      (mp_obj_t)&mod_binascii_b2a_base64_obj },
+};
+
+STATIC MP_DEFINE_CONST_DICT(mp_module_binascii_globals, mp_module_binascii_globals_table);
+
+const mp_obj_module_t mp_module_ubinascii = {
+    .base = { &mp_type_module },
+    .name = MP_QSTR_ubinascii,
+    .globals = (mp_obj_dict_t*)&mp_module_binascii_globals,
+};
--- a/cc3200/mods/modubinascii.h
+++ b/cc3200/mods/modubinascii.h
@@ -0,0 +1,31 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2014 Paul Sokolovsky
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MODUBINASCII_H_
+#define MODUBINASCII_H_
+
+
+#endif /* MODUBINASCII_H_ */
--- a/cc3200/mods/moduhashlib.c
+++ b/cc3200/mods/moduhashlib.c
@@ -0,0 +1,210 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2014 Paul Sokolovsky
+ * Copyright (c) 2015 Daniel Campora
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <assert.h>
+#include <string.h>
+
+#include "py/mpconfig.h"
+#include MICROPY_HAL_H
+#include "py/nlr.h"
+#include "py/runtime.h"
+#include "inc/hw_types.h"
+#include "inc/hw_ints.h"
+#include "inc/hw_nvic.h"
+#include "inc/hw_shamd5.h"
+#include "inc/hw_dthe.h"
+#include "hw_memmap.h"
+#include "rom_map.h"
+#include "prcm.h"
+#include "shamd5.h"
+#include "cryptohash.h"
+#include "mpexception.h"
+
+
+/******************************************************************************
+ DEFINE PRIVATE TYPES
+ ******************************************************************************/
+typedef struct _mp_obj_hash_t {
+    mp_obj_base_t base;
+    uint8_t *buffer;
+    uint32_t b_size;
+    uint32_t c_size;
+    uint8_t  algo;
+    uint8_t  h_size;
+    bool  fixedlen;
+    bool  digested;
+    uint8_t hash[32];
+} mp_obj_hash_t;
+
+/******************************************************************************
+ DECLARE PRIVATE FUNCTIONS
+ ******************************************************************************/
+STATIC void hash_update_internal(mp_obj_t self_in, mp_obj_t data, bool digest);
+STATIC mp_obj_t hash_read (mp_obj_t self_in);
+
+/******************************************************************************
+ DEFINE PRIVATE FUNCTIONS
+ ******************************************************************************/
+STATIC void hash_update_internal(mp_obj_t self_in, mp_obj_t data, bool digest) {
+    mp_obj_hash_t *self = self_in;
+    mp_buffer_info_t bufinfo;
+
+    if (data) {
+        mp_get_buffer_raise(data, &bufinfo, MP_BUFFER_READ);
+    }
+
+    if (digest) {
+        CRYPTOHASH_SHAMD5Start (self->algo, self->b_size);
+    }
+
+    if (self->c_size < self->b_size || !data || !self->fixedlen) {
+        if (digest || self->fixedlen) {
+            // no data means we want to process our internal buffer
+            CRYPTOHASH_SHAMD5Update (data ? bufinfo.buf : self->buffer, data ? bufinfo.len : self->b_size);
+            self->c_size += data ? bufinfo.len : 0;
+        } else {
+            self->buffer = m_renew(byte, self->buffer, self->b_size, self->b_size + bufinfo.len);
+            mp_seq_copy((byte*)self->buffer + self->b_size, bufinfo.buf, bufinfo.len, byte);
+            self->b_size += bufinfo.len;
+            self->digested = false;
+        }
+    } else {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_request_not_possible));
+    }
+}
+
+STATIC mp_obj_t hash_read (mp_obj_t self_in) {
+    mp_obj_hash_t *self = self_in;
+
+    if (!self->fixedlen) {
+        if (!self->digested) {
+            hash_update_internal(self, MP_OBJ_NULL, true);
+        }
+    } else if (self->c_size < self->b_size) {
+        // it's a fixed len block which is still incomplete
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_request_not_possible));
+    }
+
+    if (!self->digested) {
+        CRYPTOHASH_SHAMD5Read ((uint8_t *)self->hash);
+        self->digested = true;
+    }
+    return mp_obj_new_bytes(self->hash, self->h_size);
+}
+
+/******************************************************************************/
+// Micro Python bindings
+
+/// \classmethod \constructor([data[, block_size]])
+/// initial data must be given if block_size wants to be passed
+STATIC mp_obj_t hash_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
+    mp_arg_check_num(n_args, n_kw, 0, 2, false);
+    mp_obj_hash_t *self = m_new0(mp_obj_hash_t, 1);
+    self->base.type = type_in;
+    if (self->base.type->name == MP_QSTR_sha1) {
+        self->algo = SHAMD5_ALGO_SHA1;
+        self->h_size = 20;
+    } else /* if (self->base.type->name == MP_QSTR_sha256) */ {
+        self->algo = SHAMD5_ALGO_SHA256;
+        self->h_size = 32;
+    } /* else {
+        self->algo = SHAMD5_ALGO_MD5;
+        self->h_size = 32;
+    } */
+
+    if (n_args) {
+        // CPython extension to avoid buffering the data before digesting it
+        // Note: care must be taken to provide all intermediate blocks as multiple
+        //       of four bytes, otherwise the resulting hash will be incorrect.
+        //       the final block can be of any length
+        if (n_args > 1) {
+            // block size given, we will feed the data directly into the hash engine
+            self->fixedlen = true;
+            self->b_size = mp_obj_get_int(args[1]);
+            hash_update_internal(self, args[0], true);
+        } else {
+            hash_update_internal(self, args[0], false);
+        }
+    }
+    return self;
+}
+
+STATIC mp_obj_t hash_update(mp_obj_t self_in, mp_obj_t arg) {
+    mp_obj_hash_t *self = self_in;
+    hash_update_internal(self, arg, false);
+    return mp_const_none;
+}
+MP_DEFINE_CONST_FUN_OBJ_2(hash_update_obj, hash_update);
+
+STATIC mp_obj_t hash_digest(mp_obj_t self_in) {
+    return hash_read(self_in);
+}
+MP_DEFINE_CONST_FUN_OBJ_1(hash_digest_obj, hash_digest);
+
+STATIC const mp_map_elem_t hash_locals_dict_table[] = {
+    { MP_OBJ_NEW_QSTR(MP_QSTR_update),    (mp_obj_t) &hash_update_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_digest),    (mp_obj_t) &hash_digest_obj },
+};
+
+STATIC MP_DEFINE_CONST_DICT(hash_locals_dict, hash_locals_dict_table);
+
+//STATIC const mp_obj_type_t md5_type = {
+//    { &mp_type_type },
+//    .name = MP_QSTR_md5,
+//    .make_new = hash_make_new,
+//    .locals_dict = (mp_obj_t)&hash_locals_dict,
+//};
+
+STATIC const mp_obj_type_t sha1_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_sha1,
+    .make_new = hash_make_new,
+    .locals_dict = (mp_obj_t)&hash_locals_dict,
+};
+
+STATIC const mp_obj_type_t sha256_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_sha256,
+    .make_new = hash_make_new,
+    .locals_dict = (mp_obj_t)&hash_locals_dict,
+};
+
+STATIC const mp_map_elem_t mp_module_hashlib_globals_table[] = {
+    { MP_OBJ_NEW_QSTR(MP_QSTR___name__),    MP_OBJ_NEW_QSTR(MP_QSTR_uhashlib) },
+//    { MP_OBJ_NEW_QSTR(MP_QSTR_md5),         (mp_obj_t)&md5_type },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_sha1),        (mp_obj_t)&sha1_type },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_sha256),      (mp_obj_t)&sha256_type },
+};
+
+STATIC MP_DEFINE_CONST_DICT(mp_module_hashlib_globals, mp_module_hashlib_globals_table);
+
+const mp_obj_module_t mp_module_uhashlib = {
+    .base = { &mp_type_module },
+    .name = MP_QSTR_uhashlib,
+    .globals = (mp_obj_dict_t*)&mp_module_hashlib_globals,
+};
+
--- a/cc3200/mods/moduos.c
+++ b/cc3200/mods/moduos.c
@@ -28,18 +28,22 @@
 #include <stdint.h>
 #include <string.h>

-#include "py/mpconfig.h"
+#include "py/mpstate.h"
 #include "py/nlr.h"
-#include "py/obj.h"
 #include "py/objtuple.h"
-#include "ff.h"
+#include "py/objstr.h"
+#include "py/runtime.h"
+#include "genhdr/mpversion.h"
+#include "moduos.h"
 #include "diskio.h"
 #include "sflash_diskio.h"
-#include "file.h"
-#include "modutime.h"
+#include "extmod/vfs_fat_file.h"
 #include "random.h"
-#include "sd_diskio.h"
 #include "mpexception.h"
+#include "version.h"
+#include "timeutils.h"
+#include "pybsd.h"
+#include "pybuart.h"

 /// \module os - basic "operating system" services
 ///
@@ -49,26 +53,192 @@
 /// drives are accessible from here.  They are currently:
 ///
 ///     /flash      -- the serial flash filesystem
-///     /sd         -- the SD card (if it exists)
 ///
-/// On boot up, the current directory is `/flash` if no SD card is inserted,
-/// otherwise it is `/sd`.
+/// On boot up, the current directory is `/flash`.
+
+/******************************************************************************
+ DECLARE PRIVATE DATA
+ ******************************************************************************/
+STATIC uint32_t os_num_mounted_devices;
+STATIC os_term_dup_obj_t os_term_dup_obj;
+
+/******************************************************************************
+ DECLARE PRIVATE FUNCTIONS
+ ******************************************************************************/
+STATIC void unmount (os_fs_mount_t *mount_obj);
+STATIC bool path_equal(const char *path, const char *path_canonical);
+STATIC void append_dir_item (mp_obj_t dirlist, const char *item, bool string);
+STATIC void mount (mp_obj_t device, const char *path, uint pathlen, bool readonly);
+
+/******************************************************************************
+ DEFINE PUBLIC FUNCTIONS
+ ******************************************************************************/
+
+void moduos_init0 (void) {
+    // initialize the mount objects list
+    mp_obj_list_init(&MP_STATE_PORT(mount_obj_list), 0);
+    os_num_mounted_devices = 0;
+}
+
+os_fs_mount_t *osmount_find_by_path (const char *path) {
+    for (mp_uint_t i = 0; i < MP_STATE_PORT(mount_obj_list).len; i++) {
+        os_fs_mount_t *mount_obj = ((os_fs_mount_t *)(MP_STATE_PORT(mount_obj_list).items[i]));
+        if (!strcmp(path, mount_obj->path)) {
+            return mount_obj;
+        }
+    }
+    return NULL;
+}
+
+os_fs_mount_t *osmount_find_by_volume (uint8_t vol) {
+    for (mp_uint_t i = 0; i < MP_STATE_PORT(mount_obj_list).len; i++) {
+        os_fs_mount_t *mount_obj = ((os_fs_mount_t *)(MP_STATE_PORT(mount_obj_list).items[i]));
+        if (vol == mount_obj->vol) {
+            return mount_obj;
+        }
+    }
+    return NULL;
+}
+
+os_fs_mount_t *osmount_find_by_device (mp_obj_t device) {
+    for (mp_uint_t i = 0; i < MP_STATE_PORT(mount_obj_list).len; i++) {
+        os_fs_mount_t *mount_obj = ((os_fs_mount_t *)(MP_STATE_PORT(mount_obj_list).items[i]));
+        if (device == mount_obj->device) {
+            return mount_obj;
+        }
+    }
+    return NULL;
+}
+
+void osmount_unmount_all (void) {
+    for (mp_uint_t i = 0; i < MP_STATE_PORT(mount_obj_list).len; i++) {
+        os_fs_mount_t *mount_obj = ((os_fs_mount_t *)(MP_STATE_PORT(mount_obj_list).items[i]));
+        unmount(mount_obj);
+    }
+}

 /******************************************************************************
 DEFINE PRIVATE FUNCTIONS
 ******************************************************************************/
-STATIC bool sd_in_root(void) {
-#if MICROPY_HW_HAS_SDCARD
-    return sd_disk_ready();
-#else
-    return false;
+
+// Checks for path equality, ignoring trailing slashes:
+//   path_equal(/, /) -> true
+//   path_equal(/flash//, /flash) -> true
+// second argument must be in canonical form (meaning no trailing slash, unless it's just /)
+STATIC bool path_equal(const char *path, const char *path_canonical) {
+    for (; *path_canonical != '\0' && *path == *path_canonical; ++path, ++path_canonical) {
+    }
+    if (*path_canonical != '\0') {
+        return false;
+    }
+    for (; *path == '/'; ++path) {
+    }
+    return *path == '\0';
+}
+
+STATIC void append_dir_item (mp_obj_t dirlist, const char *item, bool string) {
+    // make a string object for this entry
+    mp_obj_t entry_o;
+    if (string) {
+        entry_o = mp_obj_new_str(item, strlen(item), false);
+    } else {
+        entry_o = mp_obj_new_bytes((const byte*)item, strlen(item));
+    }
+
+    // add the entry to the list
+    mp_obj_list_append(dirlist, entry_o);
+}
+
+STATIC void mount (mp_obj_t device, const char *path, uint pathlen, bool readonly) {
+    // is the mount point already in use?
+    FILINFO fno;
+#if _USE_LFN
+    fno.lfname = NULL;
+    fno.lfsize = 0;
 #endif
+    // cannot mount twice or on existing paths
+    if (f_stat(path, &fno) == FR_OK || osmount_find_by_device(device)) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_request_not_possible));
+    }
+
+    // create a new object
+    os_fs_mount_t *self = m_new_obj(os_fs_mount_t);
+    self->device = device;
+    self->path = path;
+    self->pathlen = pathlen;
+    self->vol = os_num_mounted_devices + 1;     // '/flash' is volume 0
+
+    if (device == (mp_obj_t)&pybsd_obj) {
+        // need to make it different to NULL, otherwise it's read only by default
+        self->writeblocks[0] = mp_const_none;
+        self->sync[0] = MP_OBJ_NULL;    // no need to sync the SD card
+        self->count[0] = MP_OBJ_NULL;
+    } else {
+        // load block protocol methods
+        mp_load_method(device, MP_QSTR_readblocks, self->readblocks);
+        mp_load_method_maybe(device, MP_QSTR_writeblocks, self->writeblocks);
+        mp_load_method_maybe(device, MP_QSTR_sync, self->sync);
+        mp_load_method(device, MP_QSTR_count, self->count);
+    }
+
+    // Read-only device indicated by writeblocks[0] == MP_OBJ_NULL.
+    // User can specify read-only device by:
+    //  1. readonly=True keyword argument
+    //  2. nonexistent writeblocks method (then writeblocks[0] == MP_OBJ_NULL already)
+    if (readonly) {
+        self->writeblocks[0] = MP_OBJ_NULL;
+    }
+
+    // we need to add it before doing the actual mount, so that the volume can be found
+    mp_obj_list_append(&MP_STATE_PORT(mount_obj_list), self);
+
+    // actually mount it
+    if (f_mount(&self->fatfs, self->path, 1) != FR_OK) {
+        // remove it and raise
+        mp_obj_list_remove(&MP_STATE_PORT(mount_obj_list), self);
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_operation_failed));
+    }
+
+    // mount succeeded, increment the count
+    os_num_mounted_devices++;
+}
+
+STATIC void unmount (os_fs_mount_t *mount_obj) {
+    // remove it from the list and then call FatFs
+    f_mount (NULL, mount_obj->path, 1);
+    mp_obj_list_remove(&MP_STATE_PORT(mount_obj_list), mount_obj);
+    os_num_mounted_devices--;
 }

 /******************************************************************************/
 // Micro Python bindings
 //

+STATIC const qstr os_uname_info_fields[] = {
+    MP_QSTR_sysname, MP_QSTR_nodename,
+    MP_QSTR_release, MP_QSTR_version, MP_QSTR_machine
+};
+STATIC const MP_DEFINE_STR_OBJ(os_uname_info_sysname_obj, MICROPY_PY_SYS_PLATFORM);
+STATIC const MP_DEFINE_STR_OBJ(os_uname_info_nodename_obj, MICROPY_PY_SYS_PLATFORM);
+STATIC const MP_DEFINE_STR_OBJ(os_uname_info_release_obj, WIPY_SW_VERSION_NUMBER);
+STATIC const MP_DEFINE_STR_OBJ(os_uname_info_version_obj, MICROPY_GIT_TAG " on " MICROPY_BUILD_DATE);
+STATIC const MP_DEFINE_STR_OBJ(os_uname_info_machine_obj, MICROPY_HW_BOARD_NAME " with " MICROPY_HW_MCU_NAME);
+STATIC MP_DEFINE_ATTRTUPLE(
+    os_uname_info_obj,
+    os_uname_info_fields,
+    5,
+    (mp_obj_t)&os_uname_info_sysname_obj,
+    (mp_obj_t)&os_uname_info_nodename_obj,
+    (mp_obj_t)&os_uname_info_release_obj,
+    (mp_obj_t)&os_uname_info_version_obj,
+    (mp_obj_t)&os_uname_info_machine_obj
+);
+
+STATIC mp_obj_t os_uname(void) {
+    return (mp_obj_t)&os_uname_info_obj;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(os_uname_obj, os_uname);
+
 /// \function chdir(path)
 /// Change current directory.
 STATIC mp_obj_t os_chdir(mp_obj_t path_in) {
@@ -89,25 +259,20 @@ STATIC mp_obj_t os_chdir(mp_obj_t path_in) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(os_chdir_obj, os_chdir);

-/// \function getcwd()
-/// Get the current directory.
 STATIC mp_obj_t os_getcwd(void) {
    char buf[MICROPY_ALLOC_PATH_MAX + 1];
    FRESULT res = f_getcwd(buf, sizeof buf);
-
    if (res != FR_OK) {
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(fresult_to_errno_table[res])));
    }
-
    return mp_obj_new_str(buf, strlen(buf), false);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_0(os_getcwd_obj, os_getcwd);

-/// \function listdir([dir])
-/// With no argument, list the current directory.  Otherwise list the given directory.
 STATIC mp_obj_t os_listdir(mp_uint_t n_args, const mp_obj_t *args) {
    bool is_str_type = true;
    const char *path;
+    mp_obj_t dir_list = mp_obj_new_list(0, NULL);

    if (n_args == 1) {
        if (mp_obj_get_type(args[0]) == &mp_type_bytes) {
@@ -118,64 +283,51 @@ STATIC mp_obj_t os_listdir(mp_uint_t n_args, const mp_obj_t *args) {
        path = "";
    }

-    // "hack" to list root directory
+    // "hack" to list the root directory
    if (path[0] == '/' && path[1] == '\0') {
-        mp_obj_t dir_list = mp_obj_new_list(0, NULL);
-        mp_obj_list_append(dir_list, MP_OBJ_NEW_QSTR(MP_QSTR_flash));
-        if (sd_in_root()) {
-            mp_obj_list_append(dir_list, MP_OBJ_NEW_QSTR(MP_QSTR_sd));
+        // add 'flash' to the list
+        append_dir_item (dir_list, "flash", is_str_type);
+        for (mp_uint_t i = 0; i < MP_STATE_PORT(mount_obj_list).len; i++) {
+            os_fs_mount_t *mount_obj = ((os_fs_mount_t *)(MP_STATE_PORT(mount_obj_list).items[i]));
+            append_dir_item (dir_list, &mount_obj->path[1], is_str_type);
        }
-        return dir_list;
-    }
+    } else {
+        FRESULT res;
+        DIR dir;
+        FILINFO fno;
+    #if _USE_LFN
+        char lfn_buf[_MAX_LFN + 1];
+        fno.lfname = lfn_buf;
+        fno.lfsize = sizeof(lfn_buf);
+    #endif

-    FRESULT res;
-    DIR dir;
-    FILINFO fno;
-#if _USE_LFN
-    char lfn_buf[_MAX_LFN + 1];
-    fno.lfname = lfn_buf;
-    fno.lfsize = sizeof(lfn_buf);
-#endif
-
-    res = f_opendir(&dir, path);                       /* Open the directory */
-    if (res != FR_OK) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_operation_failed));
-    }
-
-    mp_obj_t dir_list = mp_obj_new_list(0, NULL);
-
-    for (;;) {
-        res = f_readdir(&dir, &fno);                   /* Read a directory item */
-        if (res != FR_OK || fno.fname[0] == 0) break;  /* Break on error or end of dir */
-        if (fno.fname[0] == '.' && fno.fname[1] == 0) continue;             /* Ignore . entry */
-        if (fno.fname[0] == '.' && fno.fname[1] == '.' && fno.fname[2] == 0) continue;             /* Ignore .. entry */
-
-#if _USE_LFN
-        char *fn = *fno.lfname ? fno.lfname : fno.fname;
-#else
-        char *fn = fno.fname;
-#endif
-
-        // make a string object for this entry
-        mp_obj_t entry_o;
-        if (is_str_type) {
-            entry_o = mp_obj_new_str(fn, strlen(fn), false);
-        } else {
-            entry_o = mp_obj_new_bytes((const byte*)fn, strlen(fn));
+        res = f_opendir(&dir, path);                       /* Open the directory */
+        if (res != FR_OK) {
+            nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_operation_failed));
        }

-        // add the entry to the list
-        mp_obj_list_append(dir_list, entry_o);
-    }
+        for ( ; ; ) {
+            res = f_readdir(&dir, &fno);                   /* Read a directory item */
+            if (res != FR_OK || fno.fname[0] == 0) break;  /* Break on error or end of dir */
+            if (fno.fname[0] == '.' && fno.fname[1] == 0) continue;             /* Ignore . entry */
+            if (fno.fname[0] == '.' && fno.fname[1] == '.' && fno.fname[2] == 0) continue;             /* Ignore .. entry */

-    f_closedir(&dir);
+        #if _USE_LFN
+            char *fn = *fno.lfname ? fno.lfname : fno.fname;
+        #else
+            char *fn = fno.fname;
+        #endif
+
+            // add the entry to the list
+            append_dir_item (dir_list, fn, is_str_type);
+        }
+        f_closedir(&dir);
+    }

    return dir_list;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(os_listdir_obj, 0, 1, os_listdir);

-/// \function mkdir(path)
-/// Create a new directory.
 STATIC mp_obj_t os_mkdir(mp_obj_t path_o) {
    const char *path = mp_obj_str_get_str(path_o);
    FRESULT res = f_mkdir(path);
@@ -191,8 +343,19 @@ STATIC mp_obj_t os_mkdir(mp_obj_t path_o) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(os_mkdir_obj, os_mkdir);

-/// \function remove(path)
-/// Remove a file or a directory
+STATIC mp_obj_t os_rename(mp_obj_t path_in, mp_obj_t path_out) {
+    const char *old_path = mp_obj_str_get_str(path_in);
+    const char *new_path = mp_obj_str_get_str(path_out);
+    FRESULT res = f_rename(old_path, new_path);
+    switch (res) {
+        case FR_OK:
+            return mp_const_none;
+        default:
+            nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_operation_failed));
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(os_rename_obj, os_rename);
+
 STATIC mp_obj_t os_remove(mp_obj_t path_o) {
    const char *path = mp_obj_str_get_str(path_o);
    FRESULT res = f_unlink(path);
@@ -205,49 +368,33 @@ STATIC mp_obj_t os_remove(mp_obj_t path_o) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(os_remove_obj, os_remove);

-// Checks for path equality, ignoring trailing slashes:
-//   path_equal(/, /) -> true
-//   path_equal(/flash//, /flash) -> true
-// second argument must be in canonical form (meaning no trailing slash, unless it's just /)
-STATIC bool path_equal(const char *path, const char *path_canonical) {
-    for (; *path_canonical != '\0' && *path == *path_canonical; ++path, ++path_canonical) {
-    }
-    if (*path_canonical != '\0') {
-        return false;
-    }
-    for (; *path == '/'; ++path) {
-    }
-    return *path == '\0';
-}
-
-/// \function stat(path)
-/// Get the status of a file or directory.
 STATIC mp_obj_t os_stat(mp_obj_t path_in) {
    const char *path = mp_obj_str_get_str(path_in);
-
-    FRESULT res;
+    bool isbuilt_in = false;
    FILINFO fno;
+    FRESULT res;
 #if _USE_LFN
    fno.lfname = NULL;
    fno.lfsize = 0;
 #endif

-    if (path_equal(path, "/") || path_equal(path, "/flash") || path_equal(path, "/sd")) {
+    // check on the user mounted devices
+    for (mp_uint_t i = 0; i < MP_STATE_PORT(mount_obj_list).len; i++) {
+        os_fs_mount_t *mount_obj = ((os_fs_mount_t *)(MP_STATE_PORT(mount_obj_list).items[i]));
+        if (path_equal(path, mount_obj->path)) {
+            isbuilt_in = true;
+            break;
+        }
+    }
+
+    if (path_equal(path, "/") || path_equal(path, "/flash") || isbuilt_in) {
        // stat built-in directory
-        if (path[1] == 's' && !sd_in_root()) {
-            // no /sd directory
-            res = FR_NO_PATH;
-            goto error;
-        }
-	fno.fsize = 0;
-	fno.fdate = 0;
-	fno.ftime = 0;
-	fno.fattrib = AM_DIR;
-    } else {
-        res = f_stat(path, &fno);
-        if (res != FR_OK) {
-            goto error;
-        }
+        fno.fsize = 0;
+        fno.fdate = 0;
+        fno.ftime = 0;
+        fno.fattrib = AM_DIR;
+    } else if ((res = f_stat(path, &fno)) != FR_OK) {
+        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(fresult_to_errno_table[res])));
    }

    mp_obj_tuple_t *t = mp_obj_new_tuple(10, NULL);
@@ -257,7 +404,7 @@ STATIC mp_obj_t os_stat(mp_obj_t path_in) {
    } else {
        mode |= 0x8000; // stat.S_IFREG
    }
-    mp_int_t seconds = mod_time_seconds_since_2000(
+    mp_int_t seconds = timeutils_seconds_since_2000(
        1980 + ((fno.fdate >> 9) & 0x7f),
        (fno.fdate >> 5) & 0x0f,
        fno.fdate & 0x1f,
@@ -275,26 +422,16 @@ STATIC mp_obj_t os_stat(mp_obj_t path_in) {
    t->items[7] = mp_obj_new_int(seconds);   // st_atime
    t->items[8] = t->items[7];               // st_mtime
    t->items[9] = t->items[7];               // st_ctime
-
    return t;
-
-error:
-    nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(fresult_to_errno_table[res])));
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(os_stat_obj, os_stat);

-/// \function sync()
-/// Sync all filesystems.
 STATIC mp_obj_t os_sync(void) {
    sflash_disk_flush();
    return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_0(os_sync_obj, os_sync);

-#if MICROPY_HW_ENABLE_RNG
-/// \function urandom(n)
-/// Return a bytes object with n random bytes, generated by the hardware
-/// random number generator.
 STATIC mp_obj_t os_urandom(mp_obj_t num) {
    mp_int_t n = mp_obj_get_int(num);
    vstr_t vstr;
@@ -305,35 +442,157 @@ STATIC mp_obj_t os_urandom(mp_obj_t num) {
    return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(os_urandom_obj, os_urandom);
-#endif

-/// \function mkdisk('path')
-/// Formats the selected drive, useful when the filesystem has been damaged beyond repair
-STATIC mp_obj_t os_mkdisk(mp_obj_t path_o) {
+STATIC mp_obj_t os_mount(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    static const mp_arg_t mount_args[] = {
+        { MP_QSTR_readonly,     MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = false} },
+    };
+
+    // parse args
+    mp_obj_t device = pos_args[0];
+    mp_obj_t mount_point = pos_args[1];
+    mp_arg_val_t args[MP_ARRAY_SIZE(mount_args)];
+    mp_arg_parse_all(n_args - 2, pos_args + 2, kw_args, MP_ARRAY_SIZE(mount_args), mount_args, args);
+
+    // get the mount point
+    mp_uint_t pathlen;
+    const char *path_in = mp_obj_str_get_data(mount_point, &pathlen);
+    if (pathlen == 0) {
+        goto invalid_args;
+    }
+
+    char *path = m_new(char, pathlen + 1);
+    memcpy(path, path_in, pathlen);
+    path[pathlen] = '\0';
+
+    // "remove" any extra slahes at the end
+    while (path[(pathlen - 1)] == '/') {
+        path[--pathlen] = '\0';
+    }
+
+    // is the mount point valid?
+    if (pathlen < 2 || path[0] !='/' || strchr(&path[1], '/')) {
+        goto invalid_args;
+    }
+
+    // now mount it
+    mount(device, path, pathlen, args[0].u_bool);
+
+    return mp_const_none;
+
+invalid_args:
+    nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_value_invalid_arguments));
+}
+MP_DEFINE_CONST_FUN_OBJ_KW(os_mount_obj, 2, os_mount);
+
+STATIC mp_obj_t os_unmount(mp_obj_t path_o) {
    const char *path = mp_obj_str_get_str(path_o);
-    if (FR_OK != f_mkfs(path, 1, 0)) {
+
+    // '/flash' cannot be unmounted, also not the current working directory
+    if (path_equal(path, "/flash")) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_request_not_possible));
+    }
+
+    // now unmount it
+    os_fs_mount_t *mount_obj;
+    if ((mount_obj = osmount_find_by_path(path))) {
+        unmount (mount_obj);
+    } else {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
+    }
+
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(os_unmount_obj, os_unmount);
+
+STATIC mp_obj_t os_mkfs(mp_obj_t device) {
+    const char *path = "/__mkfs__mnt__";
+    os_fs_mount_t *mount_obj = NULL;
+    bool unmt = false;
+    FRESULT res;
+
+    if (MP_OBJ_IS_STR_OR_BYTES(device)) {
+        path = mp_obj_str_get_str(device);
+        // otherwise the relative path check will pass...
+        if (path[0] != '/') {
+            nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_value_invalid_arguments));
+        }
+    } else {
+        // mount it briefly
+        mount(device, path, strlen(path), false);
+        unmt = true;
+    }
+
+    byte sfd = 0;
+    if (!memcmp(path, "/flash", strlen("/flash"))) {
+        sfd = 1;
+    } else if ((mount_obj = osmount_find_by_path(path))) {
+        if (mount_obj->device != (mp_obj_t)&pybsd_obj &&
+            mp_obj_get_int(mp_call_method_n_kw(0, 0, mount_obj->count)) < 2048) {
+            sfd = 1;
+        }
+    }
+
+    // now format the device
+    res = f_mkfs(path, sfd, 0);
+
+    if (unmt && mount_obj) {
+        unmount (mount_obj);
+    }
+
+    if (res != FR_OK) {
        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_operation_failed));
    }
    return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(os_mkdisk_obj, os_mkdisk);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(os_mkfs_obj, os_mkfs);
+
+STATIC mp_obj_t os_dupterm(uint n_args, const mp_obj_t *args) {
+    if (n_args == 0) {
+        if (MP_STATE_PORT(os_term_dup_obj) == MP_OBJ_NULL) {
+            return mp_const_none;
+        } else {
+            return MP_STATE_PORT(os_term_dup_obj)->stream_o;
+        }
+    } else {
+        mp_obj_t stream_o = args[0];
+        if (stream_o == mp_const_none) {
+            MP_STATE_PORT(os_term_dup_obj) = MP_OBJ_NULL;
+        } else {
+            if (!MP_OBJ_IS_TYPE(stream_o, &pyb_uart_type)) {
+                // must be a stream-like object providing at least read and write methods
+                mp_load_method(stream_o, MP_QSTR_read, os_term_dup_obj.read);
+                mp_load_method(stream_o, MP_QSTR_write, os_term_dup_obj.write);
+            }
+            os_term_dup_obj.stream_o = stream_o;
+            MP_STATE_PORT(os_term_dup_obj) = &os_term_dup_obj;
+        }
+        return mp_const_none;
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(os_dupterm_obj, 0, 1, os_dupterm);

 STATIC const mp_map_elem_t os_module_globals_table[] = {
    { MP_OBJ_NEW_QSTR(MP_QSTR___name__),        MP_OBJ_NEW_QSTR(MP_QSTR_uos) },

+    { MP_OBJ_NEW_QSTR(MP_QSTR_uname),           (mp_obj_t)&os_uname_obj },
    { MP_OBJ_NEW_QSTR(MP_QSTR_chdir),           (mp_obj_t)&os_chdir_obj },
    { MP_OBJ_NEW_QSTR(MP_QSTR_getcwd),          (mp_obj_t)&os_getcwd_obj },
    { MP_OBJ_NEW_QSTR(MP_QSTR_listdir),         (mp_obj_t)&os_listdir_obj },
    { MP_OBJ_NEW_QSTR(MP_QSTR_mkdir),           (mp_obj_t)&os_mkdir_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_rename),          (mp_obj_t)&os_rename_obj},
    { MP_OBJ_NEW_QSTR(MP_QSTR_remove),          (mp_obj_t)&os_remove_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_rmdir),           (mp_obj_t)&os_remove_obj },  // rmdir aliases to remove
+    { MP_OBJ_NEW_QSTR(MP_QSTR_rmdir),           (mp_obj_t)&os_remove_obj },     // rmdir aliases to remove
    { MP_OBJ_NEW_QSTR(MP_QSTR_stat),            (mp_obj_t)&os_stat_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_unlink),          (mp_obj_t)&os_remove_obj },  // unlink aliases to remove
+    { MP_OBJ_NEW_QSTR(MP_QSTR_unlink),          (mp_obj_t)&os_remove_obj },     // unlink aliases to remove
    { MP_OBJ_NEW_QSTR(MP_QSTR_sync),            (mp_obj_t)&os_sync_obj },
-#if MICROPY_HW_ENABLE_RNG
    { MP_OBJ_NEW_QSTR(MP_QSTR_urandom),         (mp_obj_t)&os_urandom_obj },
-#endif
-    { MP_OBJ_NEW_QSTR(MP_QSTR_mkdisk),          (mp_obj_t)&os_mkdisk_obj },
+
+    // MicroPython additions
+    { MP_OBJ_NEW_QSTR(MP_QSTR_mount),           (mp_obj_t)&os_mount_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_unmount),         (mp_obj_t)&os_unmount_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_mkfs),            (mp_obj_t)&os_mkfs_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_dupterm),         (mp_obj_t)&os_dupterm_obj },

    /// \constant sep - separation character used in paths
    { MP_OBJ_NEW_QSTR(MP_QSTR_sep),             MP_OBJ_NEW_QSTR(MP_QSTR__slash_) },
--- a/cc3200/mods/moduos.h
+++ b/cc3200/mods/moduos.h
@@ -28,5 +28,35 @@
 #ifndef MODUOS_H_
 #define MODUOS_H_

+#include "ff.h"
+
+/******************************************************************************
+ DEFINE PUBLIC TYPES
+ ******************************************************************************/
+typedef struct _os_fs_mount_t {
+    mp_obj_t device;
+    const char *path;
+    mp_uint_t pathlen;
+    mp_obj_t readblocks[4];
+    mp_obj_t writeblocks[4];
+    mp_obj_t sync[2];
+    mp_obj_t count[2];
+    FATFS fatfs;
+    uint8_t vol;
+} os_fs_mount_t;
+
+typedef struct _os_term_dup_obj_t {
+    mp_obj_t stream_o;
+    mp_obj_t read[3];
+    mp_obj_t write[3];
+} os_term_dup_obj_t;
+
+/******************************************************************************
+ DECLARE PUBLIC FUNCTIONS
+ ******************************************************************************/
+void moduos_init0 (void);
+os_fs_mount_t *osmount_find_by_path (const char *path);
+os_fs_mount_t *osmount_find_by_volume (uint8_t vol);
+void osmount_unmount_all (void);

 #endif // MODUOS_H_
--- a/cc3200/mods/modusocket.c
+++ b/cc3200/mods/modusocket.c
@@ -29,64 +29,144 @@
 #include <string.h>

 #include "simplelink.h"
-#include "py/mpstate.h"
-#include MICROPY_HAL_H
+#include "py/mpconfig.h"
+#include "py/obj.h"
+#include "py/objstr.h"
 #include "py/runtime.h"
+#include "py/stream.h"
+#include "netutils.h"
 #include "modnetwork.h"
+#include "modwlan.h"
+#include "modusocket.h"
 #include "mpexception.h"

+/******************************************************************************
+ DEFINE PRIVATE CONSTANTS
+ ******************************************************************************/
+#define MOD_NETWORK_MAX_SOCKETS                 10
+
+/******************************************************************************
+ DEFINE PRIVATE TYPES
+ ******************************************************************************/
+typedef struct {
+    int16_t sd;
+    bool    user;
+} modusocket_sock_t;
+
+/******************************************************************************
+ DEFINE PRIVATE DATA
+ ******************************************************************************/
+STATIC const mp_obj_type_t socket_type;
+STATIC OsiLockObj_t modusocket_LockObj;
+STATIC modusocket_sock_t modusocket_sockets[MOD_NETWORK_MAX_SOCKETS] = {{.sd = -1}, {.sd = -1}, {.sd = -1}, {.sd = -1}, {.sd = -1},
+                                                                        {.sd = -1}, {.sd = -1}, {.sd = -1}, {.sd = -1}, {.sd = -1}};
+
+/******************************************************************************
+ DEFINE PUBLIC FUNCTIONS
+ ******************************************************************************/
+__attribute__ ((section (".boot")))
+void modusocket_pre_init (void) {
+    // create the wlan lock
+    ASSERT(OSI_OK == sl_LockObjCreate(&modusocket_LockObj, "SockLock"));
+    sl_LockObjUnlock (&modusocket_LockObj);
+}
+
+void modusocket_socket_add (int16_t sd, bool user) {
+    sl_LockObjLock (&modusocket_LockObj, SL_OS_WAIT_FOREVER);
+    for (int i = 0; i < MOD_NETWORK_MAX_SOCKETS; i++) {
+        if (modusocket_sockets[i].sd < 0) {
+            modusocket_sockets[i].sd = sd;
+            modusocket_sockets[i].user = user;
+            break;
+        }
+    }
+    sl_LockObjUnlock (&modusocket_LockObj);
+}
+
+void modusocket_socket_delete (int16_t sd) {
+    sl_LockObjLock (&modusocket_LockObj, SL_OS_WAIT_FOREVER);
+    for (int i = 0; i < MOD_NETWORK_MAX_SOCKETS; i++) {
+        if (modusocket_sockets[i].sd == sd) {
+            modusocket_sockets[i].sd = -1;
+            break;
+        }
+    }
+    sl_LockObjUnlock (&modusocket_LockObj);
+}
+
+void modusocket_enter_sleep (void) {
+    fd_set socketset;
+    int16_t maxfd = 0;
+
+    for (int i = 0; i < MOD_NETWORK_MAX_SOCKETS; i++) {
+        int16_t sd;
+        if ((sd = modusocket_sockets[i].sd) >= 0) {
+            FD_SET(sd, &socketset);
+            maxfd = (maxfd > sd) ? maxfd : sd;
+        }
+    }
+
+    if (maxfd > 0) {
+        // wait for any of the sockets to become ready...
+        sl_Select(maxfd + 1, &socketset, NULL, NULL, NULL);
+    }
+}
+
+void modusocket_close_all_user_sockets (void) {
+    sl_LockObjLock (&modusocket_LockObj, SL_OS_WAIT_FOREVER);
+    for (int i = 0; i < MOD_NETWORK_MAX_SOCKETS; i++) {
+        if (modusocket_sockets[i].sd >= 0 && modusocket_sockets[i].user) {
+            sl_Close(modusocket_sockets[i].sd);
+            modusocket_sockets[i].sd = -1;
+        }
+    }
+    sl_LockObjUnlock (&modusocket_LockObj);
+}
+
 /******************************************************************************/
 // socket class

-STATIC const mp_obj_type_t socket_type;
-
 // constructor socket(family=AF_INET, type=SOCK_STREAM, proto=IPPROTO_TCP, fileno=None)
-STATIC mp_obj_t socket_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
+STATIC mp_obj_t socket_make_new(const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
    mp_arg_check_num(n_args, n_kw, 0, 4, false);

-    // create socket object (not bound to any NIC yet)
+    // create socket object
    mod_network_socket_obj_t *s = m_new_obj_with_finaliser(mod_network_socket_obj_t);
    s->base.type = (mp_obj_t)&socket_type;
-    s->nic = MP_OBJ_NULL;
-    s->nic_type = NULL;
-    s->u_param.domain = AF_INET;
-    s->u_param.type = SOCK_STREAM;
-    s->u_param.proto = IPPROTO_TCP;
-    s->u_param.fileno = -1;
-    if (n_args >= 1) {
-        s->u_param.domain = mp_obj_get_int(args[0]);
-        if (n_args >= 2) {
-            s->u_param.type = mp_obj_get_int(args[1]);
-            if (n_args >= 3) {
-                s->u_param.proto = mp_obj_get_int(args[2]);
-                if (n_args == 4) {
-                    s->u_param.fileno = mp_obj_get_int(args[3]);
+    s->sock_base.u_param.domain = AF_INET;
+    s->sock_base.u_param.type = SOCK_STREAM;
+    s->sock_base.u_param.proto = IPPROTO_TCP;
+    s->sock_base.u_param.fileno = -1;
+    s->sock_base.has_timeout = false;
+    s->sock_base.cert_req = false;
+
+    if (n_args > 0) {
+        s->sock_base.u_param.domain = mp_obj_get_int(args[0]);
+        if (n_args > 1) {
+            s->sock_base.u_param.type = mp_obj_get_int(args[1]);
+            if (n_args > 2) {
+                s->sock_base.u_param.proto = mp_obj_get_int(args[2]);
+                if (n_args > 3) {
+                    s->sock_base.u_param.fileno = mp_obj_get_int(args[3]);
                }
            }
        }
    }
+
+    // create the socket
+    int _errno;
+    if (wlan_socket_socket(s, &_errno) != 0) {
+        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(-_errno)));
+    }
+    // add the socket to the list
+    modusocket_socket_add(s->sock_base.sd, true);
    return s;
 }

-STATIC void socket_select_nic(mod_network_socket_obj_t *self, const byte *ip) {
-    if (self->nic == MP_OBJ_NULL) {
-        // select NIC based on IP
-        self->nic = mod_network_find_nic(ip);
-        self->nic_type = (mod_network_nic_type_t*)mp_obj_get_type(self->nic);
-
-        // call the NIC to open the socket
-        int _errno;
-        if (self->nic_type->socket(self, &_errno) != 0) {
-            nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(_errno)));
-        }
-    }
-}
 // method socket.close()
 STATIC mp_obj_t socket_close(mp_obj_t self_in) {
    mod_network_socket_obj_t *self = self_in;
-    if (self->nic != MP_OBJ_NULL) {
-        self->nic_type->close(self);
-    }
+    wlan_socket_close(self);
    return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(socket_close_obj, socket_close);
@@ -97,67 +177,59 @@ STATIC mp_obj_t socket_bind(mp_obj_t self_in, mp_obj_t addr_in) {

    // get address
    uint8_t ip[MOD_NETWORK_IPV4ADDR_BUF_SIZE];
-    mp_uint_t port = mod_network_parse_inet_addr(addr_in, ip);
-
-    // check if we need to select a NIC
-    socket_select_nic(self, ip);
+    mp_uint_t port = netutils_parse_inet_addr(addr_in, ip, NETUTILS_LITTLE);

    // call the NIC to bind the socket
    int _errno;
-    if (self->nic_type->bind(self, ip, port, &_errno) != 0) {
-        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(_errno)));
+    if (wlan_socket_bind(self, ip, port, &_errno) != 0) {
+        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(-_errno)));
    }
-
    return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_bind_obj, socket_bind);

-// method socket.listen(backlog)
-STATIC mp_obj_t socket_listen(mp_obj_t self_in, mp_obj_t backlog) {
-    mod_network_socket_obj_t *self = self_in;
+// method socket.listen([backlog])
+STATIC mp_obj_t socket_listen(mp_uint_t n_args, const mp_obj_t *args) {
+    mod_network_socket_obj_t *self = args[0];

-    if (self->nic == MP_OBJ_NULL) {
-        // not connected
-        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(ENOTCONN)));
+    int32_t backlog = 0;
+    if (n_args > 1) {
+        backlog = mp_obj_get_int(args[1]);
+        backlog = (backlog < 0) ? 0 : backlog;
    }

    int _errno;
-    if (self->nic_type->listen(self, mp_obj_get_int(backlog), &_errno) != 0) {
-        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(_errno)));
+    if (wlan_socket_listen(self, backlog, &_errno) != 0) {
+        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(-_errno)));
    }
-
    return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_listen_obj, socket_listen);
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_listen_obj, 1, 2, socket_listen);

 // method socket.accept()
 STATIC mp_obj_t socket_accept(mp_obj_t self_in) {
    mod_network_socket_obj_t *self = self_in;

    // create new socket object
-    // starts with empty NIC so that finaliser doesn't run close() method if accept() fails
    mod_network_socket_obj_t *socket2 = m_new_obj_with_finaliser(mod_network_socket_obj_t);
-    socket2->base.type = (mp_obj_t)&socket_type;
-    socket2->nic = MP_OBJ_NULL;
-    socket2->nic_type = NULL;
+    // the new socket inherits all properties from its parent
+    memcpy (socket2, self, sizeof(mod_network_socket_obj_t));

-    // accept incoming connection
+    // accept the incoming connection
    uint8_t ip[MOD_NETWORK_IPV4ADDR_BUF_SIZE];
    mp_uint_t port;
    int _errno;
-    if (self->nic_type->accept(self, socket2, ip, &port, &_errno) != 0) {
-        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(_errno)));
+    if (wlan_socket_accept(self, socket2, ip, &port, &_errno) != 0) {
+        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(-_errno)));
    }

-    // new socket has valid state, so set the NIC to the same as parent
-    socket2->nic = self->nic;
-    socket2->nic_type = self->nic_type;
+    // add the socket to the list
+    modusocket_socket_add(socket2->sock_base.sd, true);

    // make the return value
    mp_obj_tuple_t *client = mp_obj_new_tuple(2, NULL);
    client->items[0] = socket2;
-    client->items[1] = mod_network_format_inet_addr(ip, port);
-
+    client->items[1] = netutils_format_inet_addr(ip, port, NETUTILS_LITTLE);
    return client;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(socket_accept_obj, socket_accept);
@@ -168,17 +240,16 @@ STATIC mp_obj_t socket_connect(mp_obj_t self_in, mp_obj_t addr_in) {

    // get address
    uint8_t ip[MOD_NETWORK_IPV4ADDR_BUF_SIZE];
-    mp_uint_t port = mod_network_parse_inet_addr(addr_in, ip);
+    mp_uint_t port = netutils_parse_inet_addr(addr_in, ip, NETUTILS_LITTLE);

-    // check if we need to select a NIC
-    socket_select_nic(self, ip);
-
-    // call the NIC to connect the socket
+    // connect the socket
    int _errno;
-    if (self->nic_type->connect(self, ip, port, &_errno) != 0) {
-        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(_errno)));
+    if (wlan_socket_connect(self, ip, port, &_errno) != 0) {
+        if (!self->sock_base.cert_req && _errno == SL_ESECSNOVERIFY) {
+            return mp_const_none;
+        }
+        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(-_errno)));
    }
-
    return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_connect_obj, socket_connect);
@@ -186,16 +257,12 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_connect_obj, socket_connect);
 // method socket.send(bytes)
 STATIC mp_obj_t socket_send(mp_obj_t self_in, mp_obj_t buf_in) {
    mod_network_socket_obj_t *self = self_in;
-    if (self->nic == MP_OBJ_NULL) {
-        // not connected
-        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(EBADF)));
-    }
    mp_buffer_info_t bufinfo;
    mp_get_buffer_raise(buf_in, &bufinfo, MP_BUFFER_READ);
    int _errno;
-    mp_uint_t ret = self->nic_type->send(self, bufinfo.buf, bufinfo.len, &_errno);
-    if (ret == -1) {
-        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(_errno)));
+    mp_int_t ret = wlan_socket_send(self, bufinfo.buf, bufinfo.len, &_errno);
+    if (ret < 0) {
+        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(-_errno)));
    }
    return mp_obj_new_int_from_uint(ret);
 }
@@ -204,17 +271,16 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_send_obj, socket_send);
 // method socket.recv(bufsize)
 STATIC mp_obj_t socket_recv(mp_obj_t self_in, mp_obj_t len_in) {
    mod_network_socket_obj_t *self = self_in;
-    if (self->nic == MP_OBJ_NULL) {
-        // not connected
-        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(ENOTCONN)));
-    }
    mp_int_t len = mp_obj_get_int(len_in);
    vstr_t vstr;
    vstr_init_len(&vstr, len);
    int _errno;
-    mp_uint_t ret = self->nic_type->recv(self, (byte*)vstr.buf, len, &_errno);
-    if (ret == -1) {
-        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(_errno)));
+    mp_int_t ret = wlan_socket_recv(self, (byte*)vstr.buf, len, &_errno);
+    if (ret < 0) {
+        if (_errno == EAGAIN && self->sock_base.has_timeout) {
+            nlr_raise(mp_obj_new_exception_msg(&mp_type_TimeoutError, "timed out"));
+        }
+        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(-_errno)));
    }
    if (ret == 0) {
        return mp_const_empty_bytes;
@@ -235,18 +301,14 @@ STATIC mp_obj_t socket_sendto(mp_obj_t self_in, mp_obj_t data_in, mp_obj_t addr_

    // get address
    uint8_t ip[MOD_NETWORK_IPV4ADDR_BUF_SIZE];
-    mp_uint_t port = mod_network_parse_inet_addr(addr_in, ip);
+    mp_uint_t port = netutils_parse_inet_addr(addr_in, ip, NETUTILS_LITTLE);

-    // check if we need to select a NIC
-    socket_select_nic(self, ip);
-
-    // call the NIC to sendto
+    // call the nic to sendto
    int _errno;
-    mp_int_t ret = self->nic_type->sendto(self, bufinfo.buf, bufinfo.len, ip, port, &_errno);
-    if (ret == -1) {
-        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(_errno)));
+    mp_int_t ret = wlan_socket_sendto(self, bufinfo.buf, bufinfo.len, ip, port, &_errno);
+    if (ret < 0) {
+        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(-_errno)));
    }
-
    return mp_obj_new_int(ret);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_3(socket_sendto_obj, socket_sendto);
@@ -254,18 +316,17 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_3(socket_sendto_obj, socket_sendto);
 // method socket.recvfrom(bufsize)
 STATIC mp_obj_t socket_recvfrom(mp_obj_t self_in, mp_obj_t len_in) {
    mod_network_socket_obj_t *self = self_in;
-    if (self->nic == MP_OBJ_NULL) {
-        // not connected
-        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(ENOTCONN)));
-    }
    vstr_t vstr;
    vstr_init_len(&vstr, mp_obj_get_int(len_in));
    byte ip[4];
    mp_uint_t port;
    int _errno;
-    mp_int_t ret = self->nic_type->recvfrom(self, (byte*)vstr.buf, vstr.len, ip, &port, &_errno);
-    if (ret == -1) {
-        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(_errno)));
+    mp_int_t ret = wlan_socket_recvfrom(self, (byte*)vstr.buf, vstr.len, ip, &port, &_errno);
+    if (ret < 0) {
+        if (_errno == EAGAIN && self->sock_base.has_timeout) {
+            nlr_raise(mp_obj_new_exception_msg(&mp_type_TimeoutError, "timed out"));
+        }
+        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(-_errno)));
    }
    mp_obj_t tuple[2];
    if (ret == 0) {
@@ -275,7 +336,7 @@ STATIC mp_obj_t socket_recvfrom(mp_obj_t self_in, mp_obj_t len_in) {
        vstr.buf[vstr.len] = '\0';
        tuple[0] = mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
    }
-    tuple[1] = mod_network_format_inet_addr(ip, port);
+    tuple[1] = netutils_format_inet_addr(ip, port, NETUTILS_LITTLE);
    return mp_obj_new_tuple(2, tuple);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_recvfrom_obj, socket_recvfrom);
@@ -291,7 +352,7 @@ STATIC mp_obj_t socket_setsockopt(mp_uint_t n_args, const mp_obj_t *args) {
    mp_uint_t optlen;
    mp_int_t val;
    if (mp_obj_is_integer(args[3])) {
-        val = mp_obj_int_get_truncated(args[3]);
+        val = mp_obj_get_int_truncated(args[3]);
        optval = &val;
        optlen = sizeof(val);
    } else {
@@ -302,10 +363,9 @@ STATIC mp_obj_t socket_setsockopt(mp_uint_t n_args, const mp_obj_t *args) {
    }

    int _errno;
-    if (self->nic_type->setsockopt(self, level, opt, optval, optlen, &_errno) != 0) {
-        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(_errno)));
+    if (wlan_socket_setsockopt(self, level, opt, optval, optlen, &_errno) != 0) {
+        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(-_errno)));
    }
-
    return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_setsockopt_obj, 4, 4, socket_setsockopt);
@@ -316,19 +376,15 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_setsockopt_obj, 4, 4, socket_s
 // otherwise, timeout is in seconds
 STATIC mp_obj_t socket_settimeout(mp_obj_t self_in, mp_obj_t timeout_in) {
    mod_network_socket_obj_t *self = self_in;
-    if (self->nic == MP_OBJ_NULL) {
-        // not connected
-        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(ENOTCONN)));
-    }
    mp_uint_t timeout;
    if (timeout_in == mp_const_none) {
        timeout = -1;
    } else {
-        timeout = 1000 * mp_obj_get_int(timeout_in);
+        timeout = mp_obj_get_int(timeout_in);
    }
    int _errno;
-    if (self->nic_type->settimeout(self, timeout, &_errno) != 0) {
-        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(_errno)));
+    if (wlan_socket_settimeout(self, timeout, &_errno) != 0) {
+        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(-_errno)));
    }
    return mp_const_none;
 }
@@ -344,30 +400,84 @@ STATIC mp_obj_t socket_setblocking(mp_obj_t self_in, mp_obj_t blocking) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_setblocking_obj, socket_setblocking);

+STATIC mp_obj_t socket_makefile(mp_uint_t n_args, const mp_obj_t *args) {
+    // TODO: CPython explicitly says that closing the returned object doesn't
+    // close the original socket (Python2 at all says that fd is dup()ed). But
+    // we save on the bloat.
+    mod_network_socket_obj_t *self = args[0];
+    if (n_args > 1) {
+        const char *mode = mp_obj_str_get_str(args[1]);
+        if (strcmp(mode, "rb") && strcmp(mode, "wb")) {
+            nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
+        }
+    }
+    return self;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_makefile_obj, 1, 6, socket_makefile);
+
 STATIC const mp_map_elem_t socket_locals_dict_table[] = {
-    { MP_OBJ_NEW_QSTR(MP_QSTR___del__), (mp_obj_t)&socket_close_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_close), (mp_obj_t)&socket_close_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_bind), (mp_obj_t)&socket_bind_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_listen), (mp_obj_t)&socket_listen_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_accept), (mp_obj_t)&socket_accept_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_connect), (mp_obj_t)&socket_connect_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_send), (mp_obj_t)&socket_send_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_recv), (mp_obj_t)&socket_recv_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_sendto), (mp_obj_t)&socket_sendto_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_recvfrom), (mp_obj_t)&socket_recvfrom_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_setsockopt), (mp_obj_t)&socket_setsockopt_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_settimeout), (mp_obj_t)&socket_settimeout_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_setblocking), (mp_obj_t)&socket_setblocking_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR___del__),         (mp_obj_t)&socket_close_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_close),           (mp_obj_t)&socket_close_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_bind),            (mp_obj_t)&socket_bind_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_listen),          (mp_obj_t)&socket_listen_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_accept),          (mp_obj_t)&socket_accept_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_connect),         (mp_obj_t)&socket_connect_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_send),            (mp_obj_t)&socket_send_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_sendall),         (mp_obj_t)&socket_send_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_recv),            (mp_obj_t)&socket_recv_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_sendto),          (mp_obj_t)&socket_sendto_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_recvfrom),        (mp_obj_t)&socket_recvfrom_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_setsockopt),      (mp_obj_t)&socket_setsockopt_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_settimeout),      (mp_obj_t)&socket_settimeout_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_setblocking),     (mp_obj_t)&socket_setblocking_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_makefile),        (mp_obj_t)&socket_makefile_obj },
+
+    // stream methods
+    { MP_OBJ_NEW_QSTR(MP_QSTR_read),            (mp_obj_t)&mp_stream_read_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_readall),         (mp_obj_t)&mp_stream_readall_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_readinto),        (mp_obj_t)&mp_stream_readinto_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_readline),        (mp_obj_t)&mp_stream_unbuffered_readline_obj},
+    { MP_OBJ_NEW_QSTR(MP_QSTR_write),           (mp_obj_t)&mp_stream_write_obj },
 };

-STATIC MP_DEFINE_CONST_DICT(socket_locals_dict, socket_locals_dict_table);
+MP_DEFINE_CONST_DICT(socket_locals_dict, socket_locals_dict_table);

-mp_uint_t socket_ioctl(mp_obj_t self_in, mp_uint_t request, mp_uint_t arg, int *errcode) {
+STATIC mp_uint_t socket_read(mp_obj_t self_in, void *buf, mp_uint_t size, int *errcode) {
    mod_network_socket_obj_t *self = self_in;
-    return self->nic_type->ioctl(self, request, arg, errcode);
+    mp_int_t ret = wlan_socket_recv(self, buf, size, errcode);
+    if (ret < 0) {
+        // we need to ignore the socket closed error here because a readall() or read() without params
+        // only returns when the socket is closed by the other end
+        if (*errcode != SL_ESECCLOSED) {
+            ret = MP_STREAM_ERROR;
+            // needed to convert simplelink's negative error codes to POSIX
+            (*errcode) *= -1;
+        } else {
+            ret = 0;
+        }
+    }
+    return ret;
 }

-STATIC const mp_stream_p_t socket_stream_p = {
+STATIC mp_uint_t socket_write(mp_obj_t self_in, const void *buf, mp_uint_t size, int *errcode) {
+    mod_network_socket_obj_t *self = self_in;
+    mp_int_t ret = wlan_socket_send(self, buf, size, errcode);
+    if (ret < 0) {
+        ret = MP_STREAM_ERROR;
+        // needed to convert simplelink's negative error codes to POSIX
+        (*errcode) *= -1;
+    }
+    return ret;
+}
+
+STATIC mp_uint_t socket_ioctl(mp_obj_t self_in, mp_uint_t request, mp_uint_t arg, int *errcode) {
+    mod_network_socket_obj_t *self = self_in;
+    return wlan_socket_ioctl(self, request, arg, errcode);
+}
+
+const mp_stream_p_t socket_stream_p = {
+    .read = socket_read,
+    .write = socket_write,
    .ioctl = socket_ioctl,
    .is_text = false,
 };
@@ -390,28 +500,19 @@ STATIC mp_obj_t mod_usocket_getaddrinfo(mp_obj_t host_in, mp_obj_t port_in) {
    const char *host = mp_obj_str_get_data(host_in, &hlen);
    mp_int_t port = mp_obj_get_int(port_in);

-    // find a NIC that can do a name lookup
-    for (mp_uint_t i = 0; i < MP_STATE_PORT(mod_network_nic_list).len; i++) {
-        mp_obj_t nic = MP_STATE_PORT(mod_network_nic_list).items[i];
-        mod_network_nic_type_t *nic_type = (mod_network_nic_type_t*)mp_obj_get_type(nic);
-        if (nic_type->gethostbyname != NULL) {
-            // Only IPv4 is supported
-            uint8_t out_ip[MOD_NETWORK_IPV4ADDR_BUF_SIZE];
-            int32_t result = nic_type->gethostbyname(nic, host, hlen, out_ip, AF_INET);
-            if (result != 0) {
-                nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(result)));
-            }
-            mp_obj_tuple_t *tuple = mp_obj_new_tuple(5, NULL);
-            tuple->items[0] = MP_OBJ_NEW_SMALL_INT(AF_INET);
-            tuple->items[1] = MP_OBJ_NEW_SMALL_INT(SOCK_STREAM);
-            tuple->items[2] = MP_OBJ_NEW_SMALL_INT(0);
-            tuple->items[3] = MP_OBJ_NEW_QSTR(MP_QSTR_);
-            tuple->items[4] = mod_network_format_inet_addr(out_ip, port);
-            return mp_obj_new_list(1, (mp_obj_t*)&tuple);
-        }
+    // ipv4 only
+    uint8_t out_ip[MOD_NETWORK_IPV4ADDR_BUF_SIZE];
+    int32_t result = wlan_gethostbyname(host, hlen, out_ip, AF_INET);
+    if (result < 0) {
+        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(-result)));
    }
-
-    nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_resource_not_avaliable));
+    mp_obj_tuple_t *tuple = mp_obj_new_tuple(5, NULL);
+    tuple->items[0] = MP_OBJ_NEW_SMALL_INT(AF_INET);
+    tuple->items[1] = MP_OBJ_NEW_SMALL_INT(SOCK_STREAM);
+    tuple->items[2] = MP_OBJ_NEW_SMALL_INT(0);
+    tuple->items[3] = MP_OBJ_NEW_QSTR(MP_QSTR_);
+    tuple->items[4] = netutils_format_inet_addr(out_ip, port, NETUTILS_LITTLE);
+    return mp_obj_new_list(1, (mp_obj_t*)&tuple);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(mod_usocket_getaddrinfo_obj, mod_usocket_getaddrinfo);

@@ -421,18 +522,19 @@ STATIC const mp_map_elem_t mp_module_usocket_globals_table[] = {
    { MP_OBJ_NEW_QSTR(MP_QSTR_socket),          (mp_obj_t)&socket_type },
    { MP_OBJ_NEW_QSTR(MP_QSTR_getaddrinfo),     (mp_obj_t)&mod_usocket_getaddrinfo_obj },

+    // class exceptions
+    { MP_OBJ_NEW_QSTR(MP_QSTR_error),           (mp_obj_t)&mp_type_OSError },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_timeout),         (mp_obj_t)&mp_type_TimeoutError },
+
    // class constants
    { MP_OBJ_NEW_QSTR(MP_QSTR_AF_INET),         MP_OBJ_NEW_SMALL_INT(AF_INET) },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_AF_INET6),        MP_OBJ_NEW_SMALL_INT(AF_INET6) },

    { MP_OBJ_NEW_QSTR(MP_QSTR_SOCK_STREAM),     MP_OBJ_NEW_SMALL_INT(SOCK_STREAM) },
    { MP_OBJ_NEW_QSTR(MP_QSTR_SOCK_DGRAM),      MP_OBJ_NEW_SMALL_INT(SOCK_DGRAM) },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_SOCK_RAW),        MP_OBJ_NEW_SMALL_INT(SOCK_RAW) },

    { MP_OBJ_NEW_QSTR(MP_QSTR_IPPROTO_SEC),     MP_OBJ_NEW_SMALL_INT(SL_SEC_SOCKET) },
    { MP_OBJ_NEW_QSTR(MP_QSTR_IPPROTO_TCP),     MP_OBJ_NEW_SMALL_INT(IPPROTO_TCP) },
    { MP_OBJ_NEW_QSTR(MP_QSTR_IPPROTO_UDP),     MP_OBJ_NEW_SMALL_INT(IPPROTO_UDP) },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_IPPROTO_RAW),     MP_OBJ_NEW_SMALL_INT(IPPROTO_RAW) },
 };

 STATIC MP_DEFINE_CONST_DICT(mp_module_usocket_globals, mp_module_usocket_globals_table);
--- a/cc3200/mods/modusocket.h
+++ b/cc3200/mods/modusocket.h
@@ -0,0 +1,39 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 Daniel Campora
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MODUSOCKET_H_
+#define MODUSOCKET_H_
+
+extern const mp_obj_dict_t socket_locals_dict;
+extern const mp_stream_p_t socket_stream_p;
+
+extern void modusocket_pre_init (void);
+extern void modusocket_socket_add (int16_t sd, bool user);
+extern void modusocket_socket_delete (int16_t sd);
+extern void modusocket_enter_sleep (void);
+extern void modusocket_close_all_user_sockets (void);
+
+#endif /* MODUSOCKET_H_ */
--- a/cc3200/mods/modussl.c
+++ b/cc3200/mods/modussl.c
@@ -0,0 +1,158 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 Daniel Campora
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdint.h>
+#include <std.h>
+
+#include "simplelink.h"
+#include "py/mpconfig.h"
+#include "py/obj.h"
+#include "py/objstr.h"
+#include "py/runtime.h"
+#include "modnetwork.h"
+#include "modusocket.h"
+#include "mpexception.h"
+
+/******************************************************************************
+ DEFINE CONSTANTS
+ ******************************************************************************/
+#define SSL_CERT_NONE                          (0)
+#define SSL_CERT_OPTIONAL                      (1)
+#define SSL_CERT_REQUIRED                      (2)
+
+/******************************************************************************
+ DEFINE TYPES
+ ******************************************************************************/
+typedef struct _mp_obj_ssl_socket_t {
+    mp_obj_base_t base;
+    mod_network_socket_base_t sock_base;
+    mp_obj_t o_sock;
+} mp_obj_ssl_socket_t;
+
+/******************************************************************************
+ DECLARE PRIVATE DATA
+ ******************************************************************************/
+STATIC const mp_obj_type_t ssl_socket_type;
+
+/******************************************************************************/
+// Micro Python bindings; SSL class
+
+// ssl sockets inherit from normal socket, so we take its
+// locals and stream methods
+STATIC const mp_obj_type_t ssl_socket_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_ussl,
+    .getiter = NULL,
+    .iternext = NULL,
+    .stream_p = &socket_stream_p,
+    .locals_dict = (mp_obj_t)&socket_locals_dict,
+};
+
+STATIC mp_obj_t mod_ssl_wrap_socket(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    STATIC const mp_arg_t allowed_args[] = {
+        { MP_QSTR_sock,             MP_ARG_REQUIRED | MP_ARG_OBJ,  },
+        { MP_QSTR_keyfile,          MP_ARG_KW_ONLY  | MP_ARG_OBJ,  {.u_obj = mp_const_none} },
+        { MP_QSTR_certfile,         MP_ARG_KW_ONLY  | MP_ARG_OBJ,  {.u_obj = mp_const_none} },
+        { MP_QSTR_server_side,      MP_ARG_KW_ONLY  | MP_ARG_BOOL, {.u_bool = false} },
+        { MP_QSTR_cert_reqs,        MP_ARG_KW_ONLY  | MP_ARG_INT,  {.u_int = SSL_CERT_NONE} },
+        { MP_QSTR_ca_certs,         MP_ARG_KW_ONLY  | MP_ARG_OBJ,  {.u_obj = mp_const_none} },
+    };
+
+    // parse arguments
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    // chech if ca validation is required
+    if (args[4].u_int != SSL_CERT_NONE && args[5].u_obj == mp_const_none) {
+        goto arg_error;
+    }
+
+    // retrieve the file paths (with an 6 byte offset in order to strip it from the '/flash' prefix)
+    const char *keyfile  = (args[1].u_obj == mp_const_none) ? NULL : &(mp_obj_str_get_str(args[1].u_obj)[6]);
+    const char *certfile = (args[2].u_obj == mp_const_none) ? NULL : &(mp_obj_str_get_str(args[2].u_obj)[6]);
+    const char *cafile   = (args[5].u_obj == mp_const_none || args[4].u_int != SSL_CERT_REQUIRED) ?
+                           NULL : &(mp_obj_str_get_str(args[5].u_obj)[6]);
+
+    // server side requires both certfile and keyfile
+    if (args[3].u_bool && (!keyfile || !certfile)) {
+        goto arg_error;
+    }
+
+    _i16 sd = ((mod_network_socket_obj_t *)args[0].u_obj)->sock_base.sd;
+    _i16 _errno;
+    _u8 method = SL_SO_SEC_METHOD_TLSV1;
+    if ((_errno = sl_SetSockOpt(sd, SL_SOL_SOCKET, SL_SO_SECMETHOD, &method, sizeof(method))) < 0) {
+        goto socket_error;
+    }
+    if (keyfile && (_errno = sl_SetSockOpt(sd, SL_SOL_SOCKET, SL_SO_SECURE_FILES_PRIVATE_KEY_FILE_NAME, keyfile, strlen(keyfile))) < 0) {
+        goto socket_error;
+    }
+    if (certfile && (_errno = sl_SetSockOpt(sd, SL_SOL_SOCKET, SL_SO_SECURE_FILES_CERTIFICATE_FILE_NAME, certfile, strlen(certfile))) < 0) {
+        goto socket_error;
+    }
+    if (cafile && (_errno = sl_SetSockOpt(sd, SL_SOL_SOCKET, SL_SO_SECURE_FILES_CA_FILE_NAME, cafile, strlen(cafile))) < 0) {
+        goto socket_error;
+    }
+
+    // create the ssl socket
+    mp_obj_ssl_socket_t *ssl_sock = m_new_obj(mp_obj_ssl_socket_t);
+    // ssl sockets inherit all properties from the original socket
+    memcpy (&ssl_sock->sock_base, &((mod_network_socket_obj_t *)args[0].u_obj)->sock_base, sizeof(mod_network_socket_base_t));
+    ssl_sock->base.type = &ssl_socket_type;
+    ssl_sock->sock_base.cert_req = (args[4].u_int == SSL_CERT_REQUIRED) ? true : false;
+    ssl_sock->o_sock = args[0].u_obj;
+
+    return ssl_sock;
+
+socket_error:
+    nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(_errno)));
+
+arg_error:
+    nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(mod_ssl_wrap_socket_obj, 0, mod_ssl_wrap_socket);
+
+STATIC const mp_map_elem_t mp_module_ussl_globals_table[] = {
+    { MP_OBJ_NEW_QSTR(MP_QSTR___name__),            MP_OBJ_NEW_QSTR(MP_QSTR_ussl) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_wrap_socket),         (mp_obj_t)&mod_ssl_wrap_socket_obj },
+
+    // class exceptions
+    { MP_OBJ_NEW_QSTR(MP_QSTR_SSLError),            (mp_obj_t)&mp_type_OSError },
+
+    // class constants
+    { MP_OBJ_NEW_QSTR(MP_QSTR_CERT_NONE),           MP_OBJ_NEW_SMALL_INT(SSL_CERT_NONE) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_CERT_OPTIONAL),       MP_OBJ_NEW_SMALL_INT(SSL_CERT_OPTIONAL) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_CERT_REQUIRED),       MP_OBJ_NEW_SMALL_INT(SSL_CERT_REQUIRED) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(mp_module_ussl_globals, mp_module_ussl_globals_table);
+
+const mp_obj_module_t mp_module_ussl = {
+    .base = { &mp_type_module },
+    .name = MP_QSTR_ussl,
+    .globals = (mp_obj_dict_t*)&mp_module_ussl_globals,
+};
+
--- a/cc3200/mods/modutime.c
+++ b/cc3200/mods/modutime.c
@@ -29,143 +29,35 @@
 #include <string.h>

 #include "py/mpconfig.h"
-#include MICROPY_HAL_H
 #include "py/nlr.h"
 #include "py/obj.h"
-#include "modutime.h"
+#include "py/smallint.h"
+#include "py/mphal.h"
+#include "timeutils.h"
 #include "inc/hw_types.h"
 #include "inc/hw_ints.h"
 #include "inc/hw_memmap.h"
 #include "rom_map.h"
 #include "prcm.h"
+#include "systick.h"
 #include "pybrtc.h"
+#include "mpsystick.h"
 #include "mpexception.h"
-
-
-// LEAPOCH corresponds to 2000-03-01, which is a mod-400 year, immediately
-// after Feb 29. We calculate seconds as a signed integer relative to that.
-//
-// Our timebase is relative to 2000-01-01.
-
-#define LEAPOCH ((31 + 29) * 86400)
-
-#define DAYS_PER_400Y (365*400 + 97)
-#define DAYS_PER_100Y (365*100 + 24)
-#define DAYS_PER_4Y   (365*4   + 1)
-
+#include "utils.h"

 /// \module time - time related functions
 ///
 /// The `time` module provides functions for getting the current time and date,
 /// and for sleeping.

-STATIC const uint16_t days_since_jan1[]= { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 };
-
-STATIC bool is_leap_year(mp_uint_t year) {
-    return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
-}
-
-// Month is one based
-STATIC mp_uint_t mod_time_days_in_month(mp_uint_t year, mp_uint_t month) {
-    mp_uint_t mdays = days_since_jan1[month] - days_since_jan1[month - 1];
-    if (month == 2 && is_leap_year(year)) {
-        mdays++;
-    }
-    return mdays;
-}
-
-// compute the day of the year, between 1 and 366
-// month should be between 1 and 12, date should start at 1
-STATIC mp_uint_t mod_time_year_day(mp_uint_t year, mp_uint_t month, mp_uint_t date) {
-    mp_uint_t yday = days_since_jan1[month - 1] + date;
-    if (month >= 3 && is_leap_year(year)) {
-        yday += 1;
-    }
-    return yday;
-}
-
-// returns the number of seconds, as an integer, since 2000-01-01
-mp_uint_t mod_time_seconds_since_2000(mp_uint_t year, mp_uint_t month, mp_uint_t date, mp_uint_t hour, mp_uint_t minute, mp_uint_t second) {
-    return
-        second
-        + minute * 60
-        + hour * 3600
-        + (mod_time_year_day(year, month, date) - 1
-            + ((year - 2000 + 3) / 4) // add a day each 4 years starting with 2001
-            - ((year - 2000 + 99) / 100) // subtract a day each 100 years starting with 2001
-            + ((year - 2000 + 399) / 400) // add a day each 400 years starting with 2001
-            ) * 86400
-        + (year - 2000) * 31536000;
-}
-
-void mod_time_seconds_since_2000_to_struct_time(mp_uint_t t, mod_struct_time *tm) {
-    // The following algorithm was adapted from musl's __secs_to_tm and adapted
-    // for differences in Micro Python's timebase.
-
-    mp_int_t seconds = t - LEAPOCH;
-
-    mp_int_t days = seconds / 86400;
-    seconds %= 86400;
-    tm->tm_hour = seconds / 3600;
-    tm->tm_min = seconds / 60 % 60;
-    tm->tm_sec = seconds % 60;
-
-    mp_int_t wday = (days + 2) % 7;   // Mar 1, 2000 was a Wednesday (2)
-    if (wday < 0) {
-        wday += 7;
-    }
-    tm->tm_wday = wday;
-
-    mp_int_t qc_cycles = days / DAYS_PER_400Y;
-    days %= DAYS_PER_400Y;
-    if (days < 0) {
-        days += DAYS_PER_400Y;
-        qc_cycles--;
-    }
-    mp_int_t c_cycles = days / DAYS_PER_100Y;
-    if (c_cycles == 4) {
-        c_cycles--;
-    }
-    days -= (c_cycles * DAYS_PER_100Y);
-
-    mp_int_t q_cycles = days / DAYS_PER_4Y;
-    if (q_cycles == 25) {
-        q_cycles--;
-    }
-    days -= q_cycles * DAYS_PER_4Y;
-
-    mp_int_t years = days / 365;
-    if (years == 4) {
-        years--;
-    }
-    days -= (years * 365);
-
-    tm->tm_year = 2000 + years + 4 * q_cycles + 100 * c_cycles + 400 * qc_cycles;
-
-    // Note: days_in_month[0] corresponds to March
-    STATIC const int8_t days_in_month[] = {31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31, 29};
-
-    mp_int_t month;
-    for (month = 0; days_in_month[month] <= days; month++) {
-        days -= days_in_month[month];
-    }
-
-    tm->tm_mon = month + 2;
-    if (tm->tm_mon >= 12) {
-        tm->tm_mon -= 12;
-        tm->tm_year++;
-    }
-    tm->tm_mday = days + 1; // Make one based
-    tm->tm_mon++;   // Make one based
-
-    tm->tm_yday = mod_time_year_day(tm->tm_year, tm->tm_mon, tm->tm_mday);
-}
+/******************************************************************************/
+// Micro Python bindings

 /// \function localtime([secs])
 /// Convert a time expressed in seconds since Jan 1, 2000 into an 8-tuple which
 /// contains: (year, month, mday, hour, minute, second, weekday, yearday)
 /// If secs is not provided or None, then the current time from the RTC is used.
-/// year includes the century (for example 2014)
+/// year includes the century (for example 2015)
 /// month   is 1-12
 /// mday    is 1-31
 /// hour    is 0-23
@@ -175,30 +67,25 @@ void mod_time_seconds_since_2000_to_struct_time(mp_uint_t t, mod_struct_time *tm
 /// yearday is 1-366
 STATIC mp_obj_t time_localtime(mp_uint_t n_args, const mp_obj_t *args) {
    if (n_args == 0 || args[0] == mp_const_none) {
-        mod_struct_time tm;
-        uint32_t seconds;
-        uint16_t mseconds;
-
-        // get the seconds and the milliseconds from the RTC
-        MAP_PRCMRTCGet(&seconds, &mseconds);
-        mseconds = RTC_CYCLES_U16MS(mseconds);
-        mod_time_seconds_since_2000_to_struct_time(seconds, &tm);
+        timeutils_struct_time_t tm;

+        // get the seconds from the RTC
+        timeutils_seconds_since_2000_to_struct_time(pyb_rtc_get_seconds(), &tm);
        mp_obj_t tuple[8] = {
                mp_obj_new_int(tm.tm_year),
                mp_obj_new_int(tm.tm_mon),
                mp_obj_new_int(tm.tm_mday),
-                mp_obj_new_int(tm.tm_wday),
                mp_obj_new_int(tm.tm_hour),
                mp_obj_new_int(tm.tm_min),
                mp_obj_new_int(tm.tm_sec),
-                mp_obj_new_int(mseconds)
+                mp_obj_new_int(tm.tm_wday),
+                mp_obj_new_int(tm.tm_yday)
        };
        return mp_obj_new_tuple(8, tuple);
    } else {
        mp_int_t seconds = mp_obj_get_int(args[0]);
-        mod_struct_time tm;
-        mod_time_seconds_since_2000_to_struct_time(seconds, &tm);
+        timeutils_struct_time_t tm;
+        timeutils_seconds_since_2000_to_struct_time(seconds, &tm);
        mp_obj_t tuple[8] = {
            tuple[0] = mp_obj_new_int(tm.tm_year),
            tuple[1] = mp_obj_new_int(tm.tm_mon),
@@ -214,13 +101,7 @@ STATIC mp_obj_t time_localtime(mp_uint_t n_args, const mp_obj_t *args) {
 }
 MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(time_localtime_obj, 0, 1, time_localtime);

-
-/// \function mktime()
-/// This is inverse function of localtime. It's argument is a full 8-tuple
-/// which expresses a time as per localtime. It returns an integer which is
-/// the number of seconds since Jan 1, 2000.
 STATIC mp_obj_t time_mktime(mp_obj_t tuple) {
-
    mp_uint_t len;
    mp_obj_t *elem;

@@ -231,95 +112,84 @@ STATIC mp_obj_t time_mktime(mp_obj_t tuple) {
        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, mpexception_num_type_invalid_arguments));
    }

-    mp_int_t year    = mp_obj_get_int(elem[0]);
-    mp_int_t month   = mp_obj_get_int(elem[1]);
-    mp_int_t mday    = mp_obj_get_int(elem[2]);
-    mp_int_t hours   = mp_obj_get_int(elem[3]);
-    mp_int_t minutes = mp_obj_get_int(elem[4]);
-    mp_int_t seconds = mp_obj_get_int(elem[5]);
-
-    // Normalize the tuple. This allows things like:
-    //
-    // tm_tomorrow = list(time.localtime())
-    // tm_tomorrow[2] += 1 # Adds 1 to mday
-    // tomorrow = time.mktime(tm_tommorrow)
-    //
-    // And not have to worry about all the weird overflows.
-    //
-    // You can subtract dates/times this way as well.
-
-    minutes += seconds / 60;
-    if ((seconds = seconds % 60) < 0) {
-        seconds += 60;
-        minutes--;
-    }
-
-    hours += minutes / 60;
-    if ((minutes = minutes % 60) < 0) {
-        minutes += 60;
-        hours--;
-    }
-
-    mday += hours / 24;
-    if ((hours = hours % 24) < 0) {
-        hours += 24;
-        mday--;
-    }
-
-    month--; // make month zero based
-    year += month / 12;
-    if ((month = month % 12) < 0) {
-        month += 12;
-        year--;
-    }
-    month++; // back to one based
-
-    while (mday < 1) {
-        if (--month == 0) {
-            month = 12;
-            year--;
-        }
-        mday += mod_time_days_in_month(year, month);
-    }
-    while (mday > mod_time_days_in_month(year, month)) {
-        mday -= mod_time_days_in_month(year, month);
-        if (++month == 13) {
-            month = 1;
-            year++;
-        }
-    }
-    return mp_obj_new_int_from_uint(mod_time_seconds_since_2000(year, month, mday, hours, minutes, seconds));
+    return mp_obj_new_int_from_uint(timeutils_mktime(mp_obj_get_int(elem[0]), mp_obj_get_int(elem[1]), mp_obj_get_int(elem[2]),
+                                                     mp_obj_get_int(elem[3]), mp_obj_get_int(elem[4]), mp_obj_get_int(elem[5])));
 }
 MP_DEFINE_CONST_FUN_OBJ_1(time_mktime_obj, time_mktime);

+STATIC mp_obj_t time_time(void) {
+    return mp_obj_new_int(pyb_rtc_get_seconds());
+}
+MP_DEFINE_CONST_FUN_OBJ_0(time_time_obj, time_time);

-/// \function sleep(milliseconds)
-/// Sleep for the given number of milliseconds.
-STATIC mp_obj_t time_sleep(mp_obj_t milliseconds_o) {
-    HAL_Delay(mp_obj_get_int(milliseconds_o));
+STATIC mp_obj_t time_sleep(mp_obj_t seconds_o) {
+    int32_t sleep_s = mp_obj_get_int(seconds_o);
+    if (sleep_s > 0) {
+        mp_hal_delay_ms(sleep_s * 1000);
+    }
    return mp_const_none;
 }
 MP_DEFINE_CONST_FUN_OBJ_1(time_sleep_obj, time_sleep);

-/// \function time()
-/// Returns the number of seconds, as an integer, since 1/1/2000.
-STATIC mp_obj_t time_time(void) {
-    uint32_t seconds;
-    uint16_t mseconds;
-
-    // get the seconds and the milliseconds from the RTC
-    MAP_PRCMRTCGet(&seconds, &mseconds);
-    return mp_obj_new_int(seconds);
+STATIC mp_obj_t time_sleep_ms (mp_obj_t ms_in) {
+    mp_int_t ms = mp_obj_get_int(ms_in);
+    if (ms > 0) {
+        mp_hal_delay_ms(ms);
+    }
+    return mp_const_none;
 }
-MP_DEFINE_CONST_FUN_OBJ_0(time_time_obj, time_time);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(time_sleep_ms_obj, time_sleep_ms);
+
+STATIC mp_obj_t time_sleep_us (mp_obj_t usec_in) {
+    mp_int_t usec = mp_obj_get_int(usec_in);
+    if (usec > 0) {
+        UtilsDelay(UTILS_DELAY_US_TO_COUNT(usec));
+    }
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(time_sleep_us_obj, time_sleep_us);
+
+STATIC mp_obj_t time_ticks_ms(void) {
+    // We want to "cast" the 32 bit unsigned into a 30-bit small-int
+    return MP_OBJ_NEW_SMALL_INT(mp_hal_ticks_ms() & MP_SMALL_INT_POSITIVE_MASK);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(time_ticks_ms_obj, time_ticks_ms);
+
+STATIC mp_obj_t time_ticks_us(void) {
+    // We want to "cast" the 32 bit unsigned into a 30-bit small-int
+    return MP_OBJ_NEW_SMALL_INT(sys_tick_get_microseconds() & MP_SMALL_INT_POSITIVE_MASK);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(time_ticks_us_obj, time_ticks_us);
+
+STATIC mp_obj_t time_ticks_cpu(void) {
+    // We want to "cast" the 32 bit unsigned into a 30-bit small-int
+    return MP_OBJ_NEW_SMALL_INT((SysTickPeriodGet() - SysTickValueGet()) & MP_SMALL_INT_POSITIVE_MASK);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_0(time_ticks_cpu_obj, time_ticks_cpu);
+
+STATIC mp_obj_t time_ticks_diff(mp_obj_t t0, mp_obj_t t1) {
+    // We want to "cast" the 32 bit unsigned into a 30-bit small-int
+    uint32_t start = mp_obj_get_int(t0);
+    uint32_t end = mp_obj_get_int(t1);
+    return MP_OBJ_NEW_SMALL_INT((end - start) & MP_SMALL_INT_POSITIVE_MASK);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(time_ticks_diff_obj, time_ticks_diff);

 STATIC const mp_map_elem_t time_module_globals_table[] = {
-    { MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_utime) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR___name__),        MP_OBJ_NEW_QSTR(MP_QSTR_utime) },

-    { MP_OBJ_NEW_QSTR(MP_QSTR_localtime), (mp_obj_t)&time_localtime_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_mktime), (mp_obj_t)&time_mktime_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_sleep), (mp_obj_t)&time_sleep_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_time), (mp_obj_t)&time_time_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_localtime),       (mp_obj_t)&time_localtime_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_mktime),          (mp_obj_t)&time_mktime_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_time),            (mp_obj_t)&time_time_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_sleep),           (mp_obj_t)&time_sleep_obj },
+
+    // MicroPython additions
+    { MP_OBJ_NEW_QSTR(MP_QSTR_sleep_ms),        (mp_obj_t)&time_sleep_ms_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_sleep_us),        (mp_obj_t)&time_sleep_us_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_ticks_ms),        (mp_obj_t)&time_ticks_ms_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_ticks_us),        (mp_obj_t)&time_ticks_us_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_ticks_cpu),       (mp_obj_t)&time_ticks_cpu_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_ticks_diff),      (mp_obj_t)&time_ticks_diff_obj },
 };

 STATIC MP_DEFINE_CONST_DICT(time_module_globals, time_module_globals_table);
--- a/cc3200/mods/modwipy.c
+++ b/cc3200/mods/modwipy.c
@@ -0,0 +1,31 @@
+#include "py/mpconfig.h"
+#include "py/obj.h"
+#include "py/runtime.h"
+#include "mperror.h"
+
+
+/******************************************************************************/
+// Micro Python bindings
+
+STATIC mp_obj_t mod_wipy_heartbeat (mp_uint_t n_args, const mp_obj_t *args) {
+    if (n_args) {
+        mperror_enable_heartbeat (mp_obj_is_true(args[0]));
+        return mp_const_none;
+    } else {
+        return mp_obj_new_bool(mperror_is_heartbeat_enabled());
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_wipy_heartbeat_obj, 0, 1, mod_wipy_heartbeat);
+
+STATIC const mp_map_elem_t wipy_module_globals_table[] = {
+    { MP_OBJ_NEW_QSTR(MP_QSTR___name__),        MP_OBJ_NEW_QSTR(MP_QSTR_wipy) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_heartbeat),       (mp_obj_t)&mod_wipy_heartbeat_obj },
+};
+
+STATIC MP_DEFINE_CONST_DICT(wipy_module_globals, wipy_module_globals_table);
+
+const mp_obj_module_t wipy_module = {
+    .base = { &mp_type_module },
+    .name = MP_QSTR_wipy,
+    .globals = (mp_obj_dict_t*)&wipy_module_globals,
+};
--- a/cc3200/mods/modwlan.c
+++ b/cc3200/mods/modwlan.c
--- a/cc3200/mods/modwlan.h
+++ b/cc3200/mods/modwlan.h
@@ -35,6 +35,10 @@
 #define SL_STOP_TIMEOUT                             35
 #define SL_STOP_TIMEOUT_LONG                        575

+#define MODWLAN_WIFI_EVENT_ANY                      0x01
+
+#define MODWLAN_SSID_LEN_MAX                        32
+
 /******************************************************************************
 DEFINE TYPES
 ******************************************************************************/
@@ -43,7 +47,35 @@ typedef enum {
    MODWLAN_ERROR_INVALID_PARAMS = -1,
    MODWLAN_ERROR_TIMEOUT = -2,
    MODWLAN_ERROR_UNKNOWN = -3,
-}modwlan_Status_t;
+} modwlan_Status_t;
+
+typedef struct _wlan_obj_t {
+    mp_obj_base_t       base;
+    mp_obj_t            irq_obj;
+    uint32_t            status;
+
+    uint32_t            ip;
+
+    int8_t              mode;
+    uint8_t             auth;
+    uint8_t             channel;
+    uint8_t             antenna;
+
+    // my own ssid, key and mac
+    uint8_t             ssid[(MODWLAN_SSID_LEN_MAX + 1)];
+    uint8_t             key[65];
+    uint8_t             mac[SL_MAC_ADDR_LEN];
+
+    // the sssid (or name) and mac of the other device
+    uint8_t             ssid_o[33];
+    uint8_t             bssid[6];
+    uint8_t             irq_flags;
+    bool                irq_enabled;
+
+#if (MICROPY_PORT_HAS_TELNET || MICROPY_PORT_HAS_FTP)
+    bool                servers_enabled;
+#endif
+} wlan_obj_t;

 /******************************************************************************
 DECLARE PUBLIC DATA
@@ -53,14 +85,31 @@ extern _SlLockObj_t wlan_LockObj;
 /******************************************************************************
 DECLARE PUBLIC FUNCTIONS
 ******************************************************************************/
-extern void wlan_init0 (void);
-extern modwlan_Status_t wlan_sl_enable (SlWlanMode_t mode, const char *ssid, uint8_t ssid_len, uint8_t sec,
-                                        const char *key, uint8_t key_len, uint8_t channel);
+extern void wlan_pre_init (void);
+extern void wlan_sl_init (int8_t mode, const char *ssid, uint8_t ssid_len, uint8_t auth, const char *key, uint8_t key_len,
+                          uint8_t channel, uint8_t antenna, bool add_mac);
 extern void wlan_first_start (void);
 extern void wlan_update(void);
 extern void wlan_stop (uint32_t timeout);
-extern void wlan_start (void);
 extern void wlan_get_mac (uint8_t *macAddress);
 extern void wlan_get_ip (uint32_t *ip);
+extern bool wlan_is_connected (void);
+extern void wlan_set_current_time (uint32_t seconds_since_2000);
+extern void wlan_off_on (void);
+
+extern int wlan_gethostbyname(const char *name, mp_uint_t len, uint8_t *out_ip, uint8_t family);
+extern int wlan_socket_socket(mod_network_socket_obj_t *s, int *_errno);
+extern void wlan_socket_close(mod_network_socket_obj_t *s);
+extern int wlan_socket_bind(mod_network_socket_obj_t *s, byte *ip, mp_uint_t port, int *_errno);
+extern int wlan_socket_listen(mod_network_socket_obj_t *s, mp_int_t backlog, int *_errno);
+extern int wlan_socket_accept(mod_network_socket_obj_t *s, mod_network_socket_obj_t *s2, byte *ip, mp_uint_t *port, int *_errno);
+extern int wlan_socket_connect(mod_network_socket_obj_t *s, byte *ip, mp_uint_t port, int *_errno);
+extern int wlan_socket_send(mod_network_socket_obj_t *s, const byte *buf, mp_uint_t len, int *_errno);
+extern int wlan_socket_recv(mod_network_socket_obj_t *s, byte *buf, mp_uint_t len, int *_errno);
+extern int wlan_socket_sendto( mod_network_socket_obj_t *s, const byte *buf, mp_uint_t len, byte *ip, mp_uint_t port, int *_errno);
+extern int wlan_socket_recvfrom(mod_network_socket_obj_t *s, byte *buf, mp_uint_t len, byte *ip, mp_uint_t *port, int *_errno);
+extern int wlan_socket_setsockopt(mod_network_socket_obj_t *s, mp_uint_t level, mp_uint_t opt, const void *optval, mp_uint_t optlen, int *_errno);
+extern int wlan_socket_settimeout(mod_network_socket_obj_t *s, mp_uint_t timeout_s, int *_errno);
+extern int wlan_socket_ioctl (mod_network_socket_obj_t *s, mp_uint_t request, mp_uint_t arg, int *_errno);

 #endif /* MODWLAN_H_ */
--- a/cc3200/mods/pybadc.c
+++ b/cc3200/mods/pybadc.c
@@ -29,7 +29,6 @@
 #include <string.h>

 #include "py/mpconfig.h"
-#include MICROPY_HAL_H
 #include "py/nlr.h"
 #include "py/runtime.h"
 #include "py/binary.h"
@@ -52,19 +51,6 @@
 #include "mpexception.h"


-/// \moduleref pyb
-/// \class ADC - analog to digital conversion: read analog values on a pin
-///
-/// Usage:
-///
-///     adc = pyb.ADC(channel)                # create an adc object on the given channel (0 to 3)
-///                                             this automatically configures the pin associated to
-///                                             that analog channel.
-///     adc.read()                            # read channel value
-///
-///     The sample rate is fixed to 62.5KHz and the resolution to 12 bits.
-
-
 /******************************************************************************
 DECLARE CONSTANTS
 ******************************************************************************/
@@ -75,129 +61,176 @@
 ******************************************************************************/
 typedef struct {
    mp_obj_base_t base;
-    byte channel;
-    byte num;
+    bool enabled;
 } pyb_adc_obj_t;

+typedef struct {
+    mp_obj_base_t base;
+    pin_obj_t *pin;
+    byte channel;
+    byte id;
+    bool enabled;
+} pyb_adc_channel_obj_t;
+
+
+/******************************************************************************
+ DECLARE PRIVATE DATA
+ ******************************************************************************/
+STATIC pyb_adc_channel_obj_t pyb_adc_channel_obj[PYB_ADC_NUM_CHANNELS] = { {.pin = &pin_GP2, .channel = ADC_CH_0, .id = 0, .enabled = false},
+                                                                           {.pin = &pin_GP3, .channel = ADC_CH_1, .id = 1, .enabled = false},
+                                                                           {.pin = &pin_GP4, .channel = ADC_CH_2, .id = 2, .enabled = false},
+                                                                           {.pin = &pin_GP5, .channel = ADC_CH_3, .id = 3, .enabled = false} };
+STATIC pyb_adc_obj_t pyb_adc_obj = {.enabled = false};
+
+STATIC const mp_obj_type_t pyb_adc_channel_type;
+
+/******************************************************************************
+ DECLARE PRIVATE FUNCTIONS
+ ******************************************************************************/
+STATIC mp_obj_t adc_channel_deinit(mp_obj_t self_in);
+
 /******************************************************************************
 DEFINE PUBLIC FUNCTIONS
 ******************************************************************************/
-STATIC void pybadc_init (pyb_adc_obj_t *self) {
-    // enable the ADC channel
-    MAP_ADCChannelEnable(ADC_BASE, self->channel);
+STATIC void pyb_adc_init (pyb_adc_obj_t *self) {
    // enable and configure the timer
    MAP_ADCTimerConfig(ADC_BASE, (1 << 17) - 1);
    MAP_ADCTimerEnable(ADC_BASE);
    // enable the ADC peripheral
    MAP_ADCEnable(ADC_BASE);
+    self->enabled = true;
 }

-/******************************************************************************
- DECLARE PRIVATE DATA
- ******************************************************************************/
-STATIC pyb_adc_obj_t pyb_adc_obj[PYB_ADC_NUM_CHANNELS];
+STATIC void pyb_adc_check_init(void) {
+    // not initialized
+    if (!pyb_adc_obj.enabled) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_request_not_possible));
+    }
+}
+
+STATIC void pyb_adc_channel_init (pyb_adc_channel_obj_t *self) {
+    // the ADC block must be enabled first
+    pyb_adc_check_init();
+    // configure the pin in analog mode
+    pin_config (self->pin, -1, PIN_TYPE_ANALOG, PIN_TYPE_STD, -1, PIN_STRENGTH_2MA);
+    // enable the ADC channel
+    MAP_ADCChannelEnable(ADC_BASE, self->channel);
+    self->enabled = true;
+}
+
+STATIC void pyb_adc_deinit_all_channels (void) {
+    for (int i = 0; i < PYB_ADC_NUM_CHANNELS; i++) {
+        adc_channel_deinit(&pyb_adc_channel_obj[i]);
+    }
+}

 /******************************************************************************/
 /* Micro Python bindings : adc object                                         */

 STATIC void adc_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
    pyb_adc_obj_t *self = self_in;
-    mp_printf(print, "<ADC, channel=%u>", self->num);
+    if (self->enabled) {
+        mp_printf(print, "ADC(0, bits=12)");
+    } else {
+        mp_printf(print, "ADC(0)");
+    }
 }

-/// \classmethod \constructor(channel)
-/// Create an ADC object associated with the given channel.
-/// This allows you to then read analog values on that pin.
-STATIC mp_obj_t adc_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
-    // check number of arguments
-    mp_arg_check_num(n_args, n_kw, 1, 1, false);
+STATIC const mp_arg_t pyb_adc_init_args[] = {
+    { MP_QSTR_id,                          MP_ARG_INT, {.u_int = 0} },
+    { MP_QSTR_bits,       MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = 12} },
+};
+STATIC mp_obj_t adc_make_new(const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
+    // parse args
+    mp_map_t kw_args;
+    mp_map_init_fixed_table(&kw_args, n_kw, all_args + n_args);
+    mp_arg_val_t args[MP_ARRAY_SIZE(pyb_adc_init_args)];
+    mp_arg_parse_all(n_args, all_args, &kw_args, MP_ARRAY_SIZE(args), pyb_adc_init_args, args);

-    // the first argument is the channel number
-    uint num = mp_obj_get_int(args[0]);
-    const pin_obj_t *pin;
-    uint channel;
-    switch (num) {
-    case 0:
-        channel = ADC_CH_0;
-        pin = &pin_GPIO2;
-        break;
-    case 1:
-        channel = ADC_CH_1;
-        pin = &pin_GPIO3;
-        break;
-    case 2:
-        channel = ADC_CH_2;
-        pin = &pin_GPIO4;
-        break;
-    case 3:
-        channel = ADC_CH_3;
-        pin = &pin_GPIO5;
-        break;
-    default:
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
-        break;
+    // check the peripheral id
+    if (args[0].u_int != 0) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_resource_not_avaliable));
    }

-    // disable the callback before re-configuring
-    pyb_adc_obj_t *self = &pyb_adc_obj[channel];
+    // check the number of bits
+    if (args[1].u_int != 12) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
+    }
+
+    // setup the object
+    pyb_adc_obj_t *self = &pyb_adc_obj;
    self->base.type = &pyb_adc_type;
-    self->channel = channel;
-    self->num = num;
-
-    // configure the pin in analog mode
-    pin_config ((pin_obj_t *)pin, PIN_MODE_0, GPIO_DIR_MODE_IN, PYBPIN_ANALOG_TYPE, PIN_STRENGTH_2MA);
-
-    // initialize it
-    pybadc_init (self);
-
-    // register it with the sleep module
-    pybsleep_add ((const mp_obj_t)self, (WakeUpCB_t)pybadc_init);

+    // initialize and register with the sleep module
+    pyb_adc_init(self);
+    pyb_sleep_add ((const mp_obj_t)self, (WakeUpCB_t)pyb_adc_init);
    return self;
 }

-/// \method read()
-/// Read the value on the analog pin and return it.  The returned value
-/// will be between 0 and 4095.
-STATIC mp_obj_t adc_read(mp_obj_t self_in) {
-    pyb_adc_obj_t *self = self_in;
-    uint32_t sample;
-
-    // wait until a new value is available
-    while (!MAP_ADCFIFOLvlGet(ADC_BASE, self->channel));
-    // read the sample
-    sample = MAP_ADCFIFORead(ADC_BASE, self->channel);
-    // the 12 bit sampled value is stored in bits [13:2]
-    return MP_OBJ_NEW_SMALL_INT((sample & 0x3FFF) >> 2);
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(adc_read_obj, adc_read);
-
-/// \method enable()
-/// Enable the adc channel
-STATIC mp_obj_t adc_enable(mp_obj_t self_in) {
-    pyb_adc_obj_t *self = self_in;
-
-    pybadc_init(self);
+STATIC mp_obj_t adc_init(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    // parse args
+    mp_arg_val_t args[MP_ARRAY_SIZE(pyb_adc_init_args) - 1];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(args), &pyb_adc_init_args[1], args);
+    // check the number of bits
+    if (args[0].u_int != 12) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
+    }
+    pyb_adc_init(pos_args[0]);
    return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(adc_enable_obj, adc_enable);
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(adc_init_obj, 1, adc_init);

-/// \method disable()
-/// Disable the adc channel
-STATIC mp_obj_t adc_disable(mp_obj_t self_in) {
+STATIC mp_obj_t adc_deinit(mp_obj_t self_in) {
    pyb_adc_obj_t *self = self_in;
-
-    MAP_ADCChannelDisable(ADC_BASE, self->channel);
+    // first deinit all channels
+    pyb_adc_deinit_all_channels();
+    MAP_ADCDisable(ADC_BASE);
+    self->enabled = false;
    // unregister it with the sleep module
-    pybsleep_remove ((const mp_obj_t)self);
+    pyb_sleep_remove ((const mp_obj_t)self);
    return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(adc_disable_obj, adc_disable);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(adc_deinit_obj, adc_deinit);
+
+STATIC mp_obj_t adc_channel(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    STATIC const mp_arg_t pyb_adc_channel_args[] = {
+        { MP_QSTR_id,                          MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_pin,        MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} },
+    };
+
+    // parse args
+    mp_arg_val_t args[MP_ARRAY_SIZE(pyb_adc_channel_args)];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(args), pyb_adc_channel_args, args);
+
+    uint ch_id;
+    if (args[0].u_obj != MP_OBJ_NULL) {
+        ch_id = mp_obj_get_int(args[0].u_obj);
+        if (ch_id >= PYB_ADC_NUM_CHANNELS) {
+            nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_os_resource_not_avaliable));
+        } else if (args[1].u_obj != mp_const_none) {
+            uint pin_ch_id = pin_find_peripheral_type (args[1].u_obj, PIN_FN_ADC, 0);
+            if (ch_id != pin_ch_id) {
+                nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
+            }
+        }
+    } else {
+        ch_id = pin_find_peripheral_type (args[1].u_obj, PIN_FN_ADC, 0);
+    }
+
+    // setup the object
+    pyb_adc_channel_obj_t *self = &pyb_adc_channel_obj[ch_id];
+    self->base.type = &pyb_adc_channel_type;
+    pyb_adc_channel_init (self);
+    // register it with the sleep module
+    pyb_sleep_add ((const mp_obj_t)self, (WakeUpCB_t)pyb_adc_channel_init);
+    return self;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(adc_channel_obj, 1, adc_channel);

 STATIC const mp_map_elem_t adc_locals_dict_table[] = {
-    { MP_OBJ_NEW_QSTR(MP_QSTR_read),                (mp_obj_t)&adc_read_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_enable),              (mp_obj_t)&adc_enable_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_disable),             (mp_obj_t)&adc_disable_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_init),                (mp_obj_t)&adc_init_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_deinit),              (mp_obj_t)&adc_deinit_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_channel),             (mp_obj_t)&adc_channel_obj },
 };

 STATIC MP_DEFINE_CONST_DICT(adc_locals_dict, adc_locals_dict_table);
@@ -210,3 +243,69 @@ const mp_obj_type_t pyb_adc_type = {
    .locals_dict = (mp_obj_t)&adc_locals_dict,
 };

+STATIC void adc_channel_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    pyb_adc_channel_obj_t *self = self_in;
+    if (self->enabled) {
+        mp_printf(print, "ADCChannel(%u, pin=%q)", self->id, self->pin->name);
+    } else {
+        mp_printf(print, "ADCChannel(%u)", self->id);
+    }
+}
+
+STATIC mp_obj_t adc_channel_init(mp_obj_t self_in) {
+    pyb_adc_channel_obj_t *self = self_in;
+    // re-enable it
+    pyb_adc_channel_init(self);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(adc_channel_init_obj, adc_channel_init);
+
+STATIC mp_obj_t adc_channel_deinit(mp_obj_t self_in) {
+    pyb_adc_channel_obj_t *self = self_in;
+
+    MAP_ADCChannelDisable(ADC_BASE, self->channel);
+    // unregister it with the sleep module
+    pyb_sleep_remove ((const mp_obj_t)self);
+    self->enabled = false;
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(adc_channel_deinit_obj, adc_channel_deinit);
+
+STATIC mp_obj_t adc_channel_value(mp_obj_t self_in) {
+    pyb_adc_channel_obj_t *self = self_in;
+    uint32_t value;
+
+    // the channel must be enabled
+    if (!self->enabled) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_request_not_possible));
+    }
+
+    // wait until a new value is available
+    while (!MAP_ADCFIFOLvlGet(ADC_BASE, self->channel));
+    // read the sample
+    value = MAP_ADCFIFORead(ADC_BASE, self->channel);
+    // the 12 bit sampled value is stored in bits [13:2]
+    return MP_OBJ_NEW_SMALL_INT((value & 0x3FFF) >> 2);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(adc_channel_value_obj, adc_channel_value);
+
+STATIC mp_obj_t adc_channel_call(mp_obj_t self_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
+    mp_arg_check_num(n_args, n_kw, 0, 0, false);
+    return adc_channel_value (self_in);
+}
+
+STATIC const mp_map_elem_t adc_channel_locals_dict_table[] = {
+    { MP_OBJ_NEW_QSTR(MP_QSTR_init),                (mp_obj_t)&adc_channel_init_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_deinit),              (mp_obj_t)&adc_channel_deinit_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_value),               (mp_obj_t)&adc_channel_value_obj },
+};
+
+STATIC MP_DEFINE_CONST_DICT(adc_channel_locals_dict, adc_channel_locals_dict_table);
+
+STATIC const mp_obj_type_t pyb_adc_channel_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_ADCChannel,
+    .print = adc_channel_print,
+    .call = adc_channel_call,
+    .locals_dict = (mp_obj_t)&adc_channel_locals_dict,
+};
--- a/cc3200/mods/pybi2c.c
+++ b/cc3200/mods/pybi2c.c
@@ -29,8 +29,8 @@
 #include <string.h>

 #include "py/mpstate.h"
-#include MICROPY_HAL_H
 #include "py/runtime.h"
+#include "py/mphal.h"
 #include "bufhelper.h"
 #include "inc/hw_types.h"
 #include "inc/hw_i2c.h"
@@ -44,51 +44,11 @@
 #include "mpexception.h"
 #include "pybsleep.h"
 #include "utils.h"
+#include "pybpin.h"
+#include "pins.h"

 /// \moduleref pyb
 /// \class I2C - a two-wire serial protocol
-///
-/// I2C is a two-wire protocol for communicating between devices.  At the physical
-/// level it consists of 2 wires: SCL and SDA, the clock and data lines respectively.
-///
-/// I2C objects are created attached to a specific bus.  They can be initialised
-/// when created, or initialised later on:
-///
-///     from pyb import I2C
-///
-///     i2c = I2C()                          # create
-///     i2c = I2C(50000)                     # create and init with a 50KHz baudrate
-///     i2c.init(100000)                     # init with a 100KHz baudrate
-///     i2c.deinit()                         # turn off the peripheral
-///
-/// Printing the i2c object gives you information about its configuration.
-///
-/// Basic methods for slave are send and recv:
-///
-///     i2c.send('abc')      # send 3 bytes
-///     i2c.send(0x42)       # send a single byte, given by the number
-///     data = i2c.recv(3)   # receive 3 bytes
-///
-/// To receive inplace, first create a bytearray:
-///
-///     data = bytearray(3)  # create a buffer
-///     i2c.recv(data)       # receive 3 bytes, writing them into data
-///
-/// A master must specify the recipient's address:
-///
-///     i2c.init(100000)
-///     i2c.send('123', 0x42)        # send 3 bytes to slave with address 0x42
-///     i2c.send(b'456', addr=0x42)  # keyword for address
-///
-/// Master also has other methods:
-///
-///     i2c.is_ready(0x42)              # check if slave 0x42 is ready
-///     i2c.scan()                      # scan for slaves on the bus, returning
-///                                     #   a list of valid addresses
-///     i2c.mem_read(3, 0x42, 2)        # read 3 bytes from memory of slave 0x42,
-///                                     #   starting at address 2 in the slave
-///     i2c.mem_write('abc', 0x42, 2)   # write 3 bytes to memory of slave 0x42,
-///                                     #   starting at address 2 in the slave

 typedef struct _pyb_i2c_obj_t {
    mp_obj_base_t base;
@@ -98,10 +58,12 @@ typedef struct _pyb_i2c_obj_t {
 /******************************************************************************
 DEFINE CONSTANTS
 ******************************************************************************/
+#define PYBI2C_MASTER                          (0)
+
 #define PYBI2C_MIN_BAUD_RATE_HZ                (50000)
 #define PYBI2C_MAX_BAUD_RATE_HZ                (400000)

-#define PYBI2C_TRANSC_TIMEOUT_MS               (10)
+#define PYBI2C_TRANSC_TIMEOUT_MS               (20)
 #define PYBI2C_TRANSAC_WAIT_DELAY_US           (10)

 #define PYBI2C_TIMEOUT_TO_COUNT(to_us, baud)   (((baud) * to_us) / 16000000)
@@ -116,6 +78,12 @@ typedef struct _pyb_i2c_obj_t {
 DECLARE PRIVATE DATA
 ******************************************************************************/
 STATIC pyb_i2c_obj_t pyb_i2c_obj = {.baudrate = 0};
+STATIC const mp_obj_t pyb_i2c_def_pin[2] = {&pin_GP13, &pin_GP23};
+
+/******************************************************************************
+ DECLARE PRIVATE FUNCTIONS
+ ******************************************************************************/
+STATIC bool pyb_i2c_write(byte addr, byte *data, uint len, bool stop);

 /******************************************************************************
 DEFINE PRIVATE FUNCTIONS
@@ -143,13 +111,13 @@ STATIC bool pyb_i2c_transaction(uint cmd) {
    // Wait until the current byte has been transferred.
    // Poll on the raw interrupt status.
    while ((MAP_I2CMasterIntStatusEx(I2CA0_BASE, false) & (I2C_MASTER_INT_DATA | I2C_MASTER_INT_TIMEOUT)) == 0) {
-        // wait for a few microseconds
-        UtilsDelay(UTILS_DELAY_US_TO_COUNT(PYBI2C_TRANSAC_WAIT_DELAY_US));
-        timeout -= PYBI2C_TRANSAC_WAIT_DELAY_US;
        if (timeout < 0) {
            // the peripheral is not responding, so stop
            return false;
        }
+        // wait for a few microseconds
+        UtilsDelay(UTILS_DELAY_US_TO_COUNT(PYBI2C_TRANSAC_WAIT_DELAY_US));
+        timeout -= PYBI2C_TRANSAC_WAIT_DELAY_US;
    }

    // Check for any errors in the transfer
@@ -173,9 +141,69 @@ STATIC bool pyb_i2c_transaction(uint cmd) {
    return true;
 }

-STATIC bool pyb_i2c_write(byte devAddr, byte *data, uint len, bool stop) {
+STATIC void pyb_i2c_check_init(pyb_i2c_obj_t *self) {
+    // not initialized
+    if (!self->baudrate) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_request_not_possible));
+    }
+}
+
+STATIC bool pyb_i2c_scan_device(byte devAddr) {
+    bool ret = false;
+    // Set the I2C slave address
+    MAP_I2CMasterSlaveAddrSet(I2CA0_BASE, devAddr, true);
+    // Initiate the transfer.
+    if (pyb_i2c_transaction(I2C_MASTER_CMD_SINGLE_RECEIVE)) {
+        ret = true;
+    }
+    // Send the stop bit to cancel the read transaction
+    MAP_I2CMasterControl(I2CA0_BASE, I2C_MASTER_CMD_BURST_SEND_ERROR_STOP);
+    if (!ret) {
+        uint8_t data = 0;
+        if (pyb_i2c_write(devAddr, &data, sizeof(data), true)) {
+            ret = true;
+        }
+    }
+    return ret;
+}
+
+STATIC bool pyb_i2c_mem_addr_write (byte addr, byte *mem_addr, uint mem_addr_len) {
    // Set I2C codec slave address
-    MAP_I2CMasterSlaveAddrSet(I2CA0_BASE, devAddr, false);
+    MAP_I2CMasterSlaveAddrSet(I2CA0_BASE, addr, false);
+    // Write the first byte to the controller.
+    MAP_I2CMasterDataPut(I2CA0_BASE, *mem_addr++);
+    // Initiate the transfer.
+    RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_BURST_SEND_START));
+
+    // Loop until the completion of transfer or error
+    while (--mem_addr_len) {
+        // Write the next byte of data
+        MAP_I2CMasterDataPut(I2CA0_BASE, *mem_addr++);
+        // Transact over I2C to send the next byte
+        RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_BURST_SEND_CONT));
+    }
+    return true;
+}
+
+STATIC bool pyb_i2c_mem_write (byte addr, byte *mem_addr, uint mem_addr_len, byte *data, uint data_len) {
+    if (pyb_i2c_mem_addr_write (addr, mem_addr, mem_addr_len)) {
+        // Loop until the completion of transfer or error
+        while (data_len--) {
+            // Write the next byte of data
+            MAP_I2CMasterDataPut(I2CA0_BASE, *data++);
+            // Transact over I2C to send the byte
+            RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_BURST_SEND_CONT));
+        }
+        // send the stop bit
+        RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_BURST_SEND_STOP));
+        return true;
+    }
+    return false;
+}
+
+STATIC bool pyb_i2c_write(byte addr, byte *data, uint len, bool stop) {
+    // Set I2C codec slave address
+    MAP_I2CMasterSlaveAddrSet(I2CA0_BASE, addr, false);
    // Write the first byte to the controller.
    MAP_I2CMasterDataPut(I2CA0_BASE, *data++);
    // Initiate the transfer.
@@ -189,34 +217,20 @@ STATIC bool pyb_i2c_write(byte devAddr, byte *data, uint len, bool stop) {
        RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_BURST_SEND_CONT));
    }

-    // If a stop bit is to be sent, send it.
+    // If a stop bit is to be sent, do it.
    if (stop) {
        RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_BURST_SEND_STOP));
    }
-
    return true;
 }

-STATIC bool pyb_i2c_read(byte devAddr, byte *data, uint len) {
-    uint cmd;
-
+STATIC bool pyb_i2c_read(byte addr, byte *data, uint len) {
+    // Initiate a burst or single receive sequence
+    uint cmd = --len > 0 ? I2C_MASTER_CMD_BURST_RECEIVE_START : I2C_MASTER_CMD_SINGLE_RECEIVE;
    // Set I2C codec slave address
-    MAP_I2CMasterSlaveAddrSet(I2CA0_BASE, devAddr, true);
-
-    // Check if its a single receive or burst receive
-    if (len > 1) {
-        // Initiate a burst receive sequence
-        cmd = I2C_MASTER_CMD_BURST_RECEIVE_START;
-    }
-    else {
-        // Configure for a single receive
-        cmd = I2C_MASTER_CMD_SINGLE_RECEIVE;
-    }
-
+    MAP_I2CMasterSlaveAddrSet(I2CA0_BASE, addr, true);
    // Initiate the transfer.
    RET_IF_ERR(pyb_i2c_transaction(cmd));
-    // Decrement the count
-    len--;
    // Loop until the completion of reception or error
    while (len) {
        // Receive the byte over I2C
@@ -224,8 +238,7 @@ STATIC bool pyb_i2c_read(byte devAddr, byte *data, uint len) {
        if (--len) {
            // Continue with reception
            RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_BURST_RECEIVE_CONT));
-        }
-        else {
+        } else {
            // Complete the last reception
            RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_BURST_RECEIVE_FINISH));
        }
@@ -233,84 +246,122 @@ STATIC bool pyb_i2c_read(byte devAddr, byte *data, uint len) {

    // Receive the last byte over I2C
    *data = MAP_I2CMasterDataGet(I2CA0_BASE);
-
    return true;
 }

-STATIC bool pyb_i2c_scan_device(byte devAddr) {
-    // Set I2C codec slave address
-    MAP_I2CMasterSlaveAddrSet(I2CA0_BASE, devAddr, true);
-    // Initiate the transfer.
-    RET_IF_ERR(pyb_i2c_transaction(I2C_MASTER_CMD_SINGLE_RECEIVE));
-    // Since this is a hack, send the stop bit anyway
-    MAP_I2CMasterControl(I2CA0_BASE, I2C_MASTER_CMD_BURST_SEND_ERROR_STOP);
+STATIC void pyb_i2c_read_into (mp_arg_val_t *args, vstr_t *vstr) {
+    pyb_i2c_check_init(&pyb_i2c_obj);
+    // get the buffer to receive into
+    pyb_buf_get_for_recv(args[1].u_obj, vstr);

-    return true;
+    // receive the data
+    if (!pyb_i2c_read(args[0].u_int, (byte *)vstr->buf, vstr->len)) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_operation_failed));
+    }
+}
+
+STATIC void pyb_i2c_readmem_into (mp_arg_val_t *args, vstr_t *vstr) {
+    pyb_i2c_check_init(&pyb_i2c_obj);
+    // get the buffer to receive into
+    pyb_buf_get_for_recv(args[2].u_obj, vstr);
+
+    // get the addresses
+    mp_uint_t i2c_addr = args[0].u_int;
+    mp_uint_t mem_addr = args[1].u_int;
+    // determine the width of mem_addr (1 or 2 bytes)
+    mp_uint_t mem_addr_size = args[3].u_int >> 3;
+
+    // write the register address to be read from
+    if (pyb_i2c_mem_addr_write (i2c_addr, (byte *)&mem_addr, mem_addr_size)) {
+        // Read the specified length of data
+        if (!pyb_i2c_read (i2c_addr, (byte *)vstr->buf, vstr->len)) {
+            nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_operation_failed));
+        }
+    }
 }

 /******************************************************************************/
 /* Micro Python bindings                                                      */
 /******************************************************************************/
-
-/// \method init(100000)
-///
-/// Initialise the I2C bus as a master with the given baudrate.
-///
-STATIC mp_obj_t pyb_i2c_init_helper(pyb_i2c_obj_t *self_in, mp_obj_t baudrate) {
+STATIC void pyb_i2c_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
    pyb_i2c_obj_t *self = self_in;
+    if (self->baudrate > 0) {
+        mp_printf(print, "I2C(0, I2C.MASTER, baudrate=%u)", self->baudrate);
+    } else {
+        mp_print_str(print, "I2C(0)");
+    }
+}
+
+STATIC mp_obj_t pyb_i2c_init_helper(pyb_i2c_obj_t *self, const mp_arg_val_t *args) {
+    // verify that mode is master
+    if (args[0].u_int != PYBI2C_MASTER) {
+        goto invalid_args;
+    }

    // make sure the baudrate is between the valid range
-    self->baudrate = MIN(MAX(mp_obj_get_int(baudrate), PYBI2C_MIN_BAUD_RATE_HZ), PYBI2C_MAX_BAUD_RATE_HZ);
+    self->baudrate = MIN(MAX(args[1].u_int, PYBI2C_MIN_BAUD_RATE_HZ), PYBI2C_MAX_BAUD_RATE_HZ);
+
+    // assign the pins
+    mp_obj_t pins_o = args[2].u_obj;
+    if (pins_o != mp_const_none) {
+        mp_obj_t *pins;
+        if (pins_o == MP_OBJ_NULL) {
+            // use the default pins
+            pins = (mp_obj_t *)pyb_i2c_def_pin;
+        } else {
+            mp_obj_get_array_fixed_n(pins_o, 2, &pins);
+        }
+        pin_assign_pins_af (pins, 2, PIN_TYPE_STD_PU, PIN_FN_I2C, 0);
+    }

    // init the I2C bus
    i2c_init(self);

    // register it with the sleep module
-    pybsleep_add ((const mp_obj_t)self, (WakeUpCB_t)i2c_init);
+    pyb_sleep_add ((const mp_obj_t)self, (WakeUpCB_t)i2c_init);

    return mp_const_none;
+
+invalid_args:
+    nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
 }

-/// \classmethod \constructor(bus, ...)
-///
-/// Construct an I2C object on the given bus.  `bus` can only be 0.
-/// With no additional parameters, the I2C object is created but not
-/// initialised (it has the settings from the last initialisation of
-/// the bus, if any).  If extra arguments are given, the bus is initialised.
-/// See `init` for parameters of initialisation.
-STATIC mp_obj_t pyb_i2c_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
-    // check arguments
-    mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
+STATIC const mp_arg_t pyb_i2c_init_args[] = {
+    { MP_QSTR_id,                          MP_ARG_INT, {.u_int = 0} },
+    { MP_QSTR_mode,                        MP_ARG_INT, {.u_int = PYBI2C_MASTER} },
+    { MP_QSTR_baudrate,  MP_ARG_KW_ONLY  | MP_ARG_INT, {.u_int = 100000} },
+    { MP_QSTR_pins,      MP_ARG_KW_ONLY  | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+};
+STATIC mp_obj_t pyb_i2c_make_new(const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
+    // parse args
+    mp_map_t kw_args;
+    mp_map_init_fixed_table(&kw_args, n_kw, all_args + n_args);
+    mp_arg_val_t args[MP_ARRAY_SIZE(pyb_i2c_init_args)];
+    mp_arg_parse_all(n_args, all_args, &kw_args, MP_ARRAY_SIZE(args), pyb_i2c_init_args, args);
+
+    // check the peripheral id
+    if (args[0].u_int != 0) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_resource_not_avaliable));
+    }

    // setup the object
    pyb_i2c_obj_t *self = &pyb_i2c_obj;
    self->base.type = &pyb_i2c_type;

-    if (n_args > 0) {
-        // start the peripheral
-        pyb_i2c_init_helper(self, *args);
-    }
+    // start the peripheral
+    pyb_i2c_init_helper(self, &args[1]);

    return (mp_obj_t)self;
 }

-STATIC void pyb_i2c_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
-    pyb_i2c_obj_t *self = self_in;
-    if (self->baudrate > 0) {
-        mp_printf(print, "<I2C0, I2C.MASTER, baudrate=%u>)", self->baudrate);
-    }
-    else {
-        mp_print_str(print, "<I2C0>");
-    }
+STATIC mp_obj_t pyb_i2c_init(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    // parse args
+    mp_arg_val_t args[MP_ARRAY_SIZE(pyb_i2c_init_args) - 1];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(args), &pyb_i2c_init_args[1], args);
+    return pyb_i2c_init_helper(pos_args[0], args);
 }
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_init_obj, 1, pyb_i2c_init);

-STATIC mp_obj_t pyb_i2c_init(mp_obj_t self_in, mp_obj_t baudrate) {
-    return pyb_i2c_init_helper(self_in, baudrate);
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_i2c_init_obj, pyb_i2c_init);
-
-/// \method deinit()
-/// Turn off the I2C bus.
 STATIC mp_obj_t pyb_i2c_deinit(mp_obj_t self_in) {
    // disable the peripheral
    MAP_I2CMasterDisable(I2CA0_BASE);
@@ -318,217 +369,169 @@ STATIC mp_obj_t pyb_i2c_deinit(mp_obj_t self_in) {
    // invalidate the baudrate
    pyb_i2c_obj.baudrate = 0;
    // unregister it with the sleep module
-    pybsleep_remove ((const mp_obj_t)self_in);
+    pyb_sleep_remove ((const mp_obj_t)self_in);
    return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_i2c_deinit_obj, pyb_i2c_deinit);

-/// \method is_ready(addr)
-/// Check if an I2C device responds to the given address.  Only valid when in master mode.
-STATIC mp_obj_t pyb_i2c_is_ready(mp_obj_t self_in, mp_obj_t i2c_addr_o) {
-    mp_uint_t i2c_addr = mp_obj_get_int(i2c_addr_o);
-    for (int i = 0; i < 7; i++) {
-        if (pyb_i2c_scan_device(i2c_addr)) {
-            return mp_const_true;
-        }
-    }
-    return mp_const_false;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_i2c_is_ready_obj, pyb_i2c_is_ready);
-
-/// \method scan()
-/// Scan all I2C addresses from 0x01 to 0x7f and return a list of those that respond.
-/// Only valid when in master mode.
 STATIC mp_obj_t pyb_i2c_scan(mp_obj_t self_in) {
+    pyb_i2c_check_init(&pyb_i2c_obj);
    mp_obj_t list = mp_obj_new_list(0, NULL);
-    for (uint addr = 1; addr <= 127; addr++) {
-        for (int i = 0; i < 7; i++) {
+    for (uint addr = 0x08; addr <= 0x77; addr++) {
+        for (int i = 0; i < 3; i++) {
            if (pyb_i2c_scan_device(addr)) {
                mp_obj_list_append(list, mp_obj_new_int(addr));
                break;
            }
        }
    }
-
    return list;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_i2c_scan_obj, pyb_i2c_scan);

-/// \method send(send, addr=0x00)
-/// Send data on the bus:
-///
-///   - `send` is the data to send (an integer to send, or a buffer object)
-///   - `addr` is the address to send to (only required in master mode)
-/// Return value: `None`.
-STATIC const mp_arg_t pyb_i2c_send_args[] = {
-    { MP_QSTR_send,    MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
-    { MP_QSTR_addr,                      MP_ARG_INT, {.u_int = 0} },
-};
-#define PYB_I2C_SEND_NUM_ARGS MP_ARRAY_SIZE(pyb_i2c_send_args)
+STATIC mp_obj_t pyb_i2c_readfrom(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    STATIC const mp_arg_t pyb_i2c_readfrom_args[] = {
+        { MP_QSTR_addr,    MP_ARG_REQUIRED | MP_ARG_INT, },
+        { MP_QSTR_nbytes,  MP_ARG_REQUIRED | MP_ARG_OBJ, },
+    };

-STATIC mp_obj_t pyb_i2c_send(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
    // parse args
-    mp_arg_val_t vals[PYB_I2C_SEND_NUM_ARGS];
-    mp_arg_parse_all(n_args - 1, args + 1, kw_args, PYB_I2C_SEND_NUM_ARGS, pyb_i2c_send_args, vals);
+    mp_arg_val_t args[MP_ARRAY_SIZE(pyb_i2c_readfrom_args)];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(args), pyb_i2c_readfrom_args, args);
+
+    vstr_t vstr;
+    pyb_i2c_read_into(args, &vstr);
+
+    // return the received data
+    return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_readfrom_obj, 3, pyb_i2c_readfrom);
+
+STATIC mp_obj_t pyb_i2c_readfrom_into(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    STATIC const mp_arg_t pyb_i2c_readfrom_into_args[] = {
+        { MP_QSTR_addr,    MP_ARG_REQUIRED | MP_ARG_INT, },
+        { MP_QSTR_buf,     MP_ARG_REQUIRED | MP_ARG_OBJ, },
+    };
+
+    // parse args
+    mp_arg_val_t args[MP_ARRAY_SIZE(pyb_i2c_readfrom_into_args)];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(args), pyb_i2c_readfrom_into_args, args);
+
+    vstr_t vstr;
+    pyb_i2c_read_into(args, &vstr);
+
+    // return the number of bytes received
+    return mp_obj_new_int(vstr.len);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_readfrom_into_obj, 1, pyb_i2c_readfrom_into);
+
+STATIC mp_obj_t pyb_i2c_writeto(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    STATIC const mp_arg_t pyb_i2c_writeto_args[] = {
+        { MP_QSTR_addr,    MP_ARG_REQUIRED | MP_ARG_INT,  },
+        { MP_QSTR_buf,     MP_ARG_REQUIRED | MP_ARG_OBJ,  },
+        { MP_QSTR_stop,    MP_ARG_KW_ONLY  | MP_ARG_BOOL, {.u_bool = true} },
+    };
+
+    // parse args
+    mp_arg_val_t args[MP_ARRAY_SIZE(pyb_i2c_writeto_args)];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(args), pyb_i2c_writeto_args, args);
+
+    pyb_i2c_check_init(&pyb_i2c_obj);

    // get the buffer to send from
    mp_buffer_info_t bufinfo;
    uint8_t data[1];
-    pyb_buf_get_for_send(vals[0].u_obj, &bufinfo, data);
+    pyb_buf_get_for_send(args[1].u_obj, &bufinfo, data);

    // send the data
-    if (!pyb_i2c_write(vals[1].u_int, bufinfo.buf, bufinfo.len, true)) {
+    if (!pyb_i2c_write(args[0].u_int, bufinfo.buf, bufinfo.len, args[2].u_bool)) {
        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_operation_failed));
    }

-    return mp_const_none;
+    // return the number of bytes written
+    return mp_obj_new_int(bufinfo.len);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_send_obj, 1, pyb_i2c_send);
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_writeto_obj, 1, pyb_i2c_writeto);

-/// \method recv(recv, addr=0x00)
-///
-/// Receive data on the bus:
-///
-///   - `recv` can be an integer, which is the number of bytes to receive,
-///     or a mutable buffer, which will be filled with received bytes
-///   - `addr` is the address to receive from (only required in master mode)
-///
-/// Return value: if `recv` is an integer then a new buffer of the bytes received,
-/// otherwise the same buffer that was passed in to `recv`.
-STATIC const mp_arg_t pyb_i2c_recv_args[] = {
-    { MP_QSTR_recv,    MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
-    { MP_QSTR_addr,                      MP_ARG_INT, {.u_int = 0} },
-};
-#define PYB_I2C_RECV_NUM_ARGS MP_ARRAY_SIZE(pyb_i2c_recv_args)
+STATIC mp_obj_t pyb_i2c_readfrom_mem(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    STATIC const mp_arg_t pyb_i2c_readfrom_mem_args[] = {
+        { MP_QSTR_addr,     MP_ARG_REQUIRED  | MP_ARG_INT, },
+        { MP_QSTR_memaddr,  MP_ARG_REQUIRED  | MP_ARG_INT, },
+        { MP_QSTR_nbytes,   MP_ARG_REQUIRED  | MP_ARG_OBJ, },
+        { MP_QSTR_addrsize, MP_ARG_KW_ONLY   | MP_ARG_INT, {.u_int = 8} },
+    };

-STATIC mp_obj_t pyb_i2c_recv(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
    // parse args
-    mp_arg_val_t vals[PYB_I2C_RECV_NUM_ARGS];
-    mp_arg_parse_all(n_args - 1, args + 1, kw_args, PYB_I2C_RECV_NUM_ARGS, pyb_i2c_recv_args, vals);
+    mp_arg_val_t args[MP_ARRAY_SIZE(pyb_i2c_readfrom_mem_args)];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(args), pyb_i2c_readfrom_mem_args, args);

-    // get the buffer to receive into
    vstr_t vstr;
-    mp_obj_t o_ret = pyb_buf_get_for_recv(vals[0].u_obj, &vstr);
-
-    // receive the data
-    if (!pyb_i2c_read(vals[1].u_int, (byte *)vstr.buf, vstr.len)) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_operation_failed));
-    }
-
-    // return the received data
-    if (o_ret != MP_OBJ_NULL) {
-        return o_ret;
-    }
-    else {
-        return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
-    }
+    pyb_i2c_readmem_into (args, &vstr);
+    return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_recv_obj, 1, pyb_i2c_recv);
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_readfrom_mem_obj, 1, pyb_i2c_readfrom_mem);

-/// \method mem_read(data, addr, memaddr, addr_size=8)
-///
-/// Read from the memory of an I2C device:
-///
-///   - `data` can be an integer or a buffer to read into
-///   - `addr` is the I2C device address
-///   - `memaddr` is the memory location within the I2C device
-///   - `addr_size` selects the width of memaddr: 8 or 16 bits
-///
-/// Returns the read data.
-/// This is only valid in master mode.
-STATIC const mp_arg_t pyb_i2c_mem_read_args[] = {
-    { MP_QSTR_data,      MP_ARG_REQUIRED  | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
-    { MP_QSTR_addr,      MP_ARG_REQUIRED  | MP_ARG_INT, {.u_int = 0} },
-    { MP_QSTR_memaddr,   MP_ARG_REQUIRED  | MP_ARG_INT, {.u_int = 0} },
-    { MP_QSTR_addr_size, MP_ARG_KW_ONLY   | MP_ARG_INT, {.u_int = 8} },
+STATIC const mp_arg_t pyb_i2c_readfrom_mem_into_args[] = {
+    { MP_QSTR_addr,     MP_ARG_REQUIRED  | MP_ARG_INT, },
+    { MP_QSTR_memaddr,  MP_ARG_REQUIRED  | MP_ARG_INT, },
+    { MP_QSTR_buf,      MP_ARG_REQUIRED  | MP_ARG_OBJ, },
+    { MP_QSTR_addrsize, MP_ARG_KW_ONLY   | MP_ARG_INT, {.u_int = 8} },
 };
-#define PYB_I2C_MEM_READ_NUM_ARGS MP_ARRAY_SIZE(pyb_i2c_mem_read_args)

-STATIC mp_obj_t pyb_i2c_mem_read(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
+STATIC mp_obj_t pyb_i2c_readfrom_mem_into(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
    // parse args
-    mp_arg_val_t vals[PYB_I2C_MEM_READ_NUM_ARGS];
-    mp_arg_parse_all(n_args - 1, args + 1, kw_args, PYB_I2C_MEM_READ_NUM_ARGS, pyb_i2c_mem_read_args, vals);
+    mp_arg_val_t args[MP_ARRAY_SIZE(pyb_i2c_readfrom_mem_into_args)];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(args), pyb_i2c_readfrom_mem_into_args, args);

    // get the buffer to read into
    vstr_t vstr;
-    mp_obj_t o_ret = pyb_buf_get_for_recv(vals[0].u_obj, &vstr);
-
-    // get the addresses
-    mp_uint_t i2c_addr = vals[1].u_int;
-    mp_uint_t mem_addr = vals[2].u_int;
-    // determine the width of mem_addr (1 or 2 bytes)
-    mp_uint_t mem_addr_size = vals[3].u_int >> 3;
-
-    // Write the register address to be read from.
-    if (pyb_i2c_write (i2c_addr, (byte *)&mem_addr, mem_addr_size, false)) {
-        // Read the specified length of data
-        if (pyb_i2c_read (i2c_addr, (byte *)vstr.buf, vstr.len)) {
-            // return the read data
-            if (o_ret != MP_OBJ_NULL) {
-                return o_ret;
-            } else {
-                return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
-            }
-        }
-    }
-
-    nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_operation_failed));
-
-    return mp_const_none;
+    pyb_i2c_readmem_into (args, &vstr);
+    return mp_obj_new_int(vstr.len);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_mem_read_obj, 1, pyb_i2c_mem_read);
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_readfrom_mem_into_obj, 1, pyb_i2c_readfrom_mem_into);

-/// \method mem_write(data, addr, memaddr, addr_size=8)
-///
-/// Write to the memory of an I2C device:
-///
-///   - `data` can be an integer or a buffer to write from
-///   - `addr` is the I2C device address
-///   - `memaddr` is the memory location within the I2C device
-///   - `addr_size` selects the width of memaddr: 8 or 16 bits
-///
-/// Returns `None`.
-/// This is only valid in master mode.
-STATIC mp_obj_t pyb_i2c_mem_write(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
-    // parse args (same as mem_read)
-    mp_arg_val_t vals[PYB_I2C_MEM_READ_NUM_ARGS];
-    mp_arg_parse_all(n_args - 1, args + 1, kw_args, PYB_I2C_MEM_READ_NUM_ARGS, pyb_i2c_mem_read_args, vals);
+STATIC mp_obj_t pyb_i2c_writeto_mem(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    // parse args
+    mp_arg_val_t args[MP_ARRAY_SIZE(pyb_i2c_readfrom_mem_into_args)];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(pyb_i2c_readfrom_mem_into_args), pyb_i2c_readfrom_mem_into_args, args);
+
+    pyb_i2c_check_init(&pyb_i2c_obj);

    // get the buffer to write from
    mp_buffer_info_t bufinfo;
    uint8_t data[1];
-    pyb_buf_get_for_send(vals[0].u_obj, &bufinfo, data);
+    pyb_buf_get_for_send(args[2].u_obj, &bufinfo, data);

    // get the addresses
-    mp_uint_t i2c_addr = vals[1].u_int;
-    mp_uint_t mem_addr = vals[2].u_int;
+    mp_uint_t i2c_addr = args[0].u_int;
+    mp_uint_t mem_addr = args[1].u_int;
    // determine the width of mem_addr (1 or 2 bytes)
-    mp_uint_t mem_addr_size = vals[3].u_int >> 3;
+    mp_uint_t mem_addr_size = args[3].u_int >> 3;

-    // Write the register address to write to.
-    if (pyb_i2c_write (i2c_addr, (byte *)&mem_addr, mem_addr_size, false)) {
-        // Write the specified length of data
-        if (pyb_i2c_write (i2c_addr, bufinfo.buf, bufinfo.len, true)) {
-            return mp_const_none;
-        }
+    // write the register address to write to.
+    if (pyb_i2c_mem_write (i2c_addr, (byte *)&mem_addr, mem_addr_size, bufinfo.buf, bufinfo.len)) {
+        // return the number of bytes written
+        return mp_obj_new_int(bufinfo.len);
    }

    nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_operation_failed));
-
-    return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_mem_write_obj, 1, pyb_i2c_mem_write);
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_i2c_writeto_mem_obj, 1, pyb_i2c_writeto_mem);

 STATIC const mp_map_elem_t pyb_i2c_locals_dict_table[] = {
    // instance methods
-    { MP_OBJ_NEW_QSTR(MP_QSTR_init),            (mp_obj_t)&pyb_i2c_init_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_deinit),          (mp_obj_t)&pyb_i2c_deinit_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_is_ready),        (mp_obj_t)&pyb_i2c_is_ready_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_scan),            (mp_obj_t)&pyb_i2c_scan_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_send),            (mp_obj_t)&pyb_i2c_send_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_recv),            (mp_obj_t)&pyb_i2c_recv_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_mem_read),        (mp_obj_t)&pyb_i2c_mem_read_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_mem_write),       (mp_obj_t)&pyb_i2c_mem_write_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_init),                (mp_obj_t)&pyb_i2c_init_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_deinit),              (mp_obj_t)&pyb_i2c_deinit_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_scan),                (mp_obj_t)&pyb_i2c_scan_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_readfrom),            (mp_obj_t)&pyb_i2c_readfrom_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_readfrom_into),       (mp_obj_t)&pyb_i2c_readfrom_into_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_writeto),             (mp_obj_t)&pyb_i2c_writeto_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_readfrom_mem),        (mp_obj_t)&pyb_i2c_readfrom_mem_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_readfrom_mem_into),   (mp_obj_t)&pyb_i2c_readfrom_mem_into_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_writeto_mem),         (mp_obj_t)&pyb_i2c_writeto_mem_obj },
+
+    // class constants
+    { MP_OBJ_NEW_QSTR(MP_QSTR_MASTER),              MP_OBJ_NEW_SMALL_INT(PYBI2C_MASTER) },
 };

 STATIC MP_DEFINE_CONST_DICT(pyb_i2c_locals_dict, pyb_i2c_locals_dict_table);
--- a/cc3200/mods/pybpin.c
+++ b/cc3200/mods/pybpin.c
--- a/cc3200/mods/pybpin.h
+++ b/cc3200/mods/pybpin.h
@@ -28,24 +28,90 @@
 #ifndef PYBPIN_H_
 #define PYBPIN_H_

-// This file requires pin_defs_xxx.h (which has port specific enums and
-// defines, so we include it here. It should never be included directly
+enum {
+    PORT_A0 = GPIOA0_BASE,
+    PORT_A1 = GPIOA1_BASE,
+    PORT_A2 = GPIOA2_BASE,
+    PORT_A3 = GPIOA3_BASE,
+};

-#include MICROPY_PIN_DEFS_PORT_H
+enum {
+    PIN_FN_UART = 0,
+    PIN_FN_SPI,
+    PIN_FN_I2S,
+    PIN_FN_I2C,
+    PIN_FN_TIM,
+    PIN_FN_SD,
+    PIN_FN_ADC,
+};

-#define PYBPIN_ANALOG_TYPE          0xFF
+enum {
+    PIN_TYPE_UART_TX = 0,
+    PIN_TYPE_UART_RX,
+    PIN_TYPE_UART_RTS,
+    PIN_TYPE_UART_CTS,
+};
+
+enum {
+    PIN_TYPE_SPI_CLK = 0,
+    PIN_TYPE_SPI_MOSI,
+    PIN_TYPE_SPI_MISO,
+    PIN_TYPE_SPI_CS0,
+};
+
+enum {
+    PIN_TYPE_I2S_CLK = 0,
+    PIN_TYPE_I2S_FS,
+    PIN_TYPE_I2S_DAT0,
+    PIN_TYPE_I2S_DAT1,
+};
+
+enum {
+    PIN_TYPE_I2C_SDA = 0,
+    PIN_TYPE_I2C_SCL,
+};
+
+enum {
+    PIN_TYPE_TIM_PWM = 0,
+};
+
+enum {
+    PIN_TYPE_SD_CLK = 0,
+    PIN_TYPE_SD_CMD,
+    PIN_TYPE_SD_DAT0,
+};
+
+enum {
+    PIN_TYPE_ADC_CH0 = 0,
+    PIN_TYPE_ADC_CH1,
+    PIN_TYPE_ADC_CH2,
+    PIN_TYPE_ADC_CH3,
+};
+
+typedef struct {
+  qstr name;
+  int8_t  idx;
+  uint8_t fn;
+  uint8_t unit;
+  uint8_t type;
+} pin_af_t;

 typedef struct {
    const mp_obj_base_t base;
    const qstr          name;
    const uint32_t      port;
-    uint16_t            type;
+    const pin_af_t      *af_list;
+    uint16_t            pull;
    const uint8_t       bit;
    const uint8_t       pin_num;
-    uint8_t             af;
+    int8_t              af;
    uint8_t             strength;
-    uint8_t             mode;
-    bool                isused;
+    uint8_t             mode;        // this is now a combination of type and mode
+    const uint8_t       num_afs;     // 255 AFs
+    uint8_t             value;
+    uint8_t             used;
+    uint8_t             irq_trigger;
+    uint8_t             irq_flags;
 } pin_obj_t;

 extern const mp_obj_type_t pin_type;
@@ -61,19 +127,15 @@ typedef struct {
    const pin_named_pin_t *named_pins;
 } pin_named_pins_obj_t;

-extern const mp_obj_type_t pin_cpu_pins_obj_type;
-extern const mp_obj_dict_t pin_cpu_pins_locals_dict;
+extern const mp_obj_type_t pin_board_pins_obj_type;
+extern const mp_obj_dict_t pin_board_pins_locals_dict;

 void pin_init0(void);
-void pin_verify_af (uint af);
-void pin_config(pin_obj_t *self, uint af, uint mode, uint type, uint strength);
-void pin_extint_register(pin_obj_t *self, uint32_t intmode, uint32_t priority);
+void pin_config(pin_obj_t *self, int af, uint mode, uint type, int value, uint strength);
 pin_obj_t *pin_find(mp_obj_t user_obj);
-pin_obj_t *pin_find_named_pin(const mp_obj_dict_t *named_pins, mp_obj_t name);
-pin_obj_t *pin_find_pin(const mp_obj_dict_t *named_pins, uint pin_num);
-pin_obj_t *pin_find_pin_by_port_bit (const mp_obj_dict_t *named_pins, uint port, uint bit);
-uint32_t pin_get_mode(const pin_obj_t *self);
-uint32_t pin_get_type(const pin_obj_t *self);
-uint32_t pin_get_strenght(const pin_obj_t *self);
+void pin_assign_pins_af (mp_obj_t *pins, uint32_t n_pins, uint32_t pull, uint32_t fn, uint32_t unit);
+uint8_t pin_find_peripheral_unit (const mp_obj_t pin, uint8_t fn, uint8_t type);
+uint8_t pin_find_peripheral_type (const mp_obj_t pin, uint8_t fn, uint8_t unit);
+int8_t pin_find_af_index (const pin_obj_t* pin, uint8_t fn, uint8_t unit, uint8_t type);;

 #endif  // PYBPIN_H_
--- a/cc3200/mods/pybrtc.c
+++ b/cc3200/mods/pybrtc.c
@@ -25,224 +25,462 @@
 * THE SOFTWARE.
 */

-#include <stdio.h>
+#include <std.h>

 #include "py/mpconfig.h"
-#include MICROPY_HAL_H
 #include "py/obj.h"
 #include "py/runtime.h"
-#include "modutime.h"
 #include "inc/hw_types.h"
 #include "inc/hw_ints.h"
 #include "inc/hw_memmap.h"
 #include "rom_map.h"
 #include "prcm.h"
 #include "pybrtc.h"
+#include "mpirq.h"
 #include "pybsleep.h"
-#include "mpcallback.h"
+#include "timeutils.h"
+#include "simplelink.h"
+#include "modnetwork.h"
+#include "modwlan.h"
+#include "mpexception.h"

 /// \moduleref pyb
 /// \class RTC - real time clock
-///
-/// The RTC is and independent clock that keeps track of the date
-/// and time.
-///
-/// Example usage:
-///
-///     rtc = pyb.RTC()
-///     rtc.datetime((2014, 5, 1, 4, 13, 0, 0, 0))
-///     print(rtc.datetime())
-
-/******************************************************************************
- DECLARE CONSTANTS
- ******************************************************************************/
-#define PYBRTC_CLOCK_FREQUENCY_HZ                   32768
-#define PYBRTC_MIN_INTERVAL_VALUE                   25
-
-/******************************************************************************
- DEFINE TYPES
- ******************************************************************************/
-typedef struct {
-    byte prwmode;
-} pybrtc_data_t;

 /******************************************************************************
 DECLARE PRIVATE DATA
 ******************************************************************************/
-STATIC pybrtc_data_t pybrtc_data;
-STATIC const mp_cb_methods_t pybrtc_cb_methods;
+STATIC const mp_irq_methods_t pyb_rtc_irq_methods;
+STATIC pyb_rtc_obj_t pyb_rtc_obj;
+
+/******************************************************************************
+ FUNCTION-LIKE MACROS
+ ******************************************************************************/
+#define RTC_U16MS_CYCLES(msec)          ((msec   * 1024) / 1000)
+#define RTC_CYCLES_U16MS(cycles)        ((cycles * 1000) / 1024)
+
+/******************************************************************************
+ DECLARE PRIVATE FUNCTIONS
+ ******************************************************************************/
+STATIC void pyb_rtc_set_time (uint32_t secs, uint16_t msecs);
+STATIC uint32_t pyb_rtc_reset (void);
+STATIC void pyb_rtc_disable_interupt (void);
+STATIC void pyb_rtc_irq_enable (mp_obj_t self_in);
+STATIC void pyb_rtc_irq_disable (mp_obj_t self_in);
+STATIC int pyb_rtc_irq_flags (mp_obj_t self_in);
+STATIC uint pyb_rtc_datetime_s_us(const mp_obj_t datetime, uint32_t *seconds);
+STATIC mp_obj_t pyb_rtc_datetime(mp_obj_t self, const mp_obj_t datetime);
+STATIC void pyb_rtc_set_alarm (pyb_rtc_obj_t *self, uint32_t seconds, uint16_t mseconds);
+STATIC void rtc_msec_add(uint16_t msecs_1, uint32_t *secs, uint16_t *msecs_2);

 /******************************************************************************
 DECLARE PUBLIC FUNCTIONS
 ******************************************************************************/
 __attribute__ ((section (".boot")))
-void pybrtc_init(void) {
-    // if the RTC was previously set, leave it alone
+void pyb_rtc_pre_init(void) {
+    // only if comming out of a power-on reset
    if (MAP_PRCMSysResetCauseGet() == PRCM_POWER_ON) {
-        // fresh reset; configure the RTC Calendar
-        // set the date to 1st Jan 2015
-        // set the time to 00:00:00
-        uint32_t seconds = mod_time_seconds_since_2000(2015, 1, 1, 0, 0, 0);
-
        // Mark the RTC in use first
        MAP_PRCMRTCInUseSet();
-
-        // Now set the RTC calendar seconds
-        MAP_PRCMRTCSet(seconds, 0);
+        // reset the time and date
+        pyb_rtc_reset();
    }
 }

+void pyb_rtc_get_time (uint32_t *secs, uint16_t *msecs) {
+    uint16_t cycles;
+    MAP_PRCMRTCGet (secs, &cycles);
+    *msecs = RTC_CYCLES_U16MS(cycles);
+}
+
+uint32_t pyb_rtc_get_seconds (void) {
+    uint32_t seconds;
+    uint16_t mseconds;
+    pyb_rtc_get_time(&seconds, &mseconds);
+    return seconds;
+}
+
+void pyb_rtc_calc_future_time (uint32_t a_mseconds, uint32_t *f_seconds, uint16_t *f_mseconds) {
+    uint32_t c_seconds;
+    uint16_t c_mseconds;
+    // get the current time
+    pyb_rtc_get_time(&c_seconds, &c_mseconds);
+    // calculate the future seconds
+    *f_seconds = c_seconds + (a_mseconds / 1000);
+    // calculate the "remaining" future mseconds
+    *f_mseconds = a_mseconds % 1000;
+    // add the current milliseconds
+    rtc_msec_add (c_mseconds, f_seconds, f_mseconds);
+}
+
+void pyb_rtc_repeat_alarm (pyb_rtc_obj_t *self) {
+    if (self->repeat) {
+        uint32_t f_seconds, c_seconds;
+        uint16_t f_mseconds, c_mseconds;
+
+        pyb_rtc_get_time(&c_seconds, &c_mseconds);
+
+        // substract the time elapsed between waking up and setting up the alarm again
+        int32_t wake_ms = ((c_seconds * 1000) + c_mseconds) - ((self->alarm_time_s * 1000) + self->alarm_time_ms);
+        int32_t next_alarm = self->alarm_ms - wake_ms;
+        next_alarm = next_alarm > 0 ? next_alarm : PYB_RTC_MIN_ALARM_TIME_MS;
+        pyb_rtc_calc_future_time (next_alarm, &f_seconds, &f_mseconds);
+
+        // now configure the alarm
+        pyb_rtc_set_alarm (self, f_seconds, f_mseconds);
+    }
+}
+
+void pyb_rtc_disable_alarm (void) {
+    pyb_rtc_obj.alarmset = false;
+    pyb_rtc_disable_interupt();
+}
+
 /******************************************************************************
 DECLARE PRIVATE FUNCTIONS
 ******************************************************************************/
-STATIC void pyb_rtc_callback_enable (mp_obj_t self_in) {
-    // check the wake from param
-    if (pybrtc_data.prwmode & PYB_PWR_MODE_ACTIVE) {
-        // enable the slow clock interrupt
-        MAP_PRCMIntEnable(PRCM_INT_SLOW_CLK_CTR);
-    }
-    else {
-        // just in case it was already enabled before
-        MAP_PRCMIntDisable(PRCM_INT_SLOW_CLK_CTR);
-    }
-    pybsleep_configure_timer_wakeup (pybrtc_data.prwmode);
+STATIC void pyb_rtc_set_time (uint32_t secs, uint16_t msecs) {
+    // add the RTC access time
+    rtc_msec_add(RTC_ACCESS_TIME_MSEC, &secs, &msecs);
+    // convert from mseconds to cycles
+    msecs = RTC_U16MS_CYCLES(msecs);
+    // now set the time
+    MAP_PRCMRTCSet(secs, msecs);
 }

-STATIC void pyb_rtc_callback_disable (mp_obj_t self_in) {
-    // check the wake from param
-    if (pybrtc_data.prwmode & PYB_PWR_MODE_ACTIVE) {
-        // enable the slow clock interrupt
+STATIC uint32_t pyb_rtc_reset (void) {
+    // fresh reset; configure the RTC Calendar
+    // set the date to 1st Jan 2015
+    // set the time to 00:00:00
+    uint32_t seconds = timeutils_seconds_since_2000(2015, 1, 1, 0, 0, 0);
+    // disable any running alarm
+    pyb_rtc_disable_alarm();
+    // Now set the RTC calendar time
+    pyb_rtc_set_time(seconds, 0);
+    return seconds;
+}
+
+STATIC void pyb_rtc_disable_interupt (void) {
+    uint primsk = disable_irq();
+    MAP_PRCMIntDisable(PRCM_INT_SLOW_CLK_CTR);
+    (void)MAP_PRCMIntStatus();
+    enable_irq(primsk);
+}
+
+STATIC void pyb_rtc_irq_enable (mp_obj_t self_in) {
+    pyb_rtc_obj_t *self = self_in;
+    // we always need interrupts if repeat is enabled
+    if ((self->pwrmode & PYB_PWR_MODE_ACTIVE) || self->repeat) {
+        MAP_PRCMIntEnable(PRCM_INT_SLOW_CLK_CTR);
+    } else { // just in case it was already enabled before
        MAP_PRCMIntDisable(PRCM_INT_SLOW_CLK_CTR);
    }
-    // disable wake from ldps and hibernate
-    pybsleep_configure_timer_wakeup (PYB_PWR_MODE_ACTIVE);
+    self->irq_enabled = true;
+}
+
+STATIC void pyb_rtc_irq_disable (mp_obj_t self_in) {
+    pyb_rtc_obj_t *self = self_in;
+    self->irq_enabled = false;
+    if (!self->repeat) { // we always need interrupts if repeat is enabled
+        pyb_rtc_disable_interupt();
+    }
+}
+
+STATIC int pyb_rtc_irq_flags (mp_obj_t self_in) {
+    pyb_rtc_obj_t *self = self_in;
+    return self->irq_flags;
+}
+
+STATIC uint pyb_rtc_datetime_s_us(const mp_obj_t datetime, uint32_t *seconds) {
+    timeutils_struct_time_t tm;
+    uint32_t useconds;
+
+    // set date and time
+    mp_obj_t *items;
+    uint len;
+    mp_obj_get_array(datetime, &len, &items);
+
+    // verify the tuple
+    if (len < 3 || len > 8) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
+    }
+
+    tm.tm_year = mp_obj_get_int(items[0]);
+    tm.tm_mon = mp_obj_get_int(items[1]);
+    tm.tm_mday = mp_obj_get_int(items[2]);
+    if (len < 7) {
+        useconds = 0;
+    } else {
+        useconds = mp_obj_get_int(items[6]);
+    }
+    if (len < 6) {
+        tm.tm_sec = 0;
+    } else {
+        tm.tm_sec = mp_obj_get_int(items[5]);
+    }
+    if (len < 5) {
+        tm.tm_min = 0;
+    } else {
+        tm.tm_min = mp_obj_get_int(items[4]);
+    }
+    if (len < 4) {
+        tm.tm_hour = 0;
+    } else {
+        tm.tm_hour = mp_obj_get_int(items[3]);
+    }
+    *seconds = timeutils_seconds_since_2000(tm.tm_year, tm.tm_mon, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
+    return useconds;
+}
+
+/// The 8-tuple has the same format as CPython's datetime object:
+///
+///     (year, month, day, hours, minutes, seconds, milliseconds, tzinfo=None)
+///
+STATIC mp_obj_t pyb_rtc_datetime(mp_obj_t self_in, const mp_obj_t datetime) {
+    uint32_t seconds;
+    uint32_t useconds;
+
+    if (datetime != MP_OBJ_NULL) {
+        useconds = pyb_rtc_datetime_s_us(datetime, &seconds);
+        pyb_rtc_set_time (seconds, useconds / 1000);
+    } else {
+        seconds = pyb_rtc_reset();
+    }
+
+    // set WLAN time and date, this is needed to verify certificates
+    wlan_set_current_time(seconds);
+    return mp_const_none;
+}
+
+STATIC void pyb_rtc_set_alarm (pyb_rtc_obj_t *self, uint32_t seconds, uint16_t mseconds) {
+    // disable the interrupt before updating anything
+    if (self->irq_enabled) {
+        MAP_PRCMIntDisable(PRCM_INT_SLOW_CLK_CTR);
+    }
+    // set the match value
+    MAP_PRCMRTCMatchSet(seconds, RTC_U16MS_CYCLES(mseconds));
+    self->alarmset = true;
+    self->alarm_time_s = seconds;
+    self->alarm_time_ms = mseconds;
+    // enabled the interrupts again if applicable
+    if (self->irq_enabled || self->repeat) {
+        MAP_PRCMIntEnable(PRCM_INT_SLOW_CLK_CTR);
+    }
+}
+
+STATIC void rtc_msec_add (uint16_t msecs_1, uint32_t *secs, uint16_t *msecs_2) {
+    if (msecs_1 + *msecs_2 >= 1000) { // larger than one second
+        *msecs_2 = (msecs_1 + *msecs_2) - 1000;
+        *secs += 1; // carry flag
+    } else {
+        // simply add the mseconds
+        *msecs_2 = msecs_1 + *msecs_2;
+    }
 }

 /******************************************************************************/
 // Micro Python bindings

-/// \method datetime([datetimetuple])
-/// Get or set the date and time of the RTC.
-///
-/// With no arguments, this method returns an 8-tuple with the current
-/// date and time. With 1 argument (being an 8-tuple) it sets the date
-/// and time.
-///
-/// The 8-tuple has the following format:
-///
-///     (year, month, day, weekday, hours, minutes, seconds, milliseconds)
-///
-/// `weekday` is 0-6 for Monday through Sunday.
-///
-mp_obj_t pyb_rtc_datetime(mp_uint_t n_args, const mp_obj_t *args) {
-    mod_struct_time tm;
+STATIC const mp_arg_t pyb_rtc_init_args[] = {
+    { MP_QSTR_id,                             MP_ARG_INT, {.u_int = 0} },
+    { MP_QSTR_datetime,                       MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+};
+STATIC mp_obj_t pyb_rtc_make_new(const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
+    // parse args
+    mp_map_t kw_args;
+    mp_map_init_fixed_table(&kw_args, n_kw, all_args + n_args);
+    mp_arg_val_t args[MP_ARRAY_SIZE(pyb_rtc_init_args)];
+    mp_arg_parse_all(n_args, all_args, &kw_args, MP_ARRAY_SIZE(args), pyb_rtc_init_args, args);
+
+    // check the peripheral id
+    if (args[0].u_int != 0) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_resource_not_avaliable));
+    }
+
+    // setup the object
+    pyb_rtc_obj_t *self = &pyb_rtc_obj;
+    self->base.type = &pyb_rtc_type;
+
+    // set the time and date
+    pyb_rtc_datetime((mp_obj_t)&pyb_rtc_obj, args[1].u_obj);
+
+    // pass it to the sleep module
+    pyb_sleep_set_rtc_obj (self);
+
+    // return constant object
+    return (mp_obj_t)&pyb_rtc_obj;
+}
+
+STATIC mp_obj_t pyb_rtc_init (mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    // parse args
+    mp_arg_val_t args[MP_ARRAY_SIZE(pyb_rtc_init_args) - 1];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(args), &pyb_rtc_init_args[1], args);
+    return pyb_rtc_datetime(pos_args[0], args[0].u_obj);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_rtc_init_obj, 1, pyb_rtc_init);
+
+STATIC mp_obj_t pyb_rtc_now (mp_obj_t self_in) {
+    timeutils_struct_time_t tm;
    uint32_t seconds;
    uint16_t mseconds;

-    if (n_args == 1) {
-        // get the seconds and the milliseconds from the RTC
-        MAP_PRCMRTCGet(&seconds, &mseconds);
-        mseconds = RTC_CYCLES_U16MS(mseconds);
-        mod_time_seconds_since_2000_to_struct_time(seconds, &tm);
+    // get the time from the RTC
+    pyb_rtc_get_time(&seconds, &mseconds);
+    timeutils_seconds_since_2000_to_struct_time(seconds, &tm);

-        mp_obj_t tuple[8] = {
-            mp_obj_new_int(tm.tm_year),
-            mp_obj_new_int(tm.tm_mon),
-            mp_obj_new_int(tm.tm_mday),
-            mp_obj_new_int(tm.tm_wday),
-            mp_obj_new_int(tm.tm_hour),
-            mp_obj_new_int(tm.tm_min),
-            mp_obj_new_int(tm.tm_sec),
-            mp_obj_new_int(mseconds)
-        };
-        return mp_obj_new_tuple(8, tuple);
+    mp_obj_t tuple[8] = {
+        mp_obj_new_int(tm.tm_year),
+        mp_obj_new_int(tm.tm_mon),
+        mp_obj_new_int(tm.tm_mday),
+        mp_obj_new_int(tm.tm_hour),
+        mp_obj_new_int(tm.tm_min),
+        mp_obj_new_int(tm.tm_sec),
+        mp_obj_new_int(mseconds * 1000),
+        mp_const_none
+    };
+    return mp_obj_new_tuple(8, tuple);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_rtc_now_obj, pyb_rtc_now);
+
+STATIC mp_obj_t pyb_rtc_deinit (mp_obj_t self_in) {
+    pyb_rtc_reset();
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_rtc_deinit_obj, pyb_rtc_deinit);
+
+STATIC mp_obj_t pyb_rtc_alarm (mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    STATIC const mp_arg_t allowed_args[] = {
+        { MP_QSTR_id,                            MP_ARG_INT,  {.u_int = 0} },
+        { MP_QSTR_time,                          MP_ARG_OBJ,  {.u_obj = mp_const_none} },
+        { MP_QSTR_repeat,     MP_ARG_KW_ONLY   | MP_ARG_BOOL, {.u_bool = false} },
+    };
+
+    // parse args
+    pyb_rtc_obj_t *self = pos_args[0];
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(args), allowed_args, args);
+
+    // check the alarm id
+    if (args[0].u_int != 0) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_resource_not_avaliable));
+    }
+
+    uint32_t f_seconds;
+    uint16_t f_mseconds;
+    bool repeat = args[2].u_bool;
+    if (MP_OBJ_IS_TYPE(args[1].u_obj, &mp_type_tuple)) { // datetime tuple given
+        // repeat cannot be used with a datetime tuple
+        if (repeat) {
+            nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
+        }
+        f_mseconds = pyb_rtc_datetime_s_us (args[1].u_obj, &f_seconds) / 1000;
+    } else { // then it must be an integer
+        self->alarm_ms = mp_obj_get_int(args[1].u_obj);
+        pyb_rtc_calc_future_time (self->alarm_ms, &f_seconds, &f_mseconds);
+    }
+
+    // store the repepat flag
+    self->repeat = repeat;
+
+    // now configure the alarm
+    pyb_rtc_set_alarm (self, f_seconds, f_mseconds);
+
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_rtc_alarm_obj, 1, pyb_rtc_alarm);
+
+STATIC mp_obj_t pyb_rtc_alarm_left (mp_uint_t n_args, const mp_obj_t *args) {
+    pyb_rtc_obj_t *self = args[0];
+    int32_t ms_left;
+    uint32_t c_seconds;
+    uint16_t c_mseconds;
+
+    // only alarm id 0 is available
+    if (n_args > 1 && mp_obj_get_int(args[1]) != 0) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_resource_not_avaliable));
+    }
+
+    // get the current time
+    pyb_rtc_get_time(&c_seconds, &c_mseconds);
+
+    // calculate the ms left
+    ms_left = ((self->alarm_time_s * 1000) + self->alarm_time_ms) - ((c_seconds * 1000) + c_mseconds);
+    if (!self->alarmset || ms_left < 0) {
+        ms_left = 0;
+    }
+    return mp_obj_new_int(ms_left);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_rtc_alarm_left_obj, 1, 2, pyb_rtc_alarm_left);
+
+STATIC mp_obj_t pyb_rtc_alarm_cancel (mp_uint_t n_args, const mp_obj_t *args) {
+    // only alarm id 0 is available
+    if (n_args > 1 && mp_obj_get_int(args[1]) != 0) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_resource_not_avaliable));
+    }
+    // disable the alarm
+    pyb_rtc_disable_alarm();
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_rtc_alarm_cancel_obj, 1, 2, pyb_rtc_alarm_cancel);
+
+/// \method irq(trigger, priority, handler, wake)
+STATIC mp_obj_t pyb_rtc_irq (mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    mp_arg_val_t args[mp_irq_INIT_NUM_ARGS];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, mp_irq_INIT_NUM_ARGS, mp_irq_init_args, args);
+    pyb_rtc_obj_t *self = pos_args[0];
+
+    // save the power mode data for later
+    uint8_t pwrmode = (args[3].u_obj == mp_const_none) ? PYB_PWR_MODE_ACTIVE : mp_obj_get_int(args[3].u_obj);
+    if (pwrmode > (PYB_PWR_MODE_ACTIVE | PYB_PWR_MODE_LPDS | PYB_PWR_MODE_HIBERNATE)) {
+        goto invalid_args;
+    }
+
+    // check the trigger
+    if (mp_obj_get_int(args[0].u_obj) == PYB_RTC_ALARM0) {
+        self->pwrmode = pwrmode;
+        pyb_rtc_irq_enable((mp_obj_t)self);
    } else {
-        // set date and time
-        mp_obj_t *items;
-        mp_obj_get_array_fixed_n(args[1], 8, &items);
-
-        tm.tm_year = mp_obj_get_int(items[0]);
-        tm.tm_mon = mp_obj_get_int(items[1]);
-        tm.tm_mday = mp_obj_get_int(items[2]);
-        // Skip the weekday
-        tm.tm_hour = mp_obj_get_int(items[4]);
-        tm.tm_min = mp_obj_get_int(items[5]);
-        tm.tm_sec = mp_obj_get_int(items[6]);
-        mseconds = mp_obj_get_int(items[7]);
-
-        seconds = mod_time_seconds_since_2000(tm.tm_year, tm.tm_mon, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
-        mseconds = RTC_U16MS_CYCLES(mseconds);
-        MAP_PRCMRTCSet(seconds, mseconds);
-
-        return mp_const_none;
+        goto invalid_args;
    }
+
+    // the interrupt priority is ignored since it's already set to to highest level by the sleep module
+    // to make sure that the wakeup irqs are always called first when resuming from sleep
+
+    // create the callback
+    mp_obj_t _irq = mp_irq_new ((mp_obj_t)self, args[2].u_obj, &pyb_rtc_irq_methods);
+    self->irq_obj = _irq;
+
+    return _irq;
+
+invalid_args:
+    nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_rtc_datetime_obj, 1, 2, pyb_rtc_datetime);
-
-/// \method callback(handler, value, pwrmode)
-/// Creates a callback object associated with the real time clock
-/// min num of arguments is 1 (value). The value is the alarm time
-/// in the future, in msec
-STATIC mp_obj_t pyb_rtc_callback (mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    mp_arg_val_t args[mpcallback_INIT_NUM_ARGS];
-    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, mpcallback_INIT_NUM_ARGS, mpcallback_init_args, args);
-
-    // check if any parameters were passed
-    mp_obj_t _callback = mpcallback_find((mp_obj_t)&pyb_rtc_obj);
-    if (kw_args->used > 0 || !_callback) {
-        uint32_t f_mseconds = args[3].u_int;
-        uint32_t seconds;
-        uint16_t mseconds;
-        // get the seconds and the milliseconds from the RTC
-        MAP_PRCMRTCGet(&seconds, &mseconds);
-        mseconds = RTC_CYCLES_U16MS(mseconds);
-
-        // configure the rtc alarm accordingly
-        seconds += f_mseconds / 1000;
-        mseconds += f_mseconds - ((f_mseconds / 1000) * 1000);
-
-        // disable the interrupt before updating anything
-        // (the object is not relevant here, the function already knows it)
-        pyb_rtc_callback_disable(NULL);
-
-        // set the match value
-        MAP_PRCMRTCMatchSet(seconds, mseconds);
-
-        // save the match data for later
-        pybrtc_data.prwmode = args[4].u_int;
-
-        // create the callback
-        _callback = mpcallback_new ((mp_obj_t)&pyb_rtc_obj, args[1].u_obj, &pybrtc_cb_methods);
-
-        // set the lpds callback
-        pybsleep_set_timer_lpds_callback(_callback);
-
-        // the interrupt priority is ignored since is already set to to highest level by the sleep module
-        // to make sure that the wakeup callbacks are always called first when resuming from sleep
-
-        // enable the interrupt (the object is not relevant here, the function already knows it)
-        pyb_rtc_callback_enable(NULL);
-    }
-    return _callback;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_rtc_callback_obj, 1, pyb_rtc_callback);
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_rtc_irq_obj, 1, pyb_rtc_irq);

 STATIC const mp_map_elem_t pyb_rtc_locals_dict_table[] = {
-    { MP_OBJ_NEW_QSTR(MP_QSTR_datetime), (mp_obj_t)&pyb_rtc_datetime_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_callback), (mp_obj_t)&pyb_rtc_callback_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_init),            (mp_obj_t)&pyb_rtc_init_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_deinit),          (mp_obj_t)&pyb_rtc_deinit_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_now),             (mp_obj_t)&pyb_rtc_now_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_alarm),           (mp_obj_t)&pyb_rtc_alarm_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_alarm_left),      (mp_obj_t)&pyb_rtc_alarm_left_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_alarm_cancel),    (mp_obj_t)&pyb_rtc_alarm_cancel_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_irq),             (mp_obj_t)&pyb_rtc_irq_obj },
+
+    // class constants
+    { MP_OBJ_NEW_QSTR(MP_QSTR_ALARM0),          MP_OBJ_NEW_SMALL_INT(PYB_RTC_ALARM0) },
 };
 STATIC MP_DEFINE_CONST_DICT(pyb_rtc_locals_dict, pyb_rtc_locals_dict_table);

-STATIC const mp_obj_type_t pyb_rtc_type = {
+const mp_obj_type_t pyb_rtc_type = {
    { &mp_type_type },
    .name = MP_QSTR_RTC,
+    .make_new = pyb_rtc_make_new,
    .locals_dict = (mp_obj_t)&pyb_rtc_locals_dict,
 };

-STATIC const mp_cb_methods_t pybrtc_cb_methods = {
-    .init = pyb_rtc_callback,
-    .enable = pyb_rtc_callback_enable,
-    .disable = pyb_rtc_callback_disable,
+STATIC const mp_irq_methods_t pyb_rtc_irq_methods = {
+    .init = pyb_rtc_irq,
+    .enable = pyb_rtc_irq_enable,
+    .disable = pyb_rtc_irq_disable,
+    .flags = pyb_rtc_irq_flags
 };
-
-const mp_obj_base_t pyb_rtc_obj = {&pyb_rtc_type};
--- a/cc3200/mods/pybrtc.h
+++ b/cc3200/mods/pybrtc.h
@@ -28,11 +28,32 @@
 #ifndef PYBRTC_H_
 #define PYBRTC_H_

-#define RTC_U16MS_CYCLES(msec)      ((msec * 1024) / 1000)
-#define RTC_CYCLES_U16MS(cycles)    ((cycles * 1000) / 1024)
+// RTC triggers
+#define PYB_RTC_ALARM0                      (0x01)

-extern const mp_obj_base_t pyb_rtc_obj;
+#define RTC_ACCESS_TIME_MSEC                (5)
+#define PYB_RTC_MIN_ALARM_TIME_MS           (RTC_ACCESS_TIME_MSEC * 2)

-void pybrtc_init(void);
+typedef struct _pyb_rtc_obj_t {
+    mp_obj_base_t base;
+    mp_obj_t irq_obj;
+    uint32_t irq_flags;
+    uint32_t alarm_ms;
+    uint32_t alarm_time_s;
+    uint16_t alarm_time_ms;
+    byte pwrmode;
+    bool alarmset;
+    bool repeat;
+    bool irq_enabled;
+} pyb_rtc_obj_t;
+
+extern const mp_obj_type_t pyb_rtc_type;
+
+extern void pyb_rtc_pre_init(void);
+extern void pyb_rtc_get_time (uint32_t *secs, uint16_t *msecs);
+extern uint32_t pyb_rtc_get_seconds (void);
+extern void pyb_rtc_calc_future_time (uint32_t a_mseconds, uint32_t *f_seconds, uint16_t *f_mseconds);
+extern void pyb_rtc_repeat_alarm (pyb_rtc_obj_t *self);
+extern void pyb_rtc_disable_alarm (void);

 #endif  // PYBRTC_H_
--- a/cc3200/mods/pybsd.c
+++ b/cc3200/mods/pybsd.c
@@ -25,7 +25,6 @@
 */

 #include "py/mpconfig.h"
-#include MICROPY_HAL_H
 #include "py/obj.h"
 #include "py/runtime.h"
 #include "inc/hw_types.h"
@@ -37,61 +36,46 @@
 #include "prcm.h"
 #include "gpio.h"
 #include "sdhost.h"
-#include "pybpin.h"
-#include "pybsd.h"
 #include "ff.h"
 #include "diskio.h"
 #include "sd_diskio.h"
-#include "simplelink.h"
-#include "debug.h"
+#include "pybsd.h"
 #include "mpexception.h"
 #include "pybsleep.h"
+#include "pybpin.h"
+#include "pins.h"

-
-#if MICROPY_HW_HAS_SDCARD
-
+/******************************************************************************
+ DEFINE PRIVATE CONSTANTS
+ ******************************************************************************/
 #define PYBSD_FREQUENCY_HZ              15000000    // 15MHz

-typedef struct {
-    mp_obj_base_t base;
-    FATFS        *fatfs;
-    pin_obj_t    *pin_clk;
-    bool         pinsset;
-    bool         enabled;
-} pybsd_obj_t;
+/******************************************************************************
+ DECLARE PUBLIC DATA
+ ******************************************************************************/
+pybsd_obj_t pybsd_obj;

 /******************************************************************************
 DECLARE PRIVATE DATA
 ******************************************************************************/
-STATIC pybsd_obj_t pybsd_obj;
+STATIC const mp_obj_t pyb_sd_def_pin[3] = {&pin_GP10, &pin_GP11, &pin_GP15};

 /******************************************************************************
 DECLARE PRIVATE FUNCTIONS
 ******************************************************************************/
-STATIC mp_obj_t pybsd_make_new (mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args);
-STATIC mp_obj_t pybsd_disable (mp_obj_t self_in);
-STATIC mp_obj_t pybsd_enable (mp_obj_t self_in);
-
-/******************************************************************************
- DEFINE PUBLIC FUNCTIONS
- ******************************************************************************/
-__attribute__ ((section (".boot")))
-void pybsd_init0 (void) {
-    // allocate memory for the sd file system
-    ASSERT ((pybsd_obj.fatfs = mem_Malloc(sizeof(FATFS))) != NULL);
-}
-
-void pybsd_deinit (void) {
-    pybsd_disable ((mp_obj_t)&pybsd_obj);
-}
+STATIC void pyb_sd_hw_init (pybsd_obj_t *self);
+STATIC mp_obj_t pyb_sd_make_new (const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args);
+STATIC mp_obj_t pyb_sd_deinit (mp_obj_t self_in);

 /******************************************************************************
 DEFINE PRIVATE FUNCTIONS
 ******************************************************************************/
-/// Initalizes the sd card driver
-STATIC void pybsd_init (pybsd_obj_t *self) {
-    // Configure the clock pin as output only
-    MAP_PinDirModeSet(self->pin_clk->pin_num, PIN_DIR_MODE_OUT);
+/// Initalizes the sd card hardware driver
+STATIC void pyb_sd_hw_init (pybsd_obj_t *self) {
+    if (self->pin_clk) {
+        // Configure the clock pin as output only
+        MAP_PinDirModeSet(((pin_obj_t *)(self->pin_clk))->pin_num, PIN_DIR_MODE_OUT);
+    }
    // Enable SD peripheral clock
    MAP_PRCMPeripheralClkEnable(PRCM_SDHOST, PRCM_RUN_MODE_CLK | PRCM_SLP_MODE_CLK);
    // Reset MMCHS
@@ -100,110 +84,95 @@ STATIC void pybsd_init (pybsd_obj_t *self) {
    MAP_SDHostInit(SDHOST_BASE);
    // Configure the card clock
    MAP_SDHostSetExpClk(SDHOST_BASE, MAP_PRCMPeripheralClockGet(PRCM_SDHOST), PYBSD_FREQUENCY_HZ);
+    // Set card rd/wr block len
+    MAP_SDHostBlockSizeSet(SDHOST_BASE, SD_SECTOR_SIZE);
+    self->enabled = true;
+}
+
+STATIC mp_obj_t pyb_sd_init_helper (pybsd_obj_t *self, const mp_arg_val_t *args) {
+    // assign the pins
+    mp_obj_t pins_o = args[0].u_obj;
+    if (pins_o != mp_const_none) {
+        mp_obj_t *pins;
+        if (pins_o == MP_OBJ_NULL) {
+            // use the default pins
+            pins = (mp_obj_t *)pyb_sd_def_pin;
+        } else {
+            mp_obj_get_array_fixed_n(pins_o, MP_ARRAY_SIZE(pyb_sd_def_pin), &pins);
+        }
+        pin_assign_pins_af (pins, MP_ARRAY_SIZE(pyb_sd_def_pin), PIN_TYPE_STD_PU, PIN_FN_SD, 0);
+        // save the pins clock
+        self->pin_clk = pin_find(pins[0]);
+    }
+
+    pyb_sd_hw_init (self);
+    if (sd_disk_init() != 0) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_operation_failed));
+    }
+
+    // register it with the sleep module
+    pyb_sleep_add ((const mp_obj_t)self, (WakeUpCB_t)pyb_sd_hw_init);
+    return mp_const_none;
 }

 /******************************************************************************/
 // Micro Python bindings
 //

-/// \classmethod \constructor()
-/// Configure the pins used for the sd card.
-///   May receive 0, or 6 arguments.
-///
-/// Usage:
-///    sd = pyb.SD()
-////
-///    sd = pyb.SD(d0_pin, d0_af, clk_pin, clk_af, cmd_pin, cmd_af)
-///
-STATIC mp_obj_t pybsd_make_new (mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
-    mp_arg_check_num(n_args, n_kw, 0, 6, false);
-
-    if (n_args == 6) {
-        // save the clock pin for later use
-        pybsd_obj.pin_clk = (pin_obj_t *)pin_find(args[2]);
-
-        // configure the data pin with pull-up enabled
-        pin_config ((pin_obj_t *)pin_find(args[0]), mp_obj_get_int(args[1]), 0, PIN_TYPE_STD_PU, PIN_STRENGTH_4MA);
-        // configure the clock pin
-        pin_config (pybsd_obj.pin_clk, mp_obj_get_int(args[3]), 0, PIN_TYPE_STD, PIN_STRENGTH_4MA);
-        // configure the command pin with pull-up enabled
-        pin_config ((pin_obj_t *)pin_find(args[4]), mp_obj_get_int(args[5]), 0, PIN_TYPE_STD_PU, PIN_STRENGTH_4MA);
-
-        pybsd_obj.pinsset = true;
-        pybsd_obj.base.type = &pyb_sd_type;
-    }
-    else if (!pybsd_obj.pinsset) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, mpexception_num_type_invalid_arguments));
-    }
-
-    return &pybsd_obj;
-}
-
-/// \method enable()
-/// Enables the sd card and mounts the file system
-STATIC mp_obj_t pybsd_enable (mp_obj_t self_in) {
-    pybsd_obj_t *self = self_in;
-
-    if (!self->enabled) {
-        // do the init first
-        pybsd_init (self);
-
-        // try to mount the sd card on /sd
-        if (FR_OK != f_mount(self->fatfs, "/sd", 1)) {
-            nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_operation_failed));
-        }
-
-        mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR__slash_sd));
-        mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR__slash_sd_slash_lib));
-
-        // register it with the sleep module
-        pybsleep_add ((const mp_obj_t)&pybsd_obj, (WakeUpCB_t)pybsd_init);
-        self->enabled = true;
-    }
-
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(pybsd_enable_obj, pybsd_enable);
-
-/// \method disable()
-/// Disables the sd card and unmounts the file system
-STATIC mp_obj_t pybsd_disable (mp_obj_t self_in) {
-    pybsd_obj_t *self = self_in;
-    if (self->enabled) {
-        self->enabled = false;
-        // unmount the sd card
-        f_mount (NULL, "/sd", 1);
-        // remove sd paths from mp_sys_path
-        mp_obj_list_remove(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR__slash_sd));
-        mp_obj_list_remove(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR__slash_sd_slash_lib));
-
-        // disable the peripheral
-        MAP_PRCMPeripheralClkDisable(PRCM_SDHOST, PRCM_RUN_MODE_CLK | PRCM_SLP_MODE_CLK);
-
-        // de-initialze de sd card at diskio level
-        sd_disk_deinit();
-
-        // unregister it with the sleep module
-        pybsleep_remove (self);
-
-        // change the drive in case it was /sd
-        f_chdrive("/flash");
-    }
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(pybsd_disable_obj, pybsd_disable);
-
-STATIC const mp_map_elem_t pybsd_locals_dict_table[] = {
-    { MP_OBJ_NEW_QSTR(MP_QSTR_enable),          (mp_obj_t)&pybsd_enable_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_disable),         (mp_obj_t)&pybsd_disable_obj },
+STATIC const mp_arg_t pyb_sd_init_args[] = {
+    { MP_QSTR_id,                          MP_ARG_INT, {.u_int = 0} },
+    { MP_QSTR_pins,                        MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
 };
-STATIC MP_DEFINE_CONST_DICT(pybsd_locals_dict, pybsd_locals_dict_table);
+STATIC mp_obj_t pyb_sd_make_new (const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
+    // parse args
+    mp_map_t kw_args;
+    mp_map_init_fixed_table(&kw_args, n_kw, all_args + n_args);
+    mp_arg_val_t args[MP_ARRAY_SIZE(pyb_sd_init_args)];
+    mp_arg_parse_all(n_args, all_args, &kw_args, MP_ARRAY_SIZE(args), pyb_sd_init_args, args);
+
+    // check the peripheral id
+    if (args[0].u_int != 0) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_resource_not_avaliable));
+    }
+
+    // setup and initialize the object
+    mp_obj_t self = &pybsd_obj;
+    pybsd_obj.base.type = &pyb_sd_type;
+    pyb_sd_init_helper (self, &args[1]);
+    return self;
+}
+
+STATIC mp_obj_t pyb_sd_init (mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    // parse args
+    mp_arg_val_t args[MP_ARRAY_SIZE(pyb_sd_init_args) - 1];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(args), &pyb_sd_init_args[1], args);
+    return pyb_sd_init_helper(pos_args[0], args);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_sd_init_obj, 1, pyb_sd_init);
+
+STATIC mp_obj_t pyb_sd_deinit (mp_obj_t self_in) {
+    pybsd_obj_t *self = self_in;
+    // disable the peripheral
+    self->enabled = false;
+    MAP_PRCMPeripheralClkDisable(PRCM_SDHOST, PRCM_RUN_MODE_CLK | PRCM_SLP_MODE_CLK);
+    // de-initialze the sd card at diskio level
+    sd_disk_deinit();
+    // unregister it from the sleep module
+    pyb_sleep_remove (self);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_sd_deinit_obj, pyb_sd_deinit);
+
+STATIC const mp_map_elem_t pyb_sd_locals_dict_table[] = {
+    { MP_OBJ_NEW_QSTR(MP_QSTR_init),            (mp_obj_t)&pyb_sd_init_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_deinit),          (mp_obj_t)&pyb_sd_deinit_obj },
+};
+
+STATIC MP_DEFINE_CONST_DICT(pyb_sd_locals_dict, pyb_sd_locals_dict_table);

 const mp_obj_type_t pyb_sd_type = {
    { &mp_type_type },
    .name = MP_QSTR_SD,
-    .make_new = pybsd_make_new,
-    .locals_dict = (mp_obj_t)&pybsd_locals_dict,
+    .make_new = pyb_sd_make_new,
+    .locals_dict = (mp_obj_t)&pyb_sd_locals_dict,
 };
-
-#endif // MICROPY_HW_HAS_SDCARD
--- a/cc3200/mods/pybsd.h
+++ b/cc3200/mods/pybsd.h
@@ -26,11 +26,19 @@
 #ifndef PYBSD_H_
 #define PYBSD_H_

-#if MICROPY_HW_HAS_SDCARD
+/******************************************************************************
+ DEFINE PUBLIC TYPES
+ ******************************************************************************/
+typedef struct {
+    mp_obj_base_t base;
+    mp_obj_t      pin_clk;
+    bool          enabled;
+} pybsd_obj_t;
+
+/******************************************************************************
+ DECLARE EXPORTED DATA
+ ******************************************************************************/
+extern pybsd_obj_t pybsd_obj;
 extern const mp_obj_type_t pyb_sd_type;

-void pybsd_init0 (void);
-void pybsd_deinit (void);
-#endif
-
 #endif // PYBSD_H_
--- a/cc3200/mods/pybsleep.c
+++ b/cc3200/mods/pybsleep.c
@@ -28,8 +28,8 @@
 #include <string.h>

 #include "py/mpstate.h"
-#include MICROPY_HAL_H
 #include "py/runtime.h"
+#include "py/mphal.h"
 #include "inc/hw_types.h"
 #include "inc/hw_ints.h"
 #include "inc/hw_nvic.h"
@@ -43,15 +43,20 @@
 #include "spi.h"
 #include "pin.h"
 #include "pybsleep.h"
+#include "mpirq.h"
 #include "pybpin.h"
 #include "simplelink.h"
+#include "modnetwork.h"
 #include "modwlan.h"
 #include "osi.h"
 #include "debug.h"
 #include "mpexception.h"
-#include "mpcallback.h"
 #include "mperror.h"
 #include "sleeprestore.h"
+#include "serverstask.h"
+#include "antenna.h"
+#include "cryptohash.h"
+#include "pybrtc.h"

 /******************************************************************************
 DECLARE PRIVATE CONSTANTS
@@ -66,7 +71,7 @@
 #define WAKEUP_TIME_LPDS                        (LPDS_UP_TIME + LPDS_DOWN_TIME + USER_OFFSET)   // 20 msec
 #define WAKEUP_TIME_HIB                         (32768)       // 1 s

-#define FORCED_TIMER_INTERRUPT_MS               (1)
+#define FORCED_TIMER_INTERRUPT_MS               (PYB_RTC_MIN_ALARM_TIME_MS)
 #define FAILED_SLEEP_DELAY_MS                   (FORCED_TIMER_INTERRUPT_MS * 3)

 /******************************************************************************
@@ -106,34 +111,37 @@ typedef struct {
    mp_obj_base_t base;
    mp_obj_t      obj;
    WakeUpCB_t    wakeup;
-} pybsleep_obj_t;
+} pyb_sleep_obj_t;

 typedef struct {
-    mp_obj_t    wlan_lpds_wake_cb;
-    mp_obj_t    timer_lpds_wake_cb;
-    mp_obj_t    gpio_lpds_wake_cb;
-    uint        timer_wake_pwrmode;
+    mp_obj_t        gpio_lpds_wake_cb;
+    wlan_obj_t      *wlan_obj;
+    pyb_rtc_obj_t   *rtc_obj;
 } pybsleep_data_t;

 /******************************************************************************
 DECLARE PRIVATE DATA
 ******************************************************************************/
-STATIC const mp_obj_type_t pybsleep_type;
 STATIC nvic_reg_store_t    *nvic_reg_store;
-STATIC pybsleep_data_t   pybsleep_data = {NULL, NULL, NULL, 0};
+STATIC pybsleep_data_t   pybsleep_data = {NULL, NULL, NULL};
 volatile arm_cm4_core_regs_t vault_arm_registers;
 STATIC pybsleep_reset_cause_t pybsleep_reset_cause = PYB_SLP_PWRON_RESET;
+STATIC pybsleep_wake_reason_t pybsleep_wake_reason = PYB_SLP_WAKED_PWRON;
+STATIC const mp_obj_type_t pyb_sleep_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_sleep,
+};

 /******************************************************************************
 DECLARE PRIVATE FUNCTIONS
 ******************************************************************************/
-STATIC pybsleep_obj_t *pybsleep_find (mp_obj_t obj);
-STATIC void pybsleep_flash_powerdown (void);
-STATIC NORETURN void pybsleep_suspend_enter (void);
-void pybsleep_suspend_exit (void);
-STATIC void pybsleep_obj_wakeup (void);
+STATIC pyb_sleep_obj_t *pyb_sleep_find (mp_obj_t obj);
+STATIC void pyb_sleep_flash_powerdown (void);
+STATIC NORETURN void pyb_sleep_suspend_enter (void);
+void pyb_sleep_suspend_exit (void);
+STATIC void pyb_sleep_obj_wakeup (void);
 STATIC void PRCMInterruptHandler (void);
-STATIC void pybsleep_iopark (void);
+STATIC void pyb_sleep_iopark (bool hibernate);
 STATIC bool setup_timer_lpds_wake (void);
 STATIC bool setup_timer_hibernate_wake (void);

@@ -141,14 +149,14 @@ STATIC bool setup_timer_hibernate_wake (void);
 DEFINE PUBLIC FUNCTIONS
 ******************************************************************************/
 __attribute__ ((section (".boot")))
-void pybsleep_pre_init (void) {
+void pyb_sleep_pre_init (void) {
    // allocate memory for nvic registers vault
    ASSERT ((nvic_reg_store = mem_Malloc(sizeof(nvic_reg_store_t))) != NULL);
 }

-void pybsleep_init0 (void) {
+void pyb_sleep_init0 (void) {
    // initialize the sleep objects list
-    mp_obj_list_init(&MP_STATE_PORT(pybsleep_obj_list), 0);
+    mp_obj_list_init(&MP_STATE_PORT(pyb_sleep_obj_list), 0);

    // register and enable the PRCM interrupt
    osi_InterruptRegister(INT_PRCM, (P_OSI_INTR_ENTRY)PRCMInterruptHandler, INT_PRIORITY_LVL_1);
@@ -159,7 +167,7 @@ void pybsleep_init0 (void) {
    MAP_PRCMHibernateWakeupSourceDisable(PRCM_HIB_SLOW_CLK_CTR | PRCM_HIB_GPIO2  | PRCM_HIB_GPIO4  | PRCM_HIB_GPIO13 |
                                         PRCM_HIB_GPIO17       | PRCM_HIB_GPIO11 | PRCM_HIB_GPIO24 | PRCM_HIB_GPIO26);

-    // store the reset casue (if it's soft reset, leave it as it is)
+    // check the reset casue (if it's soft reset, leave it as it is)
    if (pybsleep_reset_cause != PYB_SLP_SOFT_RESET) {
        switch (MAP_PRCMSysResetCauseGet()) {
        case PRCM_POWER_ON:
@@ -174,11 +182,23 @@ void pybsleep_init0 (void) {
            pybsleep_reset_cause = PYB_SLP_WDT_RESET;
            break;
        case PRCM_HIB_EXIT:
-            if (PRCMWasResetBecauseOfWDT()) {
+            if (PRCMGetSpecialBit(PRCM_WDT_RESET_BIT)) {
                pybsleep_reset_cause = PYB_SLP_WDT_RESET;
            }
            else {
                pybsleep_reset_cause = PYB_SLP_HIB_RESET;
+                // set the correct wake reason
+                switch (MAP_PRCMHibernateWakeupCauseGet()) {
+                case PRCM_HIB_WAKEUP_CAUSE_SLOW_CLOCK:
+                    pybsleep_wake_reason = PYB_SLP_WAKED_BY_RTC;
+                    // TODO repeat the alarm
+                    break;
+                case PRCM_HIB_WAKEUP_CAUSE_GPIO:
+                    pybsleep_wake_reason = PYB_SLP_WAKED_BY_GPIO;
+                    break;
+                default:
+                    break;
+                }
            }
            break;
        default:
@@ -187,55 +207,109 @@ void pybsleep_init0 (void) {
    }
 }

-void pybsleep_signal_soft_reset (void) {
+void pyb_sleep_signal_soft_reset (void) {
    pybsleep_reset_cause = PYB_SLP_SOFT_RESET;
 }

-void pybsleep_add (const mp_obj_t obj, WakeUpCB_t wakeup) {
-    pybsleep_obj_t * sleep_obj = m_new_obj(pybsleep_obj_t);
-    sleep_obj->base.type = &pybsleep_type;
+void pyb_sleep_add (const mp_obj_t obj, WakeUpCB_t wakeup) {
+    pyb_sleep_obj_t *sleep_obj = m_new_obj(pyb_sleep_obj_t);
+    sleep_obj->base.type = &pyb_sleep_type;
    sleep_obj->obj = obj;
    sleep_obj->wakeup = wakeup;
-    // only add objects once
-    if (!pybsleep_find(sleep_obj)) {
-        mp_obj_list_append(&MP_STATE_PORT(pybsleep_obj_list), sleep_obj);
+    // remove it in case it was already registered
+    pyb_sleep_remove (obj);
+    mp_obj_list_append(&MP_STATE_PORT(pyb_sleep_obj_list), sleep_obj);
+}
+
+void pyb_sleep_remove (const mp_obj_t obj) {
+    pyb_sleep_obj_t *sleep_obj;
+    if ((sleep_obj = pyb_sleep_find(obj))) {
+        mp_obj_list_remove(&MP_STATE_PORT(pyb_sleep_obj_list), sleep_obj);
    }
 }

-void pybsleep_remove (const mp_obj_t obj) {
-    pybsleep_obj_t *sleep_obj;
-    if ((sleep_obj = pybsleep_find(obj))) {
-        mp_obj_list_remove(&MP_STATE_PORT(pybsleep_obj_list), sleep_obj);
-    }
-}
-
-void pybsleep_set_wlan_lpds_callback (mp_obj_t cb_obj) {
-    pybsleep_data.wlan_lpds_wake_cb = cb_obj;
-}
-
-void pybsleep_set_gpio_lpds_callback (mp_obj_t cb_obj) {
+void pyb_sleep_set_gpio_lpds_callback (mp_obj_t cb_obj) {
    pybsleep_data.gpio_lpds_wake_cb = cb_obj;
 }

-void pybsleep_set_timer_lpds_callback (mp_obj_t cb_obj) {
-    pybsleep_data.timer_lpds_wake_cb = cb_obj;
+void pyb_sleep_set_wlan_obj (mp_obj_t wlan_obj) {
+    pybsleep_data.wlan_obj = (wlan_obj_t *)wlan_obj;
 }

-void pybsleep_configure_timer_wakeup (uint pwrmode) {
-    pybsleep_data.timer_wake_pwrmode = pwrmode;
+void pyb_sleep_set_rtc_obj (mp_obj_t rtc_obj) {
+    pybsleep_data.rtc_obj = (pyb_rtc_obj_t *)rtc_obj;
 }

-pybsleep_reset_cause_t pybsleep_get_reset_cause (void) {
+void pyb_sleep_sleep (void) {
+    nlr_buf_t nlr;
+
+    // check if we should enable timer wake-up
+    if (pybsleep_data.rtc_obj->irq_enabled && (pybsleep_data.rtc_obj->pwrmode & PYB_PWR_MODE_LPDS)) {
+        if (!setup_timer_lpds_wake()) {
+            // lpds entering is not possible, wait for the forced interrupt and return
+            mp_hal_delay_ms(FAILED_SLEEP_DELAY_MS);
+            return;
+        }
+    } else {
+        // disable the timer as wake source
+        MAP_PRCMLPDSWakeupSourceDisable(PRCM_LPDS_TIMER);
+    }
+
+    // do we need network wake-up?
+    if (pybsleep_data.wlan_obj->irq_enabled) {
+        MAP_PRCMLPDSWakeupSourceEnable (PRCM_LPDS_HOST_IRQ);
+        server_sleep_sockets();
+    } else {
+        MAP_PRCMLPDSWakeupSourceDisable (PRCM_LPDS_HOST_IRQ);
+    }
+
+    // entering and exiting suspended mode must be an atomic operation
+    // therefore interrupts need to be disabled
+    uint primsk = disable_irq();
+    if (nlr_push(&nlr) == 0) {
+        pyb_sleep_suspend_enter();
+        nlr_pop();
+    }
+
+    // an exception is always raised when exiting suspend mode
+    enable_irq(primsk);
+}
+
+void pyb_sleep_deepsleep (void) {
+    // check if we should enable timer wake-up
+    if (pybsleep_data.rtc_obj->irq_enabled && (pybsleep_data.rtc_obj->pwrmode & PYB_PWR_MODE_HIBERNATE)) {
+        if (!setup_timer_hibernate_wake()) {
+            // hibernating is not possible, wait for the forced interrupt and return
+            mp_hal_delay_ms(FAILED_SLEEP_DELAY_MS);
+            return;
+        }
+    } else {
+        // disable the timer as hibernate wake source
+        MAP_PRCMLPDSWakeupSourceDisable(PRCM_HIB_SLOW_CLK_CTR);
+    }
+
+    wlan_stop(SL_STOP_TIMEOUT);
+    pyb_sleep_flash_powerdown();
+    // must be done just before entering hibernate mode
+    pyb_sleep_iopark(true);
+    MAP_PRCMHibernateEnter();
+}
+
+pybsleep_reset_cause_t pyb_sleep_get_reset_cause (void) {
    return pybsleep_reset_cause;
 }

+pybsleep_wake_reason_t pyb_sleep_get_wake_reason (void) {
+    return pybsleep_wake_reason;
+}
+
 /******************************************************************************
 DEFINE PRIVATE FUNCTIONS
 ******************************************************************************/
-STATIC pybsleep_obj_t *pybsleep_find (mp_obj_t obj) {
-    for (mp_uint_t i = 0; i < MP_STATE_PORT(pybsleep_obj_list).len; i++) {
+STATIC pyb_sleep_obj_t *pyb_sleep_find (mp_obj_t obj) {
+    for (mp_uint_t i = 0; i < MP_STATE_PORT(pyb_sleep_obj_list).len; i++) {
        // search for the object and then remove it
-        pybsleep_obj_t *sleep_obj = ((pybsleep_obj_t *)(MP_STATE_PORT(pybsleep_obj_list).items[i]));
+        pyb_sleep_obj_t *sleep_obj = ((pyb_sleep_obj_t *)(MP_STATE_PORT(pyb_sleep_obj_list).items[i]));
        if (sleep_obj->obj == obj) {
            return sleep_obj;
        }
@@ -243,7 +317,7 @@ STATIC pybsleep_obj_t *pybsleep_find (mp_obj_t obj) {
    return NULL;
 }

-STATIC void pybsleep_flash_powerdown (void) {
+STATIC void pyb_sleep_flash_powerdown (void) {
    uint32_t status;

    // Enable clock for SSPI module
@@ -288,7 +362,7 @@ STATIC void pybsleep_flash_powerdown (void) {
    MAP_SPICSDisable(SSPI_BASE);
 }

-STATIC NORETURN void pybsleep_suspend_enter (void) {
+STATIC NORETURN void pyb_sleep_suspend_enter (void) {
    // enable full RAM retention
    MAP_PRCMSRAMRetentionEnable(PRCM_SRAM_COL_1 | PRCM_SRAM_COL_2 | PRCM_SRAM_COL_3 | PRCM_SRAM_COL_4, PRCM_SRAM_LPDS_RET);

@@ -325,7 +399,7 @@ STATIC NORETURN void pybsleep_suspend_enter (void) {
    mperror_heartbeat_switch_off();

    // park the gpio pins
-    pybsleep_iopark();
+    pyb_sleep_iopark(false);

    // store the cpu registers
    sleep_store();
@@ -338,7 +412,7 @@ STATIC NORETURN void pybsleep_suspend_enter (void) {
    for ( ; ; );
 }

-void pybsleep_suspend_exit (void) {
+void pyb_sleep_suspend_exit (void) {
    // take the I2C semaphore
    uint32_t reg = HWREG(COMMON_REG_BASE + COMMON_REG_O_I2C_Properties_Register);
    reg = (reg & ~0x3) | 0x1;
@@ -383,14 +457,22 @@ void pybsleep_suspend_exit (void) {
    // ungate the clock to the shared spi bus
    MAP_PRCMPeripheralClkEnable(PRCM_SSPI, PRCM_RUN_MODE_CLK | PRCM_SLP_MODE_CLK);

+#if MICROPY_HW_ANTENNA_DIVERSITY
+    // re-configure the antenna selection pins
+    antenna_init0();
+#endif
+
    // reinitialize simplelink's interface
    sl_IfOpen (NULL, 0);

    // restore the configuration of all active peripherals
-    pybsleep_obj_wakeup();
+    pyb_sleep_obj_wakeup();

    // reconfigure all the previously enabled interrupts
-    mpcallback_wake_all();
+    mp_irq_wake_all();
+
+    // we need to init the crypto hash engine again
+    //CRYPTOHASH_Init();

    // trigger a sw interrupt
    MAP_IntPendSet(INT_PRCM);
@@ -402,23 +484,36 @@ void pybsleep_suspend_exit (void) {
 STATIC void PRCMInterruptHandler (void) {
    // reading the interrupt status automatically clears the interrupt
    if (PRCM_INT_SLOW_CLK_CTR == MAP_PRCMIntStatus()) {
-        // this interrupt is triggered during active mode
-        mpcallback_handler(pybsleep_data.timer_lpds_wake_cb);
-    }
-    else {
+        // reconfigure it again (if repeat is true)
+        pyb_rtc_repeat_alarm (pybsleep_data.rtc_obj);
+        pybsleep_data.rtc_obj->irq_flags = PYB_RTC_ALARM0;
+        // need to check if irq's are enabled from the user point of view
+        if (pybsleep_data.rtc_obj->irq_enabled && (pybsleep_data.rtc_obj->pwrmode & PYB_PWR_MODE_ACTIVE)) {
+            mp_irq_handler(pybsleep_data.rtc_obj->irq_obj);
+        }
+        pybsleep_data.rtc_obj->irq_flags = 0;
+    } else {
        // interrupt has been triggered while waking up from LPDS
        switch (MAP_PRCMLPDSWakeupCauseGet()) {
        case PRCM_LPDS_HOST_IRQ:
-            mpcallback_handler(pybsleep_data.wlan_lpds_wake_cb);
+            pybsleep_data.wlan_obj->irq_flags = MODWLAN_WIFI_EVENT_ANY;
+            mp_irq_handler(pybsleep_data.wlan_obj->irq_obj);
+            pybsleep_wake_reason = PYB_SLP_WAKED_BY_WLAN;
+            pybsleep_data.wlan_obj->irq_flags = 0;
            break;
        case PRCM_LPDS_GPIO:
-            mpcallback_handler(pybsleep_data.gpio_lpds_wake_cb);
+            mp_irq_handler(pybsleep_data.gpio_lpds_wake_cb);
+            pybsleep_wake_reason = PYB_SLP_WAKED_BY_GPIO;
            break;
        case PRCM_LPDS_TIMER:
-            // disable the timer as a wake-up source
-            pybsleep_data.timer_wake_pwrmode &= ~PYB_PWR_MODE_LPDS;
+            // reconfigure it again if repeat is true
+            pyb_rtc_repeat_alarm (pybsleep_data.rtc_obj);
+            pybsleep_data.rtc_obj->irq_flags = PYB_RTC_ALARM0;
+            // next one clears the wake cause flag
            MAP_PRCMLPDSWakeupSourceDisable(PRCM_LPDS_TIMER);
-            mpcallback_handler(pybsleep_data.timer_lpds_wake_cb);
+            mp_irq_handler(pybsleep_data.rtc_obj->irq_obj);
+            pybsleep_data.rtc_obj->irq_flags = 0;
+            pybsleep_wake_reason = PYB_SLP_WAKED_BY_RTC;
            break;
        default:
            break;
@@ -426,38 +521,35 @@ STATIC void PRCMInterruptHandler (void) {
    }
 }

-STATIC void pybsleep_obj_wakeup (void) {
-    for (mp_uint_t i = 0; i < MP_STATE_PORT(pybsleep_obj_list).len; i++) {
-        pybsleep_obj_t *sleep_obj = ((pybsleep_obj_t *)MP_STATE_PORT(pybsleep_obj_list).items[i]);
+STATIC void pyb_sleep_obj_wakeup (void) {
+    for (mp_uint_t i = 0; i < MP_STATE_PORT(pyb_sleep_obj_list).len; i++) {
+        pyb_sleep_obj_t *sleep_obj = ((pyb_sleep_obj_t *)MP_STATE_PORT(pyb_sleep_obj_list).items[i]);
        sleep_obj->wakeup(sleep_obj->obj);
    }
 }

-STATIC void pybsleep_iopark (void) {
-    mp_map_t *named_map = mp_obj_dict_get_map((mp_obj_t)&pin_cpu_pins_locals_dict);
+STATIC void pyb_sleep_iopark (bool hibernate) {
+    mp_map_t *named_map = mp_obj_dict_get_map((mp_obj_t)&pin_board_pins_locals_dict);
    for (uint i = 0; i < named_map->used; i++) {
        pin_obj_t * pin = (pin_obj_t *)named_map->table[i].value;
-        // skip the sflash pins since these are shared with the network processor
        switch (pin->pin_num) {
-        case PIN_11:
-        case PIN_12:
-        case PIN_13:
-        case PIN_14:
 #ifdef DEBUG
-        // also skip the JTAG pins
+        // skip the JTAG pins
        case PIN_16:
        case PIN_17:
        case PIN_19:
        case PIN_20:
-#endif
            break;
+#endif
        default:
-            // enable a weak pull-down if the pin is unused
-            if (!pin->isused) {
-                MAP_PinConfigSet(pin->pin_num, pin->strength, PIN_TYPE_STD_PD);
+            // enable a weak pull-up if the pin is unused
+            if (!pin->used) {
+                MAP_PinConfigSet(pin->pin_num, pin->strength, PIN_TYPE_STD_PU);
+            }
+            if (hibernate) {
+                // make it an input
+                MAP_PinDirModeSet(pin->pin_num, PIN_DIR_MODE_IN);
            }
-            // make it an input
-            MAP_PinDirModeSet(pin->pin_num, PIN_DIR_MODE_IN);
            break;
        }
    }
@@ -472,196 +564,94 @@ STATIC void pybsleep_iopark (void) {
    HWREG(0x4402E0F4) &= ~(0x3 << 8);
    HWREG(0x4402E0F4) |= (0x1 << 8);

-    // park the antenna selection pins
-    HWREG(0x4402E108) = 0x00000E61;
-    HWREG(0x4402E10C) = 0x00000E61;
+    // if the board has antenna diversity, only park the antenna
+    // selection pins when going into hibernation
+#if MICROPY_HW_ANTENNA_DIVERSITY
+    if (hibernate) {
+#endif
+        // park the antenna selection pins
+        // (tri-stated with pull down enabled)
+        HWREG(0x4402E108) = 0x00000E61;
+        HWREG(0x4402E10C) = 0x00000E61;
+#if MICROPY_HW_ANTENNA_DIVERSITY
+    } else {
+        // park the antenna selection pins
+        // (tri-stated without changing the pull up/down resistors)
+        HWREG(0x4402E108) &= ~0x000000FF;
+        HWREG(0x4402E108) |=  0x00000C61;
+        HWREG(0x4402E10C) &= ~0x000000FF;
+        HWREG(0x4402E10C) |=  0x00000C61;
+    }
+#endif
 }

 STATIC bool setup_timer_lpds_wake (void) {
-    uint64_t t_match, t_curr, t_remaining;
+    uint64_t t_match, t_curr;
+    int64_t t_remaining;

    // get the time remaining for the RTC timer to expire
    t_match = MAP_PRCMSlowClkCtrMatchGet();
    t_curr  = MAP_PRCMSlowClkCtrGet();

-    if (t_match > t_curr) {
-        // get the time remaining in terms of slow clocks
-        t_remaining = (t_match - t_curr);
-        if (t_remaining > WAKEUP_TIME_LPDS) {
-            // subtract the time it takes for wakeup from lpds
-            t_remaining -= WAKEUP_TIME_LPDS;
-            t_remaining = (t_remaining > 0xFFFFFFFF) ? 0xFFFFFFFF: t_remaining;
-            // setup the LPDS wake time
-            MAP_PRCMLPDSIntervalSet((uint32_t)t_remaining);
-            // enable the wake source
-            MAP_PRCMLPDSWakeupSourceEnable(PRCM_LPDS_TIMER);
-            return true;
-        }
-    }
-    else {
-        // setup a timer interrupt immediately
-        MAP_PRCMRTCMatchSet(0, FORCED_TIMER_INTERRUPT_MS);
+    // get the time remaining in terms of slow clocks
+    t_remaining = (t_match - t_curr);
+    if (t_remaining > WAKEUP_TIME_LPDS) {
+        // subtract the time it takes to wakeup from lpds
+        t_remaining -= WAKEUP_TIME_LPDS;
+        t_remaining = (t_remaining > 0xFFFFFFFF) ? 0xFFFFFFFF: t_remaining;
+        // setup the LPDS wake time
+        MAP_PRCMLPDSIntervalSet((uint32_t)t_remaining);
+        // enable the wake source
+        MAP_PRCMLPDSWakeupSourceEnable(PRCM_LPDS_TIMER);
+        return true;
    }

    // disable the timer as wake source
    MAP_PRCMLPDSWakeupSourceDisable(PRCM_LPDS_TIMER);

-    // LPDS wake by timer was not possible, force
-    // an interrupt in active mode instead
+    uint32_t f_seconds;
+    uint16_t f_mseconds;
+    // setup a timer interrupt immediately
+    pyb_rtc_calc_future_time (FORCED_TIMER_INTERRUPT_MS, &f_seconds, &f_mseconds);
+    MAP_PRCMRTCMatchSet(f_seconds, f_mseconds);
+    // LPDS wake by timer was not possible, force an interrupt in active mode instead
    MAP_PRCMIntEnable(PRCM_INT_SLOW_CLK_CTR);

    return false;
 }

 STATIC bool setup_timer_hibernate_wake (void) {
-    uint64_t t_match, t_curr, t_remaining;
+    uint64_t t_match, t_curr;
+    int64_t t_remaining;

    // get the time remaining for the RTC timer to expire
    t_match = MAP_PRCMSlowClkCtrMatchGet();
    t_curr  = MAP_PRCMSlowClkCtrGet();

-    if (t_match > t_curr) {
-        // get the time remaining in terms of slow clocks
-        t_remaining = (t_match - t_curr);
-        if (t_remaining > WAKEUP_TIME_HIB) {
-            // subtract the time it takes for wakeup from hibernate
-            t_remaining -= WAKEUP_TIME_HIB;
-            // setup the LPDS wake time
-            MAP_PRCMHibernateIntervalSet((uint32_t)t_remaining);
-            // enable the wake source
-            MAP_PRCMHibernateWakeupSourceEnable(PRCM_HIB_SLOW_CLK_CTR);
-            return true;
-        }
-    }
-    else {
-        // setup a timer interrupt immediately
-        MAP_PRCMRTCMatchSet(0, FORCED_TIMER_INTERRUPT_MS);
+    // get the time remaining in terms of slow clocks
+    t_remaining = (t_match - t_curr);
+    if (t_remaining > WAKEUP_TIME_HIB) {
+        // subtract the time it takes for wakeup from hibernate
+        t_remaining -= WAKEUP_TIME_HIB;
+        // setup the LPDS wake time
+        MAP_PRCMHibernateIntervalSet((uint32_t)t_remaining);
+        // enable the wake source
+        MAP_PRCMHibernateWakeupSourceEnable(PRCM_HIB_SLOW_CLK_CTR);
+        return true;
    }

+
    // disable the timer as wake source
    MAP_PRCMLPDSWakeupSourceDisable(PRCM_HIB_SLOW_CLK_CTR);

-    // hibernate wake by timer was not possible, force
-    // an interrupt in active mode instead
+    uint32_t f_seconds;
+    uint16_t f_mseconds;
+    // setup a timer interrupt immediately
+    pyb_rtc_calc_future_time (FORCED_TIMER_INTERRUPT_MS, &f_seconds, &f_mseconds);
+    MAP_PRCMRTCMatchSet(f_seconds, f_mseconds);
+    // LPDS wake by timer was not possible, force an interrupt in active mode instead
    MAP_PRCMIntEnable(PRCM_INT_SLOW_CLK_CTR);

    return false;
 }

-/******************************************************************************/
-// Micro Python bindings; Sleep class
-
-/// \function idle()
-/// Gates the processor clock until an interrupt is triggered
-STATIC mp_obj_t pyb_sleep_idle (mp_obj_t self_in) {
-    __WFI();
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_sleep_idle_obj, pyb_sleep_idle);
-
-/// \function suspend(wlan)
-/// Enters suspended mode. Wake up sources should have been enable prior to
-/// calling this method.
-STATIC mp_obj_t pyb_sleep_suspend (mp_obj_t self_in) {
-    nlr_buf_t nlr;
-
-    // check if we should enable timer wake-up
-    if (pybsleep_data.timer_wake_pwrmode & PYB_PWR_MODE_LPDS) {
-        if (!setup_timer_lpds_wake()) {
-            // lpds entering is not possible, wait for the forced interrupt and return
-            pybsleep_data.timer_wake_pwrmode &= ~PYB_PWR_MODE_LPDS;
-            HAL_Delay (FAILED_SLEEP_DELAY_MS);
-            return mp_const_none;
-        }
-    }
-
-    // do we need network wake-up?
-    if (pybsleep_data.wlan_lpds_wake_cb) {
-        MAP_PRCMLPDSWakeupSourceEnable (PRCM_LPDS_HOST_IRQ);
-    }
-    else {
-        MAP_PRCMLPDSWakeupSourceDisable (PRCM_LPDS_HOST_IRQ);
-    }
-
-    // entering and exiting suspended mode must be an atomic operation
-    // therefore interrupts need to be disabled
-    uint primsk = disable_irq();
-    if (nlr_push(&nlr) == 0) {
-        pybsleep_suspend_enter();
-        nlr_pop();
-    }
-
-    // an exception is always raised when exiting suspend mode
-    enable_irq(primsk);
-
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_sleep_suspend_obj, pyb_sleep_suspend);
-
-/// \function hibernate()
-/// Enters hibernate mode. Wake up sources should have been enable prior to
-/// calling this method.
-STATIC mp_obj_t pyb_sleep_hibernate (mp_obj_t self_in) {
-    // check if we should enable timer wake-up
-    if (pybsleep_data.timer_wake_pwrmode & PYB_PWR_MODE_HIBERNATE) {
-        if (!setup_timer_hibernate_wake()) {
-            // hibernating is not possible, wait for the forced interrupt and return
-            pybsleep_data.timer_wake_pwrmode &= ~PYB_PWR_MODE_HIBERNATE;
-            HAL_Delay (FAILED_SLEEP_DELAY_MS);
-            return mp_const_none;
-        }
-    }
-    wlan_stop(SL_STOP_TIMEOUT);
-    pybsleep_flash_powerdown();
-    // must be done just before entering hibernate mode
-    pybsleep_iopark();
-    MAP_PRCMHibernateEnter();
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_sleep_hibernate_obj, pyb_sleep_hibernate);
-
-/// \function reset_cause()
-/// Returns the last reset casue
-STATIC mp_obj_t pyb_sleep_reset_cause (mp_obj_t self_in) {
-    return MP_OBJ_NEW_SMALL_INT(pybsleep_reset_cause);
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_sleep_reset_cause_obj, pyb_sleep_reset_cause);
-
-/// \function wake_reason()
-/// Returns the wake up reson from ldps or hibernate
-STATIC mp_obj_t pyb_sleep_wake_reason (mp_obj_t self_in) {
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_sleep_wake_reason_obj, pyb_sleep_wake_reason);
-
-STATIC const mp_map_elem_t pybsleep_locals_dict_table[] = {
-    // instance methods
-    { MP_OBJ_NEW_QSTR(MP_QSTR_idle),                    (mp_obj_t)&pyb_sleep_idle_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_suspend),                 (mp_obj_t)&pyb_sleep_suspend_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_hibernate),               (mp_obj_t)&pyb_sleep_hibernate_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_reset_cause),             (mp_obj_t)&pyb_sleep_reset_cause_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_wake_reason),             (mp_obj_t)&pyb_sleep_wake_reason_obj },
-
-    // class constants
-    { MP_OBJ_NEW_QSTR(MP_QSTR_ACTIVE),                  MP_OBJ_NEW_SMALL_INT(PYB_PWR_MODE_ACTIVE) },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_SUSPENDED),               MP_OBJ_NEW_SMALL_INT(PYB_PWR_MODE_LPDS) },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_HIBERNATING),             MP_OBJ_NEW_SMALL_INT(PYB_PWR_MODE_HIBERNATE) },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_PWR_ON_RESET),            MP_OBJ_NEW_SMALL_INT(PYB_SLP_PWRON_RESET) },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_HARD_RESET),              MP_OBJ_NEW_SMALL_INT(PYB_SLP_HARD_RESET) },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_WDT_RESET),               MP_OBJ_NEW_SMALL_INT(PYB_SLP_WDT_RESET) },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_HIB_RESET),               MP_OBJ_NEW_SMALL_INT(PYB_SLP_HIB_RESET) },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_SOFT_RESET),              MP_OBJ_NEW_SMALL_INT(PYB_SLP_SOFT_RESET) },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_WLAN_WAKE),               MP_OBJ_NEW_SMALL_INT(PYB_SLP_WAKED_BY_WLAN) },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_PIN_WAKE),                MP_OBJ_NEW_SMALL_INT(PYB_SLP_WAKED_BY_PIN) },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_RTC_WAKE),                MP_OBJ_NEW_SMALL_INT(PYB_SLP_WAKED_BY_RTC) },
-};
-
-STATIC MP_DEFINE_CONST_DICT(pybsleep_locals_dict, pybsleep_locals_dict_table);
-
-STATIC const mp_obj_type_t pybsleep_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_sleep,
-    .locals_dict = (mp_obj_t)&pybsleep_locals_dict,
-};
-
-const mp_obj_base_t pyb_sleep_obj = {&pybsleep_type};
--- a/cc3200/mods/pybsleep.h
+++ b/cc3200/mods/pybsleep.h
@@ -42,37 +42,32 @@ typedef enum {
    PYB_SLP_HARD_RESET,
    PYB_SLP_WDT_RESET,
    PYB_SLP_HIB_RESET,
-    PYB_SLP_SOFT_RESET,
-
+    PYB_SLP_SOFT_RESET
 } pybsleep_reset_cause_t;

 typedef enum {
+    PYB_SLP_WAKED_PWRON = 0,
    PYB_SLP_WAKED_BY_WLAN,
-    PYB_SLP_WAKED_BY_PIN,
+    PYB_SLP_WAKED_BY_GPIO,
    PYB_SLP_WAKED_BY_RTC
-
 } pybsleep_wake_reason_t;

 typedef void (*WakeUpCB_t)(const mp_obj_t self);
-typedef void (*DeinitCB_t)(const mp_obj_t self);
-
-/******************************************************************************
- DECLARE EXPORTED VARIABLES
- ******************************************************************************/
-extern const mp_obj_base_t pyb_sleep_obj;

 /******************************************************************************
 DECLARE FUNCTIONS
 ******************************************************************************/
-void pybsleep_pre_init (void);
-void pybsleep_init0 (void);
-void pybsleep_signal_soft_reset (void);
-void pybsleep_add (const mp_obj_t obj, WakeUpCB_t wakeup);
-void pybsleep_remove (const mp_obj_t obj);
-void pybsleep_set_wlan_lpds_callback (mp_obj_t cb_obj);
-void pybsleep_set_gpio_lpds_callback (mp_obj_t cb_obj);
-void pybsleep_set_timer_lpds_callback (mp_obj_t cb_obj);
-void pybsleep_configure_timer_wakeup (uint pwrmode);
-pybsleep_reset_cause_t pybsleep_get_reset_cause (void);
+void pyb_sleep_pre_init (void);
+void pyb_sleep_init0 (void);
+void pyb_sleep_signal_soft_reset (void);
+void pyb_sleep_add (const mp_obj_t obj, WakeUpCB_t wakeup);
+void pyb_sleep_remove (const mp_obj_t obj);
+void pyb_sleep_set_gpio_lpds_callback (mp_obj_t cb_obj);
+void pyb_sleep_set_wlan_obj (mp_obj_t wlan_obj);
+void pyb_sleep_set_rtc_obj (mp_obj_t rtc_obj);
+void pyb_sleep_sleep (void);
+void pyb_sleep_deepsleep (void);
+pybsleep_reset_cause_t pyb_sleep_get_reset_cause (void);
+pybsleep_wake_reason_t pyb_sleep_get_wake_reason (void);

 #endif /* PYBSLEEP_H_ */
--- a/cc3200/mods/pybspi.c
+++ b/cc3200/mods/pybspi.c
@@ -29,7 +29,6 @@
 #include <string.h>

 #include "py/mpstate.h"
-#include MICROPY_HAL_H
 #include "py/runtime.h"
 #include "bufhelper.h"
 #include "inc/hw_types.h"
@@ -43,28 +42,11 @@
 #include "pybspi.h"
 #include "mpexception.h"
 #include "pybsleep.h"
+#include "pybpin.h"
+#include "pins.h"

 /// \moduleref pyb
 /// \class SPI - a master-driven serial protocol
-///
-/// SPI is a serial protocol that is driven by a master.  At the physical level
-/// there are 3 lines: SCK, MOSI, MISO.
-///
-/// See usage model of I2C; SPI is very similar.  Main difference is
-/// parameters to init the SPI bus:
-///
-///     from pyb import SPI
-///     spi = SPI(2000000, bits=8, submode=0, cs=SPI.ACTIVE_LOW)
-///
-/// Only required parameter is the baudrate, in Hz. Submode may be 0-3.
-/// Bit accepts 8, 16, 32. Chip select values are ACTIVE_LOW and ACTIVE_HIGH
-///
-/// Additional method for SPI:
-///
-///     data = spi.send_recv(b'1234')        # send 4 bytes and receive 4 bytes
-///     buf = bytearray(4)
-///     spi.send_recv(b'1234', buf)          # send 4 bytes and receive 4 into buf
-///     spi.send_recv(buf, buf)              # send/recv 4 bytes from/to buf

 /******************************************************************************
 DEFINE TYPES
@@ -73,10 +55,8 @@ typedef struct _pyb_spi_obj_t {
    mp_obj_base_t base;
    uint baudrate;
    uint config;
-    vstr_t tx_vstr;
-    vstr_t rx_vstr;
-    uint tx_index;
-    uint rx_index;
+    byte polarity;
+    byte phase;
    byte submode;
    byte wlen;
 } pyb_spi_obj_t;
@@ -84,14 +64,15 @@ typedef struct _pyb_spi_obj_t {
 /******************************************************************************
 DEFINE CONSTANTS
 ******************************************************************************/
-#define PYBSPI_DEF_BAUDRATE                     1000000     // 1MHz
-#define PYBSPI_CS_NONE                          0xFF        // spi cs is controlled by the user
+#define PYBSPI_FIRST_BIT_MSB                    0

 /******************************************************************************
 DECLARE PRIVATE DATA
 ******************************************************************************/
 STATIC pyb_spi_obj_t pyb_spi_obj = {.baudrate = 0};

+STATIC const mp_obj_t pyb_spi_def_pin[3] = {&pin_GP14, &pin_GP16, &pin_GP30};
+
 /******************************************************************************
 DEFINE PRIVATE FUNCTIONS
 ******************************************************************************/
@@ -111,21 +92,19 @@ STATIC void pybspi_init (const pyb_spi_obj_t *self) {
 }

 STATIC void pybspi_tx (pyb_spi_obj_t *self, const void *data) {
-    uint32_t txdata = 0xFFFFFFFF;
-    if (data) {
-        switch (self->wlen) {
-        case 1:
-            txdata = (uint8_t)(*(char *)data);
-            break;
-        case 2:
-            txdata = (uint16_t)(*(uint16_t *)data);
-            break;
-        case 4:
-            txdata = (uint32_t)(*(uint32_t *)data);
-            break;
-        default:
-            return;
-        }
+    uint32_t txdata;
+    switch (self->wlen) {
+    case 1:
+        txdata = (uint8_t)(*(char *)data);
+        break;
+    case 2:
+        txdata = (uint16_t)(*(uint16_t *)data);
+        break;
+    case 4:
+        txdata = (uint32_t)(*(uint32_t *)data);
+        break;
+    default:
+        return;
    }
    MAP_SPIDataPut (GSPI_BASE, txdata);
 }
@@ -150,11 +129,14 @@ STATIC void pybspi_rx (pyb_spi_obj_t *self, void *data) {
    }
 }

-STATIC void pybspi_transfer (pyb_spi_obj_t *self, const char *txdata, char *rxdata, uint32_t len) {
+STATIC void pybspi_transfer (pyb_spi_obj_t *self, const char *txdata, char *rxdata, uint32_t len, uint32_t *txchar) {
+    if (!self->baudrate) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_request_not_possible));
+    }
    // send and receive the data
    MAP_SPICSEnable(GSPI_BASE);
-    for (int i = 0; i < len / self->wlen; i += self->wlen) {
-        pybspi_tx(self, txdata ? (const void *)&txdata[i] : NULL);
+    for (int i = 0; i < len; i += self->wlen) {
+        pybspi_tx(self, txdata ? (const void *)&txdata[i] : txchar);
        pybspi_rx(self, rxdata ? (void *)&rxdata[i] : NULL);
    }
    MAP_SPICSDisable(GSPI_BASE);
@@ -165,43 +147,22 @@ STATIC void pybspi_transfer (pyb_spi_obj_t *self, const char *txdata, char *rxda
 /******************************************************************************/
 STATIC void pyb_spi_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
    pyb_spi_obj_t *self = self_in;
-
    if (self->baudrate > 0) {
-        mp_printf(print, "<SPI0, SPI.MASTER, baudrate=%u, config=%u, submode=%u, bits=%u>",
-              self->baudrate, self->config, self->submode, (self->wlen * 8));
-    }
-    else {
-        mp_print_str(print, "<SPI0>");
+        mp_printf(print, "SPI(0, SPI.MASTER, baudrate=%u, bits=%u, polarity=%u, phase=%u, firstbit=SPI.MSB)",
+                  self->baudrate, (self->wlen * 8), self->polarity, self->phase);
+    } else {
+        mp_print_str(print, "SPI(0)");
    }
 }

-/// \method init(2000000, *, bits=8, submode=0, cs=SPI.ACTIVELOW)
-///
-/// Initialise the SPI bus with the given parameters:
-///
-///   - `baudrate` is the SCK clock rate.
-///   - `bits` is the transfer width size (8, 16, 32).
-///   - `submode` is the spi mode (0, 1, 2, 3).
-///   - `cs` can be ACTIVELOW, ACTIVEHIGH, or NONE
-static const mp_arg_t pybspi_init_args[] = {
-    { MP_QSTR_baudrate,     MP_ARG_REQUIRED | MP_ARG_INT,  },
-    { MP_QSTR_bits,         MP_ARG_KW_ONLY  | MP_ARG_INT,  {.u_int = 8} },
-    { MP_QSTR_submode,      MP_ARG_KW_ONLY  | MP_ARG_INT,  {.u_int = 0} },
-    { MP_QSTR_cs,           MP_ARG_KW_ONLY  | MP_ARG_INT,  {.u_int = SPI_CS_ACTIVELOW} },
-};
+STATIC mp_obj_t pyb_spi_init_helper(pyb_spi_obj_t *self, const mp_arg_val_t *args) {
+    // verify that mode is master
+    if (args[0].u_int != SPI_MODE_MASTER) {
+        goto invalid_args;
+    }

-STATIC mp_obj_t pyb_spi_init_helper(pyb_spi_obj_t *self, mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    // parse args
-    mp_arg_val_t args[MP_ARRAY_SIZE(pybspi_init_args)];
-    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(pybspi_init_args), pybspi_init_args, args);
-
-    uint submode = args[2].u_int;
-    uint cs = args[3].u_int;
    uint bits;
-
-    // save the word length for later use
-    self->wlen = args[1].u_int / 8;
-    switch (args[1].u_int) {
+    switch (args[2].u_int) {
    case 8:
        bits = SPI_WL_8;
        break;
@@ -212,59 +173,91 @@ STATIC mp_obj_t pyb_spi_init_helper(pyb_spi_obj_t *self, mp_uint_t n_args, const
        bits = SPI_WL_32;
        break;
    default:
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
+        goto invalid_args;
        break;
    }

-    if (submode < SPI_SUB_MODE_0 || submode > SPI_SUB_MODE_3) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
+    uint polarity = args[3].u_int;
+    uint phase = args[4].u_int;
+    if (polarity > 1 || phase > 1) {
+        goto invalid_args;
    }

-    if (cs != SPI_CS_ACTIVELOW && cs != SPI_CS_ACTIVEHIGH) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
+    uint firstbit = args[5].u_int;
+    if (firstbit != PYBSPI_FIRST_BIT_MSB) {
+        goto invalid_args;
    }

    // build the configuration
-    self->baudrate = args[0].u_int;
-    self->config = bits | cs | SPI_SW_CTRL_CS | SPI_4PIN_MODE | SPI_TURBO_OFF;
-    self->submode = submode;
+    self->baudrate = args[1].u_int;
+    self->wlen = args[2].u_int >> 3;
+    self->config = bits | SPI_CS_ACTIVELOW | SPI_SW_CTRL_CS | SPI_4PIN_MODE | SPI_TURBO_OFF;
+    self->polarity = polarity;
+    self->phase = phase;
+    self->submode = (polarity << 1) | phase;
+
+    // assign the pins
+    mp_obj_t pins_o = args[6].u_obj;
+    if (pins_o != mp_const_none) {
+        mp_obj_t *pins;
+        if (pins_o == MP_OBJ_NULL) {
+            // use the default pins
+            pins = (mp_obj_t *)pyb_spi_def_pin;
+        } else {
+            mp_obj_get_array_fixed_n(pins_o, 3, &pins);
+        }
+        pin_assign_pins_af (pins, 3, PIN_TYPE_STD_PU, PIN_FN_SPI, 0);
+    }

    // init the bus
    pybspi_init((const pyb_spi_obj_t *)self);

    // register it with the sleep module
-    pybsleep_add((const mp_obj_t)self, (WakeUpCB_t)pybspi_init);
+    pyb_sleep_add((const mp_obj_t)self, (WakeUpCB_t)pybspi_init);

    return mp_const_none;
+
+invalid_args:
+    nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
 }

-/// \classmethod \constructor(bus, ...)
-///
-/// Construct an SPI object with the given baudrate.
-/// With no 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.
-///
-STATIC mp_obj_t pyb_spi_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
-    // check arguments
-    mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
+static const mp_arg_t pyb_spi_init_args[] = {
+    { MP_QSTR_id,                             MP_ARG_INT,  {.u_int = 0} },
+    { MP_QSTR_mode,                           MP_ARG_INT,  {.u_int = SPI_MODE_MASTER} },
+    { MP_QSTR_baudrate,     MP_ARG_KW_ONLY  | MP_ARG_INT,  {.u_int = 1000000} },    // 1MHz
+    { MP_QSTR_bits,         MP_ARG_KW_ONLY  | MP_ARG_INT,  {.u_int = 8} },
+    { MP_QSTR_polarity,     MP_ARG_KW_ONLY  | MP_ARG_INT,  {.u_int = 0} },
+    { MP_QSTR_phase,        MP_ARG_KW_ONLY  | MP_ARG_INT,  {.u_int = 0} },
+    { MP_QSTR_firstbit,     MP_ARG_KW_ONLY  | MP_ARG_INT,  {.u_int = PYBSPI_FIRST_BIT_MSB} },
+    { MP_QSTR_pins,         MP_ARG_KW_ONLY  | MP_ARG_OBJ,  {.u_obj = MP_OBJ_NULL} },
+};
+STATIC mp_obj_t pyb_spi_make_new(const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
+    // parse args
+    mp_map_t kw_args;
+    mp_map_init_fixed_table(&kw_args, n_kw, all_args + n_args);
+    mp_arg_val_t args[MP_ARRAY_SIZE(pyb_spi_init_args)];
+    mp_arg_parse_all(n_args, all_args, &kw_args, MP_ARRAY_SIZE(args), pyb_spi_init_args, args);

+    // check the peripheral id
+    if (args[0].u_int != 0) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_resource_not_avaliable));
+    }
+
+    // setup the object
    pyb_spi_obj_t *self = &pyb_spi_obj;
    self->base.type = &pyb_spi_type;

-    if (n_args > 0 || n_kw > 0) {
-        // start the peripheral
-        mp_map_t kw_args;
-        mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
-        pyb_spi_init_helper(self, n_args, args, &kw_args);
-    }
+    // start the peripheral
+    pyb_spi_init_helper(self, &args[1]);

    return self;
 }

-STATIC mp_obj_t pyb_spi_init(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
-    return pyb_spi_init_helper(args[0], n_args - 1, args + 1, kw_args);
+STATIC mp_obj_t pyb_spi_init(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    // parse args
+    mp_arg_val_t args[MP_ARRAY_SIZE(pyb_spi_init_args) - 1];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(args), &pyb_spi_init_args[1], args);
+    return pyb_spi_init_helper(pos_args[0], args);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_spi_init_obj, 1, pyb_spi_init);

@@ -277,127 +270,117 @@ STATIC mp_obj_t pyb_spi_deinit(mp_obj_t self_in) {
    // invalidate the baudrate
    pyb_spi_obj.baudrate = 0;
    // unregister it with the sleep module
-    pybsleep_remove((const mp_obj_t)self_in);
+    pyb_sleep_remove((const mp_obj_t)self_in);
    return mp_const_none;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_spi_deinit_obj, pyb_spi_deinit);

-/// \method send(send)
-/// Send data on the bus:
-///
-/// - `send` is the data to send (a byte to send, or a buffer object).
-///
-STATIC mp_obj_t pyb_spi_send (mp_obj_t self_in, mp_obj_t send_o) {
+STATIC mp_obj_t pyb_spi_write (mp_obj_t self_in, mp_obj_t buf) {
+    // parse args
    pyb_spi_obj_t *self = self_in;
+
    // get the buffer to send from
    mp_buffer_info_t bufinfo;
    uint8_t data[1];
-    pyb_buf_get_for_send(send_o, &bufinfo, data);
+    pyb_buf_get_for_send(buf, &bufinfo, data);

    // just send
-    pybspi_transfer(self, (const char *)bufinfo.buf, NULL, bufinfo.len);
+    pybspi_transfer(self, (const char *)bufinfo.buf, NULL, bufinfo.len, NULL);

-    return mp_const_none;
+    // return the number of bytes written
+    return mp_obj_new_int(bufinfo.len);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_spi_send_obj, pyb_spi_send);
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_spi_write_obj, pyb_spi_write);
+
+STATIC mp_obj_t pyb_spi_read(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_nbytes,    MP_ARG_REQUIRED | MP_ARG_OBJ, },
+        { MP_QSTR_write,     MP_ARG_KW_ONLY  | MP_ARG_INT, {.u_int = 0x00} },
+    };
+
+    // parse args
+    pyb_spi_obj_t *self = pos_args[0];
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(args), allowed_args, args);

-/// \method recv(recv)
-///
-/// Receive data on the bus:
-///
-///   - `recv` can be an integer, which is the number of bytes to receive,
-///      or a mutable buffer, which will be filled with received bytes.
-///
-/// Return: if `recv` is an integer then a new buffer of the bytes received,
-/// otherwise the same buffer that was passed in to `recv`.
-STATIC mp_obj_t pyb_spi_recv(mp_obj_t self_in, mp_obj_t recv_o) {
-    pyb_spi_obj_t *self = self_in;
    // get the buffer to receive into
    vstr_t vstr;
-    mp_obj_t o_ret = pyb_buf_get_for_recv(recv_o, &vstr);
+    pyb_buf_get_for_recv(args[0].u_obj, &vstr);

    // just receive
-    pybspi_transfer(self, NULL, vstr.buf, vstr.len);
+    uint32_t write = args[1].u_int;
+    pybspi_transfer(self, NULL, vstr.buf, vstr.len, &write);

    // return the received data
-    if (o_ret != MP_OBJ_NULL) {
-        return o_ret;
-    } else {
-        return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
-    }
+    return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_spi_recv_obj, pyb_spi_recv);
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_spi_read_obj, 1, pyb_spi_read);

-/// \method send_recv(send, recv)
-///
-/// Send and receive data on the bus at the same time:
-///
-///   - `send` is the data to send (an integer to send, or a buffer object).
-///   - `recv` is a mutable buffer which will be filled with received bytes.
-///      It can be the same as `send`, or omitted.  If omitted, a new buffer will
-///      be created.
-///
-/// Return: the buffer with the received bytes.
-STATIC mp_obj_t pyb_spi_send_recv (mp_uint_t n_args, const mp_obj_t *args) {
-    pyb_spi_obj_t *self = args[0];
+STATIC mp_obj_t pyb_spi_readinto(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_buf,       MP_ARG_REQUIRED | MP_ARG_OBJ, },
+        { MP_QSTR_write,     MP_ARG_KW_ONLY  | MP_ARG_INT, {.u_int = 0x00} },
+    };

-    // get buffers to send from/receive to
-    mp_buffer_info_t bufinfo_send;
+    // parse args
+    pyb_spi_obj_t *self = pos_args[0];
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(args), allowed_args, args);
+
+    // get the buffer to receive into
+    vstr_t vstr;
+    pyb_buf_get_for_recv(args[0].u_obj, &vstr);
+
+    // just receive
+    uint32_t write = args[1].u_int;
+    pybspi_transfer(self, NULL, vstr.buf, vstr.len, &write);
+
+    // return the number of bytes received
+    return mp_obj_new_int(vstr.len);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_spi_readinto_obj, 1, pyb_spi_readinto);
+
+STATIC mp_obj_t pyb_spi_write_readinto (mp_obj_t self, mp_obj_t writebuf, mp_obj_t readbuf) {
+    // get buffers to write from/read to
+    mp_buffer_info_t bufinfo_write;
    uint8_t data_send[1];
-    mp_buffer_info_t bufinfo_recv;
-    vstr_t vstr_recv;
-    mp_obj_t o_ret;
+    mp_buffer_info_t bufinfo_read;

-    if (args[1] == args[2]) {
-        // same object for sending and receiving, it must be a r/w buffer
-        mp_get_buffer_raise(args[1], &bufinfo_send, MP_BUFFER_RW);
-        bufinfo_recv = bufinfo_send;
-        o_ret = args[1];
+    if (writebuf == readbuf) {
+        // same object for writing and reading, it must be a r/w buffer
+        mp_get_buffer_raise(writebuf, &bufinfo_write, MP_BUFFER_RW);
+        bufinfo_read = bufinfo_write;
    } else {
-        // get the buffer to send from
-        pyb_buf_get_for_send(args[1], &bufinfo_send, data_send);
+        // get the buffer to write from
+        pyb_buf_get_for_send(writebuf, &bufinfo_write, data_send);

-        // get the buffer to receive into
-        if (n_args == 2) {
-            // only the send was argument given, so create a fresh buffer of the send length
-            vstr_init_len(&vstr_recv, bufinfo_send.len);
-            bufinfo_recv.len = vstr_recv.len;
-            bufinfo_recv.buf = vstr_recv.buf;
-            o_ret = MP_OBJ_NULL;
-        }
-        else {
-            // recv argument given
-            mp_get_buffer_raise(args[2], &bufinfo_recv, MP_BUFFER_WRITE);
-            if (bufinfo_recv.len != bufinfo_send.len) {
-                nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
-            }
-            o_ret = args[2];
+        // get the read buffer
+        mp_get_buffer_raise(readbuf, &bufinfo_read, MP_BUFFER_WRITE);
+        if (bufinfo_read.len != bufinfo_write.len) {
+            nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
        }
    }

    // send and receive
-    pybspi_transfer(self, (const char *)bufinfo_send.buf, vstr_recv.buf, bufinfo_send.len);
+    pybspi_transfer(self, (const char *)bufinfo_write.buf, bufinfo_read.buf, bufinfo_write.len, NULL);

-    // return the received data
-    if (o_ret != MP_OBJ_NULL) {
-        return o_ret;
-    } else {
-        return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr_recv);
-    }
+    // return the number of transferred bytes
+    return mp_obj_new_int(bufinfo_write.len);
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_spi_send_recv_obj, 2, 3, pyb_spi_send_recv);
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(pyb_spi_write_readinto_obj, pyb_spi_write_readinto);

 STATIC const mp_map_elem_t pyb_spi_locals_dict_table[] = {
    // instance methods
    { MP_OBJ_NEW_QSTR(MP_QSTR_init),                (mp_obj_t)&pyb_spi_init_obj },
    { MP_OBJ_NEW_QSTR(MP_QSTR_deinit),              (mp_obj_t)&pyb_spi_deinit_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_send),                (mp_obj_t)&pyb_spi_send_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_recv),                (mp_obj_t)&pyb_spi_recv_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_send_recv),           (mp_obj_t)&pyb_spi_send_recv_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_write),               (mp_obj_t)&pyb_spi_write_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_read),                (mp_obj_t)&pyb_spi_read_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_readinto),            (mp_obj_t)&pyb_spi_readinto_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_write_readinto),      (mp_obj_t)&pyb_spi_write_readinto_obj },

    // class constants
-    { MP_OBJ_NEW_QSTR(MP_QSTR_ACTIVE_LOW),          MP_OBJ_NEW_SMALL_INT(SPI_CS_ACTIVELOW) },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_ACTIVE_HIGH),         MP_OBJ_NEW_SMALL_INT(SPI_CS_ACTIVEHIGH) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_MASTER),              MP_OBJ_NEW_SMALL_INT(SPI_MODE_MASTER) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_MSB),                 MP_OBJ_NEW_SMALL_INT(PYBSPI_FIRST_BIT_MSB) },
 };

 STATIC MP_DEFINE_CONST_DICT(pyb_spi_locals_dict, pyb_spi_locals_dict_table);
--- a/cc3200/mods/pybtimer.c
+++ b/cc3200/mods/pybtimer.c
@@ -0,0 +1,734 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2013, 2014 Damien P. George
+ * Copyright (c) 2015 Daniel Campora
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "py/mpconfig.h"
+#include "py/obj.h"
+#include "py/nlr.h"
+#include "py/runtime.h"
+#include "py/gc.h"
+#include "py/mphal.h"
+#include "inc/hw_types.h"
+#include "inc/hw_ints.h"
+#include "inc/hw_memmap.h"
+#include "inc/hw_timer.h"
+#include "rom_map.h"
+#include "interrupt.h"
+#include "prcm.h"
+#include "timer.h"
+#include "pin.h"
+#include "pybtimer.h"
+#include "pybpin.h"
+#include "pins.h"
+#include "mpirq.h"
+#include "pybsleep.h"
+#include "mpexception.h"
+
+
+/// \moduleref pyb
+/// \class Timer - generate periodic events, count events, and create PWM signals.
+///
+/// Each timer consists of a counter that counts up at a certain rate.  The rate
+/// at which it counts is the peripheral clock frequency (in Hz) divided by the
+/// timer prescaler.  When the counter reaches the timer period it triggers an
+/// event, and the counter resets back to zero.  By using the irq method,
+/// the timer event can call a Python function.
+
+/******************************************************************************
+ DECLARE PRIVATE CONSTANTS
+ ******************************************************************************/
+#define PYBTIMER_NUM_TIMERS                         (4)
+#define PYBTIMER_POLARITY_POS                       (0x01)
+#define PYBTIMER_POLARITY_NEG                       (0x02)
+
+#define PYBTIMER_TIMEOUT_TRIGGER                    (0x01)
+#define PYBTIMER_MATCH_TRIGGER                      (0x02)
+
+#define PYBTIMER_SRC_FREQ_HZ                        HAL_FCPU_HZ
+
+/******************************************************************************
+ DEFINE PRIVATE TYPES
+ ******************************************************************************/
+typedef struct _pyb_timer_obj_t {
+    mp_obj_base_t base;
+    uint32_t timer;
+    uint32_t config;
+    uint16_t irq_trigger;
+    uint16_t irq_flags;
+    uint8_t peripheral;
+    uint8_t id;
+} pyb_timer_obj_t;
+
+typedef struct _pyb_timer_channel_obj_t {
+    mp_obj_base_t base;
+    struct _pyb_timer_obj_t *timer;
+    uint32_t frequency;
+    uint32_t period;
+    uint16_t channel;
+    uint16_t duty_cycle;
+    uint8_t  polarity;
+} pyb_timer_channel_obj_t;
+
+/******************************************************************************
+ DEFINE PRIVATE DATA
+ ******************************************************************************/
+STATIC const mp_irq_methods_t pyb_timer_channel_irq_methods;
+STATIC pyb_timer_obj_t pyb_timer_obj[PYBTIMER_NUM_TIMERS] = {{.timer = TIMERA0_BASE, .peripheral = PRCM_TIMERA0},
+                                                             {.timer = TIMERA1_BASE, .peripheral = PRCM_TIMERA1},
+                                                             {.timer = TIMERA2_BASE, .peripheral = PRCM_TIMERA2},
+                                                             {.timer = TIMERA3_BASE, .peripheral = PRCM_TIMERA3}};
+STATIC const mp_obj_type_t pyb_timer_channel_type;
+STATIC const mp_obj_t pyb_timer_pwm_pin[8] = {&pin_GP24, MP_OBJ_NULL, &pin_GP25, MP_OBJ_NULL, MP_OBJ_NULL, &pin_GP9, &pin_GP10, &pin_GP11};
+
+/******************************************************************************
+ DECLARE PRIVATE FUNCTIONS
+ ******************************************************************************/
+STATIC mp_obj_t pyb_timer_channel_irq (mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args);
+STATIC void timer_disable (pyb_timer_obj_t *tim);
+STATIC void timer_channel_init (pyb_timer_channel_obj_t *ch);
+STATIC void TIMER0AIntHandler(void);
+STATIC void TIMER0BIntHandler(void);
+STATIC void TIMER1AIntHandler(void);
+STATIC void TIMER1BIntHandler(void);
+STATIC void TIMER2AIntHandler(void);
+STATIC void TIMER2BIntHandler(void);
+STATIC void TIMER3AIntHandler(void);
+STATIC void TIMER3BIntHandler(void);
+
+/******************************************************************************
+ DEFINE PUBLIC FUNCTIONS
+ ******************************************************************************/
+void timer_init0 (void) {
+    mp_obj_list_init(&MP_STATE_PORT(pyb_timer_channel_obj_list), 0);
+}
+
+/******************************************************************************
+ DEFINE PRIVATE FUNCTIONS
+ ******************************************************************************/
+STATIC void pyb_timer_channel_irq_enable (mp_obj_t self_in) {
+    pyb_timer_channel_obj_t *self = self_in;
+    MAP_TimerIntClear(self->timer->timer, self->timer->irq_trigger & self->channel);
+    MAP_TimerIntEnable(self->timer->timer, self->timer->irq_trigger & self->channel);
+}
+
+STATIC void pyb_timer_channel_irq_disable (mp_obj_t self_in) {
+    pyb_timer_channel_obj_t *self = self_in;
+    MAP_TimerIntDisable(self->timer->timer, self->timer->irq_trigger & self->channel);
+}
+
+STATIC int pyb_timer_channel_irq_flags (mp_obj_t self_in) {
+    pyb_timer_channel_obj_t *self = self_in;
+    return self->timer->irq_flags;
+}
+
+STATIC pyb_timer_channel_obj_t *pyb_timer_channel_find (uint32_t timer, uint16_t channel_n) {
+    for (mp_uint_t i = 0; i < MP_STATE_PORT(pyb_timer_channel_obj_list).len; i++) {
+        pyb_timer_channel_obj_t *ch = ((pyb_timer_channel_obj_t *)(MP_STATE_PORT(pyb_timer_channel_obj_list).items[i]));
+        // any 32-bit timer must be matched by any of its 16-bit versions
+        if (ch->timer->timer == timer && ((ch->channel & TIMER_A) == channel_n || (ch->channel & TIMER_B) == channel_n)) {
+            return ch;
+        }
+    }
+    return MP_OBJ_NULL;
+}
+
+STATIC void pyb_timer_channel_remove (pyb_timer_channel_obj_t *ch) {
+    pyb_timer_channel_obj_t *channel;
+    if ((channel = pyb_timer_channel_find(ch->timer->timer, ch->channel))) {
+        mp_obj_list_remove(&MP_STATE_PORT(pyb_timer_channel_obj_list), channel);
+        // unregister it with the sleep module
+        pyb_sleep_remove((const mp_obj_t)channel);
+    }
+}
+
+STATIC void pyb_timer_channel_add (pyb_timer_channel_obj_t *ch) {
+    // remove it in case it already exists
+    pyb_timer_channel_remove(ch);
+    mp_obj_list_append(&MP_STATE_PORT(pyb_timer_channel_obj_list), ch);
+    // register it with the sleep module
+    pyb_sleep_add((const mp_obj_t)ch, (WakeUpCB_t)timer_channel_init);
+}
+
+STATIC void timer_disable (pyb_timer_obj_t *tim) {
+    // disable all timers and it's interrupts
+    MAP_TimerDisable(tim->timer, TIMER_A | TIMER_B);
+    MAP_TimerIntDisable(tim->timer, tim->irq_trigger);
+    MAP_TimerIntClear(tim->timer, tim->irq_trigger);
+    pyb_timer_channel_obj_t *ch;
+    // disable its channels
+    if ((ch = pyb_timer_channel_find (tim->timer, TIMER_A))) {
+        pyb_sleep_remove(ch);
+    }
+    if ((ch = pyb_timer_channel_find (tim->timer, TIMER_B))) {
+        pyb_sleep_remove(ch);
+    }
+    MAP_PRCMPeripheralClkDisable(tim->peripheral, PRCM_RUN_MODE_CLK | PRCM_SLP_MODE_CLK);
+}
+
+// computes prescaler period and match value so timer triggers at freq-Hz
+STATIC uint32_t compute_prescaler_period_and_match_value(pyb_timer_channel_obj_t *ch, uint32_t *period_out, uint32_t *match_out) {
+    uint32_t maxcount = (ch->channel == (TIMER_A | TIMER_B)) ? 0xFFFFFFFF : 0xFFFF;
+    uint32_t prescaler;
+    uint32_t period_c = (ch->frequency > 0) ? PYBTIMER_SRC_FREQ_HZ / ch->frequency : ((PYBTIMER_SRC_FREQ_HZ / 1000000) * ch->period);
+
+    period_c = MAX(1, period_c) - 1;
+    if (period_c == 0) {
+        goto error;
+    }
+
+    prescaler = period_c >> 16; // The prescaler is an extension of the timer counter
+    *period_out = period_c;
+
+    if (prescaler > 0xFF && maxcount == 0xFFFF) {
+        goto error;
+    }
+    // check limit values for the duty cycle
+    if (ch->duty_cycle == 0) {
+        *match_out = period_c - 1;
+    } else {
+        if (period_c > 0xFFFF) {
+            uint32_t match = (period_c * 100) / 10000;
+            *match_out = period_c - ((match * ch->duty_cycle) / 100);
+        } else {
+            *match_out = period_c - ((period_c * ch->duty_cycle) / 10000);
+        }
+    }
+    return prescaler;
+
+error:
+    nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
+}
+
+STATIC void timer_init (pyb_timer_obj_t *tim) {
+    MAP_PRCMPeripheralClkEnable(tim->peripheral, PRCM_RUN_MODE_CLK | PRCM_SLP_MODE_CLK);
+    MAP_PRCMPeripheralReset(tim->peripheral);
+    MAP_TimerConfigure(tim->timer, tim->config);
+}
+
+STATIC void timer_channel_init (pyb_timer_channel_obj_t *ch) {
+    // calculate the period, the prescaler and the match value
+    uint32_t period_c;
+    uint32_t match;
+    uint32_t prescaler = compute_prescaler_period_and_match_value(ch, &period_c, &match);
+
+    // set the prescaler
+    MAP_TimerPrescaleSet(ch->timer->timer, ch->channel, (prescaler < 0xFF) ? prescaler : 0);
+
+    // set the load value
+    MAP_TimerLoadSet(ch->timer->timer, ch->channel, period_c);
+
+    // configure the pwm if we are in such mode
+    if ((ch->timer->config & 0x0F) == TIMER_CFG_A_PWM) {
+        // invert the timer output if required
+        MAP_TimerControlLevel(ch->timer->timer, ch->channel, (ch->polarity == PYBTIMER_POLARITY_NEG) ? true : false);
+        // set the match value (which is simply the duty cycle translated to ticks)
+        MAP_TimerMatchSet(ch->timer->timer, ch->channel, match);
+        MAP_TimerPrescaleMatchSet(ch->timer->timer, ch->channel, match >> 16);
+    }
+
+#ifdef DEBUG
+    // stall the timer when the processor is halted while debugging
+    MAP_TimerControlStall(ch->timer->timer, ch->channel, true);
+#endif
+
+    // now enable the timer channel
+    MAP_TimerEnable(ch->timer->timer, ch->channel);
+}
+
+/******************************************************************************/
+/* Micro Python bindings                                                      */
+
+STATIC void pyb_timer_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    pyb_timer_obj_t *tim = self_in;
+    uint32_t mode = tim->config & 0xFF;
+
+    // timer mode
+    qstr mode_qst = MP_QSTR_PWM;
+    switch(mode) {
+    case TIMER_CFG_A_ONE_SHOT_UP:
+        mode_qst = MP_QSTR_ONE_SHOT;
+        break;
+    case TIMER_CFG_A_PERIODIC_UP:
+        mode_qst = MP_QSTR_PERIODIC;
+        break;
+    default:
+        break;
+    }
+    mp_printf(print, "Timer(%u, mode=Timer.%q)", tim->id, mode_qst);
+}
+
+STATIC mp_obj_t pyb_timer_init_helper(pyb_timer_obj_t *tim, mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_mode,         MP_ARG_REQUIRED | MP_ARG_INT, },
+        { MP_QSTR_width,        MP_ARG_KW_ONLY  | MP_ARG_INT, {.u_int = 16} },
+    };
+
+    // parse args
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    // check the mode
+    uint32_t _mode = args[0].u_int;
+    if (_mode != TIMER_CFG_A_ONE_SHOT_UP && _mode != TIMER_CFG_A_PERIODIC_UP && _mode != TIMER_CFG_A_PWM) {
+        goto error;
+    }
+
+    // check the width
+    if (args[1].u_int != 16 && args[1].u_int != 32) {
+        goto error;
+    }
+    bool is16bit = (args[1].u_int == 16);
+
+    if (!is16bit && _mode == TIMER_CFG_A_PWM) {
+        // 32-bit mode is only available when in free running modes
+        goto error;
+    }
+    tim->config = is16bit ? ((_mode | (_mode << 8)) | TIMER_CFG_SPLIT_PAIR) : _mode;
+
+    timer_init(tim);
+    // register it with the sleep module
+    pyb_sleep_add ((const mp_obj_t)tim, (WakeUpCB_t)timer_init);
+
+    return mp_const_none;
+
+error:
+    nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
+}
+
+STATIC mp_obj_t pyb_timer_make_new(const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
+    // check arguments
+    mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
+
+    // create a new Timer object
+    int32_t timer_idx = mp_obj_get_int(args[0]);
+    if (timer_idx < 0 || timer_idx > (PYBTIMER_NUM_TIMERS - 1)) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_resource_not_avaliable));
+    }
+
+    pyb_timer_obj_t *tim = &pyb_timer_obj[timer_idx];
+    tim->base.type = &pyb_timer_type;
+    tim->id = timer_idx;
+
+    if (n_args > 1 || n_kw > 0) {
+        // start the peripheral
+        mp_map_t kw_args;
+        mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
+        pyb_timer_init_helper(tim, n_args - 1, args + 1, &kw_args);
+    }
+    return (mp_obj_t)tim;
+}
+
+STATIC mp_obj_t pyb_timer_init(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
+    return pyb_timer_init_helper(args[0], n_args - 1, args + 1, kw_args);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_timer_init_obj, 1, pyb_timer_init);
+
+STATIC mp_obj_t pyb_timer_deinit(mp_obj_t self_in) {
+    pyb_timer_obj_t *self = self_in;
+    timer_disable(self);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_timer_deinit_obj, pyb_timer_deinit);
+
+STATIC mp_obj_t pyb_timer_channel(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_freq,                MP_ARG_KW_ONLY  | MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_period,              MP_ARG_KW_ONLY  | MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_polarity,            MP_ARG_KW_ONLY  | MP_ARG_INT, {.u_int = PYBTIMER_POLARITY_POS} },
+        { MP_QSTR_duty_cycle,          MP_ARG_KW_ONLY  | MP_ARG_INT, {.u_int = 0} },
+    };
+
+    pyb_timer_obj_t *tim = pos_args[0];
+    mp_int_t channel_n = mp_obj_get_int(pos_args[1]);
+
+    // verify that the timer has been already initialized
+    if (!tim->config) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_request_not_possible));
+    }
+    if (channel_n != TIMER_A && channel_n != TIMER_B && channel_n != (TIMER_A | TIMER_B)) {
+        // invalid channel
+        goto error;
+    }
+    if (channel_n == (TIMER_A | TIMER_B) && (tim->config & TIMER_CFG_SPLIT_PAIR)) {
+        // 32-bit channel selected when the timer is in 16-bit mode
+        goto error;
+    }
+
+    // if only the channel number is given return the previously
+    // allocated channel (or None if no previous channel)
+    if (n_args == 2 && kw_args->used == 0) {
+        pyb_timer_channel_obj_t *ch;
+        if ((ch = pyb_timer_channel_find(tim->timer, channel_n))) {
+            return ch;
+        }
+        return mp_const_none;
+    }
+
+    // parse the arguments
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 2, pos_args + 2, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+    // throw an exception if both frequency and period are given
+    if (args[0].u_int != 0 && args[1].u_int != 0) {
+        goto error;
+    }
+    // check that at least one of them has a valid value
+    if (args[0].u_int <= 0 && args[1].u_int <= 0) {
+        goto error;
+    }
+    // check that the polarity is not 'both' in pwm mode
+    if ((tim->config & TIMER_A) == TIMER_CFG_A_PWM && args[2].u_int == (PYBTIMER_POLARITY_POS | PYBTIMER_POLARITY_NEG)) {
+        goto error;
+    }
+
+    // allocate a new timer channel
+    pyb_timer_channel_obj_t *ch = m_new_obj(pyb_timer_channel_obj_t);
+    ch->base.type = &pyb_timer_channel_type;
+    ch->timer = tim;
+    ch->channel = channel_n;
+
+    // get the frequency the polarity and the duty cycle
+    ch->frequency = args[0].u_int;
+    ch->period = args[1].u_int;
+    ch->polarity = args[2].u_int;
+    ch->duty_cycle = MIN(10000, MAX(0, args[3].u_int));
+
+    timer_channel_init(ch);
+
+    // assign the pin
+    if ((ch->timer->config & 0x0F) == TIMER_CFG_A_PWM) {
+        uint32_t ch_idx = (ch->channel == TIMER_A) ? 0 : 1;
+        // use the default pin if available
+        mp_obj_t pin_o = (mp_obj_t)pyb_timer_pwm_pin[(ch->timer->id * 2) + ch_idx];
+        if (pin_o != MP_OBJ_NULL) {
+            pin_obj_t *pin = pin_find(pin_o);
+            pin_config (pin, pin_find_af_index(pin, PIN_FN_TIM, ch->timer->id, PIN_TYPE_TIM_PWM),
+                        0, PIN_TYPE_STD, -1, PIN_STRENGTH_4MA);
+        }
+    }
+
+    // add the timer to the list
+    pyb_timer_channel_add(ch);
+
+    return ch;
+
+error:
+    nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_timer_channel_obj, 2, pyb_timer_channel);
+
+STATIC const mp_map_elem_t pyb_timer_locals_dict_table[] = {
+    // instance methods
+    { MP_OBJ_NEW_QSTR(MP_QSTR_init),                    (mp_obj_t)&pyb_timer_init_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_deinit),                  (mp_obj_t)&pyb_timer_deinit_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_channel),                 (mp_obj_t)&pyb_timer_channel_obj },
+
+    // class constants
+    { MP_OBJ_NEW_QSTR(MP_QSTR_A),                       MP_OBJ_NEW_SMALL_INT(TIMER_A) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_B),                       MP_OBJ_NEW_SMALL_INT(TIMER_B) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_ONE_SHOT),                MP_OBJ_NEW_SMALL_INT(TIMER_CFG_A_ONE_SHOT_UP) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_PERIODIC),                MP_OBJ_NEW_SMALL_INT(TIMER_CFG_A_PERIODIC_UP) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_PWM),                     MP_OBJ_NEW_SMALL_INT(TIMER_CFG_A_PWM) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_POSITIVE),                MP_OBJ_NEW_SMALL_INT(PYBTIMER_POLARITY_POS) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_NEGATIVE),                MP_OBJ_NEW_SMALL_INT(PYBTIMER_POLARITY_NEG) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_TIMEOUT),                 MP_OBJ_NEW_SMALL_INT(PYBTIMER_TIMEOUT_TRIGGER) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_MATCH),                   MP_OBJ_NEW_SMALL_INT(PYBTIMER_MATCH_TRIGGER) },
+};
+STATIC MP_DEFINE_CONST_DICT(pyb_timer_locals_dict, pyb_timer_locals_dict_table);
+
+const mp_obj_type_t pyb_timer_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_Timer,
+    .print = pyb_timer_print,
+    .make_new = pyb_timer_make_new,
+    .locals_dict = (mp_obj_t)&pyb_timer_locals_dict,
+};
+
+STATIC const mp_irq_methods_t pyb_timer_channel_irq_methods = {
+    .init = pyb_timer_channel_irq,
+    .enable = pyb_timer_channel_irq_enable,
+    .disable = pyb_timer_channel_irq_disable,
+    .flags = pyb_timer_channel_irq_flags,
+};
+
+STATIC void TIMERGenericIntHandler(uint32_t timer, uint16_t channel) {
+    pyb_timer_channel_obj_t *self;
+    uint32_t status;
+    if ((self = pyb_timer_channel_find(timer, channel))) {
+        status = MAP_TimerIntStatus(self->timer->timer, true) & self->channel;
+        MAP_TimerIntClear(self->timer->timer, status);
+        mp_irq_handler(mp_irq_find(self));
+    }
+}
+
+STATIC void TIMER0AIntHandler(void) {
+    TIMERGenericIntHandler(TIMERA0_BASE, TIMER_A);
+}
+
+STATIC void TIMER0BIntHandler(void) {
+    TIMERGenericIntHandler(TIMERA0_BASE, TIMER_B);
+}
+
+STATIC void TIMER1AIntHandler(void) {
+    TIMERGenericIntHandler(TIMERA1_BASE, TIMER_A);
+}
+
+STATIC void TIMER1BIntHandler(void) {
+    TIMERGenericIntHandler(TIMERA1_BASE, TIMER_B);
+}
+
+STATIC void TIMER2AIntHandler(void) {
+    TIMERGenericIntHandler(TIMERA2_BASE, TIMER_A);
+}
+
+STATIC void TIMER2BIntHandler(void) {
+    TIMERGenericIntHandler(TIMERA2_BASE, TIMER_B);
+}
+
+STATIC void TIMER3AIntHandler(void) {
+    TIMERGenericIntHandler(TIMERA3_BASE, TIMER_A);
+}
+
+STATIC void TIMER3BIntHandler(void) {
+    TIMERGenericIntHandler(TIMERA3_BASE, TIMER_B);
+}
+
+STATIC void pyb_timer_channel_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
+    pyb_timer_channel_obj_t *ch = self_in;
+    char *ch_id = "AB";
+    // timer channel
+    if (ch->channel == TIMER_A) {
+        ch_id = "A";
+    } else if (ch->channel == TIMER_B) {
+        ch_id = "B";
+    }
+
+    mp_printf(print, "timer.channel(Timer.%s, %q=%u", ch_id, MP_QSTR_freq, ch->frequency);
+
+    uint32_t mode = ch->timer->config & 0xFF;
+    if (mode == TIMER_CFG_A_PWM) {
+        mp_printf(print, ", %q=Timer.", MP_QSTR_polarity);
+        switch (ch->polarity) {
+            case PYBTIMER_POLARITY_POS:
+                mp_printf(print, "POSITIVE");
+                break;
+            case PYBTIMER_POLARITY_NEG:
+                mp_printf(print, "NEGATIVE");
+                break;
+            default:
+                mp_printf(print, "BOTH");
+                break;
+        }
+        mp_printf(print, ", %q=%u.%02u", MP_QSTR_duty_cycle, ch->duty_cycle / 100, ch->duty_cycle % 100);
+    }
+    mp_printf(print, ")");
+}
+
+STATIC mp_obj_t pyb_timer_channel_freq(mp_uint_t n_args, const mp_obj_t *args) {
+    pyb_timer_channel_obj_t *ch = args[0];
+    if (n_args == 1) {
+        // get
+        return mp_obj_new_int(ch->frequency);
+    } else {
+        // set
+        int32_t _frequency = mp_obj_get_int(args[1]);
+        if (_frequency <= 0) {
+            nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
+        }
+        ch->frequency = _frequency;
+        ch->period = 1000000 / _frequency;
+        timer_channel_init(ch);
+        return mp_const_none;
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_timer_channel_freq_obj, 1, 2, pyb_timer_channel_freq);
+
+STATIC mp_obj_t pyb_timer_channel_period(mp_uint_t n_args, const mp_obj_t *args) {
+    pyb_timer_channel_obj_t *ch = args[0];
+    if (n_args == 1) {
+        // get
+        return mp_obj_new_int(ch->period);
+    } else {
+        // set
+        int32_t _period = mp_obj_get_int(args[1]);
+        if (_period <= 0) {
+            nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
+        }
+        ch->period = _period;
+        ch->frequency = 1000000 / _period;
+        timer_channel_init(ch);
+        return mp_const_none;
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_timer_channel_period_obj, 1, 2, pyb_timer_channel_period);
+
+STATIC mp_obj_t pyb_timer_channel_duty_cycle(mp_uint_t n_args, const mp_obj_t *args) {
+    pyb_timer_channel_obj_t *ch = args[0];
+    if (n_args == 1) {
+        // get
+        return mp_obj_new_int(ch->duty_cycle);
+    } else {
+        // duty cycle must be converted from percentage to ticks
+        // calculate the period, the prescaler and the match value
+        uint32_t period_c;
+        uint32_t match;
+        ch->duty_cycle = MIN(10000, MAX(0, mp_obj_get_int(args[1])));
+        compute_prescaler_period_and_match_value(ch, &period_c, &match);
+        if (n_args == 3) {
+            // set the new polarity if requested
+            ch->polarity = mp_obj_get_int(args[2]);
+            MAP_TimerControlLevel(ch->timer->timer, ch->channel, (ch->polarity == PYBTIMER_POLARITY_NEG) ? true : false);
+        }
+        MAP_TimerMatchSet(ch->timer->timer, ch->channel, match);
+        MAP_TimerPrescaleMatchSet(ch->timer->timer, ch->channel, match >> 16);
+        return mp_const_none;
+    }
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(pyb_timer_channel_duty_cycle_obj, 1, 3, pyb_timer_channel_duty_cycle);
+
+STATIC mp_obj_t pyb_timer_channel_irq (mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    mp_arg_val_t args[mp_irq_INIT_NUM_ARGS];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, mp_irq_INIT_NUM_ARGS, mp_irq_init_args, args);
+    pyb_timer_channel_obj_t *ch = pos_args[0];
+
+    // convert the priority to the correct value
+    uint priority = mp_irq_translate_priority (args[1].u_int);
+
+    // validate the power mode
+    uint8_t pwrmode = (args[3].u_obj == mp_const_none) ? PYB_PWR_MODE_ACTIVE : mp_obj_get_int(args[3].u_obj);
+    if (pwrmode != PYB_PWR_MODE_ACTIVE) {
+        goto invalid_args;
+    }
+
+    // get the trigger
+    uint trigger = mp_obj_get_int(args[0].u_obj);
+
+    // disable the callback first
+    pyb_timer_channel_irq_disable(ch);
+
+    uint8_t shift = (ch->channel == TIMER_B) ? 8 : 0;
+    uint32_t _config = (ch->channel == TIMER_B) ? ((ch->timer->config & TIMER_B) >> 8) : (ch->timer->config & TIMER_A);
+    switch (_config) {
+    case TIMER_CFG_A_ONE_SHOT_UP:
+    case TIMER_CFG_A_PERIODIC_UP:
+        ch->timer->irq_trigger |= TIMER_TIMA_TIMEOUT << shift;
+        if (trigger != PYBTIMER_TIMEOUT_TRIGGER) {
+            goto invalid_args;
+        }
+        break;
+    case TIMER_CFG_A_PWM:
+        // special case for the PWM match interrupt
+        ch->timer->irq_trigger |= ((ch->channel & TIMER_A) == TIMER_A) ? TIMER_TIMA_MATCH : TIMER_TIMB_MATCH;
+        if (trigger != PYBTIMER_MATCH_TRIGGER) {
+            goto invalid_args;
+        }
+        break;
+    default:
+        break;
+    }
+    // special case for a 32-bit timer
+    if (ch->channel == (TIMER_A | TIMER_B)) {
+       ch->timer->irq_trigger |= (ch->timer->irq_trigger << 8);
+    }
+
+    void (*pfnHandler)(void);
+    uint32_t intregister;
+    switch (ch->timer->timer) {
+    case TIMERA0_BASE:
+        if (ch->channel == TIMER_B) {
+            pfnHandler = &TIMER0BIntHandler;
+            intregister = INT_TIMERA0B;
+        } else {
+            pfnHandler = &TIMER0AIntHandler;
+            intregister = INT_TIMERA0A;
+        }
+        break;
+    case TIMERA1_BASE:
+        if (ch->channel == TIMER_B) {
+            pfnHandler = &TIMER1BIntHandler;
+            intregister = INT_TIMERA1B;
+        } else {
+            pfnHandler = &TIMER1AIntHandler;
+            intregister = INT_TIMERA1A;
+        }
+        break;
+    case TIMERA2_BASE:
+        if (ch->channel == TIMER_B) {
+            pfnHandler = &TIMER2BIntHandler;
+            intregister = INT_TIMERA2B;
+        } else {
+            pfnHandler = &TIMER2AIntHandler;
+            intregister = INT_TIMERA2A;
+        }
+        break;
+    default:
+        if (ch->channel == TIMER_B) {
+            pfnHandler = &TIMER3BIntHandler;
+            intregister = INT_TIMERA3B;
+        } else {
+            pfnHandler = &TIMER3AIntHandler;
+            intregister = INT_TIMERA3A;
+        }
+        break;
+    }
+
+    // register the interrupt and configure the priority
+    MAP_IntPrioritySet(intregister, priority);
+    MAP_TimerIntRegister(ch->timer->timer, ch->channel, pfnHandler);
+
+    // create the callback
+    mp_obj_t _irq = mp_irq_new (ch, args[2].u_obj, &pyb_timer_channel_irq_methods);
+
+    // enable the callback before returning
+    pyb_timer_channel_irq_enable(ch);
+
+    return _irq;
+
+invalid_args:
+    nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_timer_channel_irq_obj, 1, pyb_timer_channel_irq);
+
+STATIC const mp_map_elem_t pyb_timer_channel_locals_dict_table[] = {
+    // instance methods
+    { MP_OBJ_NEW_QSTR(MP_QSTR_freq),                 (mp_obj_t)&pyb_timer_channel_freq_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_period),               (mp_obj_t)&pyb_timer_channel_period_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_duty_cycle),           (mp_obj_t)&pyb_timer_channel_duty_cycle_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_irq),                  (mp_obj_t)&pyb_timer_channel_irq_obj },
+};
+STATIC MP_DEFINE_CONST_DICT(pyb_timer_channel_locals_dict, pyb_timer_channel_locals_dict_table);
+
+STATIC const mp_obj_type_t pyb_timer_channel_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_TimerChannel,
+    .print = pyb_timer_channel_print,
+    .locals_dict = (mp_obj_t)&pyb_timer_channel_locals_dict,
+};
+
--- a/cc3200/mods/pybtimer.h
+++ b/cc3200/mods/pybtimer.h
@@ -3,6 +3,7 @@
 *
 * The MIT License (MIT)
 *
+ * Copyright (c) 2013, 2014 Damien P. George
 * Copyright (c) 2015 Daniel Campora
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -24,15 +25,13 @@
 * THE SOFTWARE.
 */

-#ifndef HASH_H_
-#define HASH_H_
+/******************************************************************************
+ DECLARE EXPORTED DATA
+ ******************************************************************************/
+extern const mp_obj_type_t pyb_timer_type;

 /******************************************************************************
 DECLARE PUBLIC FUNCTIONS
 ******************************************************************************/
-extern void HASH_Init (void);
-extern void HASH_SHAMD5Start (uint32_t algo, uint32_t blocklen);
-extern void HASH_SHAMD5Update (uint8_t *data, uint32_t datalen);
-extern void HASH_SHAMD5Read (uint8_t *hash);
+void timer_init0 (void);

-#endif /* HASH_H_ */
--- a/cc3200/mods/pybuart.c
+++ b/cc3200/mods/pybuart.c
@@ -31,11 +31,11 @@
 #include <string.h>

 #include "py/mpconfig.h"
-#include MICROPY_HAL_H
 #include "py/obj.h"
 #include "py/runtime.h"
 #include "py/objlist.h"
 #include "py/stream.h"
+#include "py/mphal.h"
 #include "inc/hw_types.h"
 #include "inc/hw_ints.h"
 #include "inc/hw_memmap.h"
@@ -45,62 +45,51 @@
 #include "prcm.h"
 #include "uart.h"
 #include "pybuart.h"
+#include "mpirq.h"
 #include "pybioctl.h"
 #include "pybsleep.h"
-#include "mpcallback.h"
 #include "mpexception.h"
 #include "py/mpstate.h"
 #include "osi.h"
+#include "utils.h"
+#include "pin.h"
+#include "pybpin.h"
+#include "pins.h"
+#include "moduos.h"

 /// \moduleref pyb
 /// \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.
-///
-/// UART objects can be created and initialised using:
-///
-///     from pyb import UART
-///
-///     uart = UART(0, 9600)                         # init with given baudrate
-///     uart.init(9600, bits=8, stop=1, parity=None) # init with given parameters
-///
-/// Bits can be 5, 6, 7, 8, parity can be None, 0 (even), 1 (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
-///
-/// 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

 /******************************************************************************
 DEFINE CONSTANTS
- ******************************************************************************/
-#define PYBUART_TX_WAIT_MS                  1
-#define PYBUART_TX_MAX_TIMEOUT_MS           5
+ *******-***********************************************************************/
+#define PYBUART_FRAME_TIME_US(baud)             ((11 * 1000000) / baud)
+#define PYBUART_2_FRAMES_TIME_US(baud)          (PYBUART_FRAME_TIME_US(baud) * 2)
+#define PYBUART_RX_TIMEOUT_US(baud)             (PYBUART_2_FRAMES_TIME_US(baud) * 8) // we need at least characters in the FIFO
+
+#define PYBUART_TX_WAIT_US(baud)                ((PYBUART_FRAME_TIME_US(baud)) + 1)
+#define PYBUART_TX_MAX_TIMEOUT_MS               (5)
+
+#define PYBUART_RX_BUFFER_LEN                   (256)
+
+// interrupt triggers
+#define UART_TRIGGER_RX_ANY                     (0x01)
+#define UART_TRIGGER_RX_HALF                    (0x02)
+#define UART_TRIGGER_RX_FULL                    (0x04)
+#define UART_TRIGGER_TX_DONE                    (0x08)

 /******************************************************************************
 DECLARE PRIVATE FUNCTIONS
 ******************************************************************************/
 STATIC void uart_init (pyb_uart_obj_t *self);
-STATIC bool uart_rx_wait (pyb_uart_obj_t *self, uint32_t timeout);
+STATIC bool uart_rx_wait (pyb_uart_obj_t *self);
+STATIC void uart_check_init(pyb_uart_obj_t *self);
+STATIC mp_obj_t uart_irq_new (pyb_uart_obj_t *self, byte trigger, mp_int_t priority, mp_obj_t handler);
 STATIC void UARTGenericIntHandler(uint32_t uart_id);
 STATIC void UART0IntHandler(void);
 STATIC void UART1IntHandler(void);
-STATIC void uart_callback_enable (mp_obj_t self_in);
-STATIC void uart_callback_disable (mp_obj_t self_in);
+STATIC void uart_irq_enable (mp_obj_t self_in);
+STATIC void uart_irq_disable (mp_obj_t self_in);

 /******************************************************************************
 DEFINE PRIVATE TYPES
@@ -113,35 +102,46 @@ struct _pyb_uart_obj_t {
    uint config;
    uint flowcontrol;
    byte *read_buf;                     // read buffer pointer
-    uint16_t timeout;                   // timeout waiting for first char
-    uint16_t timeout_char;              // timeout waiting between chars
-    uint16_t read_buf_len;              // len in chars; buf can hold len-1 chars
    volatile uint16_t read_buf_head;    // indexes first empty slot
    uint16_t read_buf_tail;             // indexes first full slot (not full if equals head)
    byte peripheral;
+    byte irq_trigger;
+    bool irq_enabled;
+    byte irq_flags;
 };

 /******************************************************************************
 DECLARE PRIVATE DATA
 ******************************************************************************/
-STATIC pyb_uart_obj_t pyb_uart_obj[PYB_NUM_UARTS];
-STATIC const mp_cb_methods_t uart_cb_methods;
+STATIC pyb_uart_obj_t pyb_uart_obj[PYB_NUM_UARTS] = { {.reg = UARTA0_BASE, .baudrate = 0, .read_buf = NULL, .peripheral = PRCM_UARTA0},
+                                                      {.reg = UARTA1_BASE, .baudrate = 0, .read_buf = NULL, .peripheral = PRCM_UARTA1} };
+STATIC const mp_irq_methods_t uart_irq_methods;
+
+STATIC const mp_obj_t pyb_uart_def_pin[PYB_NUM_UARTS][2] = { {&pin_GP1, &pin_GP2}, {&pin_GP3, &pin_GP4} };

 /******************************************************************************
 DEFINE PUBLIC FUNCTIONS
 ******************************************************************************/
 void uart_init0 (void) {
+    // save references of the UART objects, to prevent the read buffers from being trashed by the gc
+    MP_STATE_PORT(pyb_uart_objs)[0] = &pyb_uart_obj[0];
+    MP_STATE_PORT(pyb_uart_objs)[1] = &pyb_uart_obj[1];
 }

-bool uart_rx_any(pyb_uart_obj_t *self) {
-    return (self->read_buf_tail != self->read_buf_head || MAP_UARTCharsAvail(self->reg));
+uint32_t uart_rx_any(pyb_uart_obj_t *self) {
+    if (self->read_buf_tail != self->read_buf_head) {
+        // buffering  via irq
+        return (self->read_buf_head > self->read_buf_tail) ? self->read_buf_head - self->read_buf_tail :
+                PYBUART_RX_BUFFER_LEN - self->read_buf_tail + self->read_buf_head;
+    }
+    return MAP_UARTCharsAvail(self->reg) ? 1 : 0;
 }

 int uart_rx_char(pyb_uart_obj_t *self) {
    if (self->read_buf_tail != self->read_buf_head) {
-        // buffering via IRQ
+        // buffering via irq
        int data = self->read_buf[self->read_buf_tail];
-        self->read_buf_tail = (self->read_buf_tail + 1) % self->read_buf_len;
+        self->read_buf_tail = (self->read_buf_tail + 1) % PYBUART_RX_BUFFER_LEN;
        return data;
    } else {
        // no buffering
@@ -151,12 +151,11 @@ int uart_rx_char(pyb_uart_obj_t *self) {

 bool uart_tx_char(pyb_uart_obj_t *self, int c) {
    uint32_t timeout = 0;
-
    while (!MAP_UARTCharPutNonBlocking(self->reg, c)) {
-        if (timeout++ > (PYBUART_TX_MAX_TIMEOUT_MS / PYBUART_TX_WAIT_MS)) {
+        if (timeout++ > ((PYBUART_TX_MAX_TIMEOUT_MS * 1000) / PYBUART_TX_WAIT_US(self->baudrate))) {
            return false;
        }
-        HAL_Delay (PYBUART_TX_WAIT_MS);
+        UtilsDelay(UTILS_DELAY_US_TO_COUNT(PYBUART_TX_WAIT_US(self->baudrate)));
    }
    return true;
 }
@@ -170,64 +169,23 @@ bool uart_tx_strn(pyb_uart_obj_t *self, const char *str, uint len) {
    return true;
 }

-void uart_tx_strn_cooked(pyb_uart_obj_t *self, const char *str, uint len) {
-    for (const char *top = str + len; str < top; str++) {
-        if (*str == '\n') {
-            uart_tx_char(self, '\r');
-        }
-        uart_tx_char(self, *str);
-    }
-}
-
-mp_obj_t uart_callback_new (pyb_uart_obj_t *self, mp_obj_t handler, uint rxbuffer_size, mp_int_t priority) {
-    // disable the uart interrupts before updating anything
-    uart_callback_disable (self);
-
-    if (self->uart_id == PYB_UART_0) {
-        MAP_IntPrioritySet(INT_UARTA0, priority);
-        MAP_UARTIntRegister(self->reg, UART0IntHandler);
-    }
-    else {
-        MAP_IntPrioritySet(INT_UARTA1, priority);
-        MAP_UARTIntRegister(self->reg, UART1IntHandler);
-    }
-
-    // check the rx buffer size
-    if (rxbuffer_size > 0) {
-        // allocate the read buffer
-        self->read_buf_len = rxbuffer_size;
-        self->read_buf = m_new(byte, rxbuffer_size);
-    }
-
-    // create the callback
-    mp_obj_t _callback = mpcallback_new ((mp_obj_t)self, handler, &uart_cb_methods);
-
-    // enable the interrupts now
-    uart_callback_enable (self);
-
-    return _callback;
-}
-
 /******************************************************************************
 DEFINE PRIVATE FUNCTIONS
 ******************************************************************************/
 // assumes init parameters have been set up correctly
 STATIC void uart_init (pyb_uart_obj_t *self) {
-    if (self->uart_id == PYB_UART_0) {
-        self->reg = UARTA0_BASE;
-        self->peripheral = PRCM_UARTA0;
-    }
-    else {
-        self->reg = UARTA1_BASE;
-        self->peripheral = PRCM_UARTA1;
-    }
-
    // Enable the peripheral clock
    MAP_PRCMPeripheralClkEnable(self->peripheral, PRCM_RUN_MODE_CLK | PRCM_SLP_MODE_CLK);

    // Reset the uart
    MAP_PRCMPeripheralReset(self->peripheral);

+    // re-allocate the read buffer after resetting the uart (which automatically disables any irqs)
+    self->read_buf_head = 0;
+    self->read_buf_tail = 0;
+    self->read_buf = MP_OBJ_NULL; // free the read buffer before allocating again
+    self->read_buf = m_new(byte, PYBUART_RX_BUFFER_LEN);
+
    // Initialize the UART
    MAP_UARTConfigSetExpClk(self->reg, MAP_PRCMPeripheralClockGet(self->peripheral),
                            self->baudrate, self->config);
@@ -242,16 +200,17 @@ STATIC void uart_init (pyb_uart_obj_t *self) {
    UARTFlowControlSet(self->reg, self->flowcontrol);
 }

-// Waits at most timeout milliseconds for at least 1 char to become ready for
+// Waits at most timeout microseconds for at least 1 char to become ready for
 // reading (from buf or for direct reading).
 // Returns true if something available, false if not.
-STATIC bool uart_rx_wait (pyb_uart_obj_t *self, uint32_t timeout) {
+STATIC bool uart_rx_wait (pyb_uart_obj_t *self) {
+    int timeout = PYBUART_RX_TIMEOUT_US(self->baudrate);
    for ( ; ; ) {
        if (uart_rx_any(self)) {
-            return true; // have at least 1 char ready for reading
+            return true; // we have at least 1 char ready for reading
        }
        if (timeout > 0) {
-            HAL_Delay (1);
+            UtilsDelay(UTILS_DELAY_US_TO_COUNT(1));
            timeout--;
        }
        else {
@@ -260,6 +219,27 @@ STATIC bool uart_rx_wait (pyb_uart_obj_t *self, uint32_t timeout) {
    }
 }

+STATIC mp_obj_t uart_irq_new (pyb_uart_obj_t *self, byte trigger, mp_int_t priority, mp_obj_t handler) {
+    // disable the uart interrupts before updating anything
+    uart_irq_disable (self);
+
+    if (self->uart_id == PYB_UART_0) {
+        MAP_IntPrioritySet(INT_UARTA0, priority);
+        MAP_UARTIntRegister(self->reg, UART0IntHandler);
+    } else {
+        MAP_IntPrioritySet(INT_UARTA1, priority);
+        MAP_UARTIntRegister(self->reg, UART1IntHandler);
+    }
+
+    // create the callback
+    mp_obj_t _irq = mp_irq_new ((mp_obj_t)self, handler, &uart_irq_methods);
+
+    // enable the interrupts now
+    self->irq_trigger = trigger;
+    uart_irq_enable (self);
+    return _irq;
+}
+
 STATIC void UARTGenericIntHandler(uint32_t uart_id) {
    pyb_uart_obj_t *self;
    uint32_t status;
@@ -268,15 +248,16 @@ STATIC void UARTGenericIntHandler(uint32_t uart_id) {
    status = MAP_UARTIntStatus(self->reg, true);
    // receive interrupt
    if (status & (UART_INT_RX | UART_INT_RT)) {
+        // set the flags
+        self->irq_flags = UART_TRIGGER_RX_ANY;
        MAP_UARTIntClear(self->reg, UART_INT_RX | UART_INT_RT);
        while (UARTCharsAvail(self->reg)) {
            int data = MAP_UARTCharGetNonBlocking(self->reg);
-            if (pyb_stdio_uart == self && data == user_interrupt_char) {
+            if (MP_STATE_PORT(os_term_dup_obj) && MP_STATE_PORT(os_term_dup_obj)->stream_o == self && data == user_interrupt_char) {
                // raise an exception when interrupts are finished
                mpexception_keyboard_nlr_jump();
-            }
-            else if (self->read_buf_len != 0) {
-                uint16_t next_head = (self->read_buf_head + 1) % self->read_buf_len;
+            } else { // there's always a read buffer available
+                uint16_t next_head = (self->read_buf_head + 1) % PYBUART_RX_BUFFER_LEN;
                if (next_head != self->read_buf_tail) {
                    // only store data if room in buf
                    self->read_buf[self->read_buf_head] = data;
@@ -284,9 +265,22 @@ STATIC void UARTGenericIntHandler(uint32_t uart_id) {
                }
            }
        }
+    }
+
+    // check the flags to see if the user handler should be called
+    if ((self->irq_trigger & self->irq_flags) && self->irq_enabled) {
        // call the user defined handler
-        mp_obj_t _callback = mpcallback_find(self);
-        mpcallback_handler(_callback);
+        mp_irq_handler(mp_irq_find(self));
+    }
+
+    // clear the flags
+    self->irq_flags = 0;
+}
+
+STATIC void uart_check_init(pyb_uart_obj_t *self) {
+    // not initialized
+    if (!self->baudrate) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_request_not_possible));
    }
 }

@@ -298,15 +292,24 @@ STATIC void UART1IntHandler(void) {
    UARTGenericIntHandler(1);
 }

-STATIC void uart_callback_enable (mp_obj_t self_in) {
+STATIC void uart_irq_enable (mp_obj_t self_in) {
    pyb_uart_obj_t *self = self_in;
-    MAP_UARTIntClear(self->reg, UART_INT_RX | UART_INT_RT);
-    MAP_UARTIntEnable(self->reg, UART_INT_RX | UART_INT_RT);
+    // check for any of the rx interrupt types
+    if (self->irq_trigger & (UART_TRIGGER_RX_ANY | UART_TRIGGER_RX_HALF | UART_TRIGGER_RX_FULL)) {
+        MAP_UARTIntClear(self->reg, UART_INT_RX | UART_INT_RT);
+        MAP_UARTIntEnable(self->reg, UART_INT_RX | UART_INT_RT);
+    }
+    self->irq_enabled = true;
 }

-STATIC void uart_callback_disable (mp_obj_t self_in) {
+STATIC void uart_irq_disable (mp_obj_t self_in) {
    pyb_uart_obj_t *self = self_in;
-    MAP_UARTIntDisable(self->reg, UART_INT_RX | UART_INT_RT);
+    self->irq_enabled = false;
+}
+
+STATIC int uart_irq_flags (mp_obj_t self_in) {
+    pyb_uart_obj_t *self = self_in;
+    return self->irq_flags;
 }

 /******************************************************************************/
@@ -315,7 +318,7 @@ STATIC void uart_callback_disable (mp_obj_t self_in) {
 STATIC void pyb_uart_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
    pyb_uart_obj_t *self = self_in;
    if (self->baudrate > 0) {
-        mp_printf(print, "<UART%u, baudrate=%u, bits=", self->uart_id, self->baudrate);
+        mp_printf(print, "UART(%u, baudrate=%u, bits=", self->uart_id, self->baudrate);
        switch (self->config & UART_CONFIG_WLEN_MASK) {
        case UART_CONFIG_WLEN_5:
            mp_print_str(print, "5");
@@ -335,121 +338,140 @@ STATIC void pyb_uart_print(const mp_print_t *print, mp_obj_t self_in, mp_print_k
        if ((self->config & UART_CONFIG_PAR_MASK) == UART_CONFIG_PAR_NONE) {
            mp_print_str(print, ", parity=None");
        } else {
-            mp_printf(print, ", parity=%u", (self->config & UART_CONFIG_PAR_MASK) == UART_CONFIG_PAR_EVEN ? 0 : 1);
+            mp_printf(print, ", parity=UART.%q", (self->config & UART_CONFIG_PAR_MASK) == UART_CONFIG_PAR_EVEN ? MP_QSTR_EVEN : MP_QSTR_ODD);
        }
-        mp_printf(print, ", stop=%u, timeout=%u, timeout_char=%u, read_buf_len=%u>",
-              (self->config & UART_CONFIG_STOP_MASK) == UART_CONFIG_STOP_ONE ? 1 : 2,
-               self->timeout, self->timeout_char, self->read_buf_len);
+        mp_printf(print, ", stop=%u)", (self->config & UART_CONFIG_STOP_MASK) == UART_CONFIG_STOP_ONE ? 1 : 2);
    }
    else {
-        mp_printf(print, "<UART%u>", self->uart_id);
+        mp_printf(print, "UART(%u)", self->uart_id);
    }
 }

-/// \method init(baudrate, bits=8, parity=None, stop=1, *, timeout=1000, timeout_char=0)
-///
-/// Initialise the UART bus with the given parameters:
-///
-///   - `baudrate` is the clock rate.
-///   - `bits` is the number of bits per byte, 7, 8 or 9.
-///   - `parity` is the parity, `None`, 0 (even) or 1 (odd).
-///   - `stop` is the number of stop bits, 1 or 2.
-///   - `flowcontrol` is the flow control mode, `None`, `UART.FLOW_TX`, 
-///     `UART.FLOW_RX', 'UART.FLOW_TXRX`.
-///   - `timeout` is the timeout (in milliseconds) when waiting for the first character.
-///   - `timeout_char` is the timeout (in milliseconds) between characters.
-STATIC const mp_arg_t pyb_uart_init_args[] = {
-    { MP_QSTR_baudrate,     MP_ARG_REQUIRED | MP_ARG_INT,  },
-    { MP_QSTR_bits,         MP_ARG_KW_ONLY  | MP_ARG_INT,  {.u_int = 8} },
-    { MP_QSTR_parity,       MP_ARG_KW_ONLY  | MP_ARG_OBJ,  {.u_obj = mp_const_none} },
-    { MP_QSTR_stop,         MP_ARG_KW_ONLY  | MP_ARG_INT,  {.u_int = 1} },
-    { MP_QSTR_flow,         MP_ARG_KW_ONLY  | MP_ARG_OBJ,  {.u_int = UART_FLOWCONTROL_NONE} },
-    { MP_QSTR_timeout,      MP_ARG_KW_ONLY  | MP_ARG_INT,  {.u_int = 1000} },
-    { MP_QSTR_timeout_char, MP_ARG_KW_ONLY  | MP_ARG_INT,  {.u_int = 1} },
-};
-
-STATIC mp_obj_t pyb_uart_init_helper(pyb_uart_obj_t *self, mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    // parse args
-    mp_arg_val_t args[MP_ARRAY_SIZE(pyb_uart_init_args)];
-    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(pyb_uart_init_args), pyb_uart_init_args, args);
-
-    // set timeouts
-    self->timeout = args[5].u_int;
-    self->timeout_char = args[6].u_int;
-
-    // no read buffer for the moment
-    self->read_buf_head = 0;
-    self->read_buf_tail = 0;
-    self->read_buf_len = 0;
-    self->read_buf = NULL;
-
+STATIC mp_obj_t pyb_uart_init_helper(pyb_uart_obj_t *self, const mp_arg_val_t *args) {
    // get the baudrate
-    self->baudrate = args[0].u_int;
+    if (args[0].u_int <= 0) {
+        goto error;
+    }
+    uint baudrate = args[0].u_int;
+    uint config;
+    switch (args[1].u_int) {
+    case 5:
+        config = UART_CONFIG_WLEN_5;
+        break;
+    case 6:
+        config = UART_CONFIG_WLEN_6;
+        break;
+    case 7:
+        config = UART_CONFIG_WLEN_7;
+        break;
+    case 8:
+        config = UART_CONFIG_WLEN_8;
+        break;
+    default:
+        goto error;
+        break;
+    }
+    // parity
+    if (args[2].u_obj == mp_const_none) {
+        config |= UART_CONFIG_PAR_NONE;
+    } else {
+        uint parity = mp_obj_get_int(args[2].u_obj);
+        if (parity != UART_CONFIG_PAR_ODD && parity != UART_CONFIG_PAR_EVEN) {
+            goto error;
+        }
+        config |= parity;
+    }
+    // stop bits
+    config |= (args[3].u_int == 1 ? UART_CONFIG_STOP_ONE : UART_CONFIG_STOP_TWO);

-    // set the UART configuration values
-    if (n_args > 1) {
-        switch (args[1].u_int) {
-        case 5:
-            self->config = UART_CONFIG_WLEN_5;
-            break;
-        case 6:
-            self->config = UART_CONFIG_WLEN_6;
-            break;
-        case 7:
-            self->config = UART_CONFIG_WLEN_7;
-            break;
-        case 8:
-            self->config = UART_CONFIG_WLEN_8;
-            break;
-        default:
-            nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
-            break;
-        }
-        // Parity
-        if (args[2].u_obj == mp_const_none) {
-            self->config |= UART_CONFIG_PAR_NONE;
+    // assign the pins
+    mp_obj_t pins_o = args[4].u_obj;
+    uint flowcontrol = UART_FLOWCONTROL_NONE;
+    if (pins_o != mp_const_none) {
+        mp_obj_t *pins;
+        mp_uint_t n_pins = 2;
+        if (pins_o == MP_OBJ_NULL) {
+            // use the default pins
+            pins = (mp_obj_t *)pyb_uart_def_pin[self->uart_id];
        } else {
-            self->config |= ((mp_obj_get_int(args[2].u_obj) & 1) ? UART_CONFIG_PAR_ODD : UART_CONFIG_PAR_EVEN);
+            mp_obj_get_array(pins_o, &n_pins, &pins);
+            if (n_pins != 2 && n_pins != 4) {
+                goto error;
+            }
+            if (n_pins == 4) {
+                if (pins[PIN_TYPE_UART_RTS] != mp_const_none && pins[PIN_TYPE_UART_RX] == mp_const_none) {
+                    goto error;  // RTS pin given in TX only mode
+                } else if (pins[PIN_TYPE_UART_CTS] != mp_const_none && pins[PIN_TYPE_UART_TX] == mp_const_none) {
+                    goto error;  // CTS pin given in RX only mode
+                } else {
+                    if (pins[PIN_TYPE_UART_RTS] != mp_const_none) {
+                        flowcontrol |= UART_FLOWCONTROL_RX;
+                    }
+                    if (pins[PIN_TYPE_UART_CTS] != mp_const_none) {
+                        flowcontrol |= UART_FLOWCONTROL_TX;
+                    }
+                }
+            }
        }
-        // Stop bits
-        self->config |= (args[3].u_int == 1 ? UART_CONFIG_STOP_ONE : UART_CONFIG_STOP_TWO);
-        // Flow control
-        self->flowcontrol = args[4].u_int;
-    }
-    else {
-        self->config = UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE;
-        self->flowcontrol = UART_FLOWCONTROL_NONE;
+        pin_assign_pins_af (pins, n_pins, PIN_TYPE_STD_PU, PIN_FN_UART, self->uart_id);
    }

+    self->baudrate = baudrate;
+    self->config = config;
+    self->flowcontrol = flowcontrol;
+
    // initialize and enable the uart
    uart_init (self);
    // register it with the sleep module
-    pybsleep_add ((const mp_obj_t)self, (WakeUpCB_t)uart_init);
+    pyb_sleep_add ((const mp_obj_t)self, (WakeUpCB_t)uart_init);
+    // enable the callback
+    uart_irq_new (self, UART_TRIGGER_RX_ANY, INT_PRIORITY_LVL_3, mp_const_none);
+    // disable the irq (from the user point of view)
+    uart_irq_disable(self);

    return mp_const_none;
+
+error:
+    nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
 }

-/// \classmethod \constructor(bus, ...)
-///
-/// Construct a UART object on the given bus id.  `bus id` can be 0 or 1
-/// With no additional parameters, the UART object is created but not
-/// initialised (it has the settings from the last initialisation of
-/// the bus, if any).
-/// When only the baud rate is given the UART object is created and
-/// initialized with the default configuration of: 8 bit transfers,
-/// 1 stop bit, no parity and flow control disabled.
-/// See `init` for parameters of initialisation.
-/// If extra arguments are given, the bus is initialised with these arguments
-/// See `init` for parameters of initialisation.
-///
-STATIC mp_obj_t pyb_uart_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
-    // check arguments
-    mp_arg_check_num(n_args, n_kw, 1, MP_ARRAY_SIZE(pyb_uart_init_args), true);
+STATIC const mp_arg_t pyb_uart_init_args[] = {
+    { MP_QSTR_id,                             MP_ARG_OBJ,  {.u_obj = MP_OBJ_NULL} },
+    { MP_QSTR_baudrate,                       MP_ARG_INT,  {.u_int = 9600} },
+    { MP_QSTR_bits,                           MP_ARG_INT,  {.u_int = 8} },
+    { MP_QSTR_parity,                         MP_ARG_OBJ,  {.u_obj = mp_const_none} },
+    { MP_QSTR_stop,                           MP_ARG_INT,  {.u_int = 1} },
+    { MP_QSTR_pins,         MP_ARG_KW_ONLY  | MP_ARG_OBJ,  {.u_obj = MP_OBJ_NULL} },
+};
+STATIC mp_obj_t pyb_uart_make_new(const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
+    // parse args
+    mp_map_t kw_args;
+    mp_map_init_fixed_table(&kw_args, n_kw, all_args + n_args);
+    mp_arg_val_t args[MP_ARRAY_SIZE(pyb_uart_init_args)];
+    mp_arg_parse_all(n_args, all_args, &kw_args, MP_ARRAY_SIZE(args), pyb_uart_init_args, args);

    // work out the uart id
-    pyb_uart_id_t uart_id = mp_obj_get_int(args[0]);
+    uint uart_id;
+    if (args[0].u_obj == MP_OBJ_NULL) {
+        if (args[5].u_obj != MP_OBJ_NULL) {
+            mp_obj_t *pins;
+            mp_uint_t n_pins = 2;
+            mp_obj_get_array(args[5].u_obj, &n_pins, &pins);
+            // check the Tx pin (or the Rx if Tx is None)
+            if (pins[0] == mp_const_none) {
+                uart_id = pin_find_peripheral_unit(pins[1], PIN_FN_UART, PIN_TYPE_UART_RX);
+            } else {
+                uart_id = pin_find_peripheral_unit(pins[0], PIN_FN_UART, PIN_TYPE_UART_TX);
+            }
+        } else {
+            // default id
+            uart_id = 0;
+        }
+    } else {
+        uart_id = mp_obj_get_int(args[0].u_obj);
+    }

-    if (uart_id < PYB_UART_0 || uart_id > PYB_UART_1) {
+    if (uart_id > PYB_UART_1) {
        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_resource_not_avaliable));
    }

@@ -457,30 +479,30 @@ STATIC mp_obj_t pyb_uart_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t
    pyb_uart_obj_t *self = &pyb_uart_obj[uart_id];
    self->base.type = &pyb_uart_type;
    self->uart_id = uart_id;
-    if (n_args > 1 || n_kw > 0) {
-        // start the peripheral
-        mp_map_t kw_args;
-        mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
-        pyb_uart_init_helper(self, n_args - 1, args + 1, &kw_args);
-    }
+
+    // start the peripheral
+    pyb_uart_init_helper(self, &args[1]);

    return self;
 }

-STATIC mp_obj_t pyb_uart_init(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
-    return pyb_uart_init_helper(args[0], n_args - 1, args + 1, kw_args);
+STATIC mp_obj_t pyb_uart_init(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    // parse args
+    mp_arg_val_t args[MP_ARRAY_SIZE(pyb_uart_init_args) - 1];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(args), &pyb_uart_init_args[1], args);
+    return pyb_uart_init_helper(pos_args[0], args);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_uart_init_obj, 1, pyb_uart_init);

-/// \method deinit()
-/// Turn off the UART bus.
-mp_obj_t pyb_uart_deinit(mp_obj_t self_in) {
+STATIC mp_obj_t pyb_uart_deinit(mp_obj_t self_in) {
    pyb_uart_obj_t *self = self_in;

    // unregister it with the sleep module
-    pybsleep_remove (self);
+    pyb_sleep_remove (self);
    // invalidate the baudrate
    self->baudrate = 0;
+    // free the read buffer
+    m_del(byte, self->read_buf, PYBUART_RX_BUFFER_LEN);
    MAP_UARTIntDisable(self->reg, UART_INT_RX | UART_INT_RT);
    MAP_UARTDisable(self->reg);
    MAP_PRCMPeripheralClkDisable(self->peripheral, PRCM_RUN_MODE_CLK | PRCM_SLP_MODE_CLK);
@@ -488,83 +510,63 @@ mp_obj_t pyb_uart_deinit(mp_obj_t self_in) {
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_uart_deinit_obj, pyb_uart_deinit);

-/// \method any()
-/// Return `True` if any characters waiting, else `False`.
 STATIC mp_obj_t pyb_uart_any(mp_obj_t self_in) {
    pyb_uart_obj_t *self = self_in;
-    if (uart_rx_any(self)) {
-        return mp_const_true;
-    } else {
-        return mp_const_false;
-    }
+    uart_check_init(self);
+    return mp_obj_new_int(uart_rx_any(self));
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_uart_any_obj, pyb_uart_any);

-/// \method callback(handler, value, priority)
-/// Creates a callback object associated with the uart
-/// min num of arguments is 1 (value). The value is the size of the rx buffer
-STATIC mp_obj_t pyb_uart_callback (mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
-    mp_arg_val_t args[mpcallback_INIT_NUM_ARGS];
-    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, mpcallback_INIT_NUM_ARGS, mpcallback_init_args, args);
+STATIC mp_obj_t pyb_uart_sendbreak(mp_obj_t self_in) {
+    pyb_uart_obj_t *self = self_in;
+    uart_check_init(self);
+    // send a break signal for at least 2 complete frames
+    MAP_UARTBreakCtl(self->reg, true);
+    UtilsDelay(UTILS_DELAY_US_TO_COUNT(PYBUART_2_FRAMES_TIME_US(self->baudrate)));
+    MAP_UARTBreakCtl(self->reg, false);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_uart_sendbreak_obj, pyb_uart_sendbreak);
+
+/// \method irq(trigger, priority, handler, wake)
+STATIC mp_obj_t pyb_uart_irq (mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+    mp_arg_val_t args[mp_irq_INIT_NUM_ARGS];
+    mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, mp_irq_INIT_NUM_ARGS, mp_irq_init_args, args);

    // check if any parameters were passed
    pyb_uart_obj_t *self = pos_args[0];
-    mp_obj_t _callback = mpcallback_find((mp_obj_t)self);
-    if (kw_args->used > 0 || !_callback) {
+    uart_check_init(self);

-        // convert the priority to the correct value
-        uint priority = mpcallback_translate_priority (args[2].u_int);
+    // convert the priority to the correct value
+    uint priority = mp_irq_translate_priority (args[1].u_int);

-        // check the power mode
-        if (PYB_PWR_MODE_ACTIVE != args[3].u_int) {
-            nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
-        }
-
-        // register a new callback
-        return uart_callback_new (self, args[1].u_obj, args[3].u_int, priority);
-    }
-    return _callback;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_KW(pyb_uart_callback_obj, 1, pyb_uart_callback);
-
-/// \method writechar(char)
-/// Write a single character on the bus.  `char` is an integer to write.
-/// Return value: `None`.
-STATIC mp_obj_t pyb_uart_writechar(mp_obj_t self_in, mp_obj_t char_in) {
-    pyb_uart_obj_t *self = self_in;
-
-    // get the character to write
-    uint8_t data = mp_obj_get_int(char_in);
-
-    // send the character
-    if (!uart_tx_char(self, data)) {
-        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(ETIMEDOUT)));
+    // check the power mode
+    uint8_t pwrmode = (args[3].u_obj == mp_const_none) ? PYB_PWR_MODE_ACTIVE : mp_obj_get_int(args[3].u_obj);
+    if (PYB_PWR_MODE_ACTIVE != pwrmode) {
+        goto invalid_args;
    }

-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_uart_writechar_obj, pyb_uart_writechar);
-
-/// \method readchar()
-/// Receive a single character on the bus.
-/// Return value: The character read, as an integer.  Returns -1 on timeout.
-STATIC mp_obj_t pyb_uart_readchar(mp_obj_t self_in) {
-    pyb_uart_obj_t *self = self_in;
-    if (uart_rx_wait(self, self->timeout)) {
-        return mp_obj_new_int(uart_rx_char(self));
-    } else {
-        // return -1 on timeout
-        return MP_OBJ_NEW_SMALL_INT(-1);
+    // check the trigger
+    uint trigger = mp_obj_get_int(args[0].u_obj);
+    if (!trigger || trigger > (UART_TRIGGER_RX_ANY | UART_TRIGGER_RX_HALF | UART_TRIGGER_RX_FULL | UART_TRIGGER_TX_DONE)) {
+        goto invalid_args;
    }
+
+    // register a new callback
+    return uart_irq_new (self, trigger, priority, args[2].u_obj);
+
+invalid_args:
+    nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_uart_readchar_obj, pyb_uart_readchar);
+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
    { MP_OBJ_NEW_QSTR(MP_QSTR_init),        (mp_obj_t)&pyb_uart_init_obj },
    { 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_callback),    (mp_obj_t)&pyb_uart_callback_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_irq_obj },

    /// \method read([nbytes])
    { MP_OBJ_NEW_QSTR(MP_QSTR_read),        (mp_obj_t)&mp_stream_read_obj },
@@ -577,14 +579,10 @@ STATIC const mp_map_elem_t pyb_uart_locals_dict_table[] = {
    /// \method write(buf)
    { MP_OBJ_NEW_QSTR(MP_QSTR_write),       (mp_obj_t)&mp_stream_write_obj },

-    { MP_OBJ_NEW_QSTR(MP_QSTR_writechar),   (mp_obj_t)&pyb_uart_writechar_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_readchar),    (mp_obj_t)&pyb_uart_readchar_obj },
-
    // class constants
-    { MP_OBJ_NEW_QSTR(MP_QSTR_FLOW_NONE),   MP_OBJ_NEW_SMALL_INT(UART_FLOWCONTROL_NONE) },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_FLOW_TX),     MP_OBJ_NEW_SMALL_INT(UART_FLOWCONTROL_TX) },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_FLOW_RX),     MP_OBJ_NEW_SMALL_INT(UART_FLOWCONTROL_RX) },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_FLOW_TXRX),   MP_OBJ_NEW_SMALL_INT(UART_FLOWCONTROL_TX | UART_FLOWCONTROL_RX) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_EVEN),        MP_OBJ_NEW_SMALL_INT(UART_CONFIG_PAR_EVEN) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_ODD),         MP_OBJ_NEW_SMALL_INT(UART_CONFIG_PAR_ODD) },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_RX_ANY),      MP_OBJ_NEW_SMALL_INT(UART_TRIGGER_RX_ANY) },
 };

 STATIC MP_DEFINE_CONST_DICT(pyb_uart_locals_dict, pyb_uart_locals_dict_table);
@@ -592,6 +590,7 @@ STATIC MP_DEFINE_CONST_DICT(pyb_uart_locals_dict, pyb_uart_locals_dict_table);
 STATIC mp_uint_t pyb_uart_read(mp_obj_t self_in, void *buf_in, mp_uint_t size, int *errcode) {
    pyb_uart_obj_t *self = self_in;
    byte *buf = buf_in;
+    uart_check_init(self);

    // make sure we want at least 1 char
    if (size == 0) {
@@ -599,17 +598,17 @@ STATIC mp_uint_t pyb_uart_read(mp_obj_t self_in, void *buf_in, mp_uint_t size, i
    }

    // wait for first char to become available
-    if (!uart_rx_wait(self, self->timeout)) {
-        // we can either return 0 to indicate EOF (then read() method returns b'')
-        // or return EAGAIN error to indicate non-blocking (then read() method returns None)
-        return 0;
+    if (!uart_rx_wait(self)) {
+        // return EAGAIN error to indicate non-blocking (then read() method returns None)
+        *errcode = EAGAIN;
+        return MP_STREAM_ERROR;
    }

    // read the data
    byte *orig_buf = buf;
    for ( ; ; ) {
        *buf++ = uart_rx_char(self);
-        if (--size == 0 || !uart_rx_wait(self, self->timeout_char)) {
+        if (--size == 0 || !uart_rx_wait(self)) {
            // return number of bytes read
            return buf - orig_buf;
        }
@@ -619,10 +618,11 @@ STATIC mp_uint_t pyb_uart_read(mp_obj_t self_in, void *buf_in, mp_uint_t size, i
 STATIC mp_uint_t pyb_uart_write(mp_obj_t self_in, const void *buf_in, mp_uint_t size, int *errcode) {
    pyb_uart_obj_t *self = self_in;
    const char *buf = buf_in;
+    uart_check_init(self);

    // write the data
    if (!uart_tx_strn(self, buf, size)) {
-        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(ETIMEDOUT)));
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_operation_failed));
    }
    return size;
 }
@@ -630,6 +630,8 @@ STATIC mp_uint_t pyb_uart_write(mp_obj_t self_in, const void *buf_in, mp_uint_t
 STATIC mp_uint_t pyb_uart_ioctl(mp_obj_t self_in, mp_uint_t request, mp_uint_t arg, int *errcode) {
    pyb_uart_obj_t *self = self_in;
    mp_uint_t ret;
+    uart_check_init(self);
+
    if (request == MP_IOCTL_POLL) {
        mp_uint_t flags = arg;
        ret = 0;
@@ -653,10 +655,11 @@ STATIC const mp_stream_p_t uart_stream_p = {
    .is_text = false,
 };

-STATIC const mp_cb_methods_t uart_cb_methods = {
-    .init = pyb_uart_callback,
-    .enable = uart_callback_enable,
-    .disable = uart_callback_disable,
+STATIC const mp_irq_methods_t uart_irq_methods = {
+    .init = pyb_uart_irq,
+    .enable = uart_irq_enable,
+    .disable = uart_irq_disable,
+    .flags = uart_irq_flags
 };

 const mp_obj_type_t pyb_uart_type = {
--- a/cc3200/mods/pybuart.h
+++ b/cc3200/mods/pybuart.h
@@ -38,12 +38,9 @@ typedef struct _pyb_uart_obj_t pyb_uart_obj_t;
 extern const mp_obj_type_t pyb_uart_type;

 void uart_init0(void);
-mp_obj_t pyb_uart_deinit(mp_obj_t self_in);
-bool uart_rx_any(pyb_uart_obj_t *uart_obj);
+uint32_t uart_rx_any(pyb_uart_obj_t *uart_obj);
 int uart_rx_char(pyb_uart_obj_t *uart_obj);
 bool uart_tx_char(pyb_uart_obj_t *self, int c);
 bool uart_tx_strn(pyb_uart_obj_t *uart_obj, const char *str, uint len);
-void uart_tx_strn_cooked(pyb_uart_obj_t *uart_obj, const char *str, uint len);
-mp_obj_t uart_callback_new (pyb_uart_obj_t *self, mp_obj_t handler, uint rxbuffer_size, mp_int_t priority);

 #endif  // PYBUART_H_
--- a/cc3200/mods/pybwdt.c
+++ b/cc3200/mods/pybwdt.c
@@ -27,9 +27,9 @@
 #include <stdint.h>

 #include "py/mpconfig.h"
-#include MICROPY_HAL_H
 #include "py/obj.h"
 #include "py/runtime.h"
+#include "py/mphal.h"
 #include "inc/hw_types.h"
 #include "inc/hw_gpio.h"
 #include "inc/hw_ints.h"
@@ -53,15 +53,17 @@
 DECLARE TYPES
 ******************************************************************************/
 typedef struct {
+    mp_obj_base_t base;
    bool    servers;
+    bool    servers_sleeping;
    bool    simplelink;
    bool    running;
-}pybwdt_data_t;
+} pyb_wdt_obj_t;

 /******************************************************************************
 DECLARE PRIVATE DATA
 ******************************************************************************/
-static  pybwdt_data_t   pybwdt_data;
+STATIC pyb_wdt_obj_t pyb_wdt_obj = {.servers = false, .servers_sleeping = false, .simplelink = false, .running = false};

 /******************************************************************************
 DEFINE PUBLIC FUNCTIONS
@@ -69,38 +71,42 @@ static  pybwdt_data_t   pybwdt_data;
 // must be called in main.c just after initializing the hal
 __attribute__ ((section (".boot")))
 void pybwdt_init0 (void) {
-    pybwdt_data.running = false;
-}
-
-void pybwdt_kick (void) {
-    // check that the servers and simplelink are running fine
-    if (pybwdt_data.servers && pybwdt_data.simplelink && pybwdt_data.running) {
-        pybwdt_data.servers = false;
-        pybwdt_data.simplelink = false;
-        MAP_WatchdogIntClear(WDT_BASE);
-    }
 }

 void pybwdt_srv_alive (void) {
-    pybwdt_data.servers = true;
+    pyb_wdt_obj.servers = true;
+}
+
+void pybwdt_srv_sleeping (bool state) {
+    pyb_wdt_obj.servers_sleeping = state;
 }

 void pybwdt_sl_alive (void) {
-    pybwdt_data.simplelink = true;
+    pyb_wdt_obj.simplelink = true;
 }

 /******************************************************************************/
 // Micro Python bindings

-/// \function wdt_enable('msec')
-/// Enabled the watchdog timer with msec timeout value
-STATIC mp_obj_t pyb_enable_wdt(mp_obj_t self, mp_obj_t msec_in) {
-    mp_int_t msec = mp_obj_get_int(msec_in);
+STATIC const mp_arg_t pyb_wdt_init_args[] = {
+    { MP_QSTR_id,                             MP_ARG_OBJ,  {.u_obj = mp_const_none} },
+    { MP_QSTR_timeout,                        MP_ARG_INT,  {.u_int = 5000} },   // 5 s
+};
+STATIC mp_obj_t pyb_wdt_make_new(const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *all_args) {
+    // check the arguments
+    mp_map_t kw_args;
+    mp_map_init_fixed_table(&kw_args, n_kw, all_args + n_args);
+    mp_arg_val_t args[MP_ARRAY_SIZE(pyb_wdt_init_args)];
+    mp_arg_parse_all(n_args, all_args, &kw_args, MP_ARRAY_SIZE(args), pyb_wdt_init_args, args);

-    if (msec < PYBWDT_MIN_TIMEOUT_MS) {
+    if (args[0].u_obj != mp_const_none && mp_obj_get_int(args[0].u_obj) > 0) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_resource_not_avaliable));
+    }
+    uint timeout_ms = args[1].u_int;
+    if (timeout_ms < PYBWDT_MIN_TIMEOUT_MS) {
        nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
    }
-    if (pybwdt_data.running) {
+    if (pyb_wdt_obj.running) {
        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, mpexception_os_request_not_possible));
    }

@@ -110,40 +116,44 @@ STATIC mp_obj_t pyb_enable_wdt(mp_obj_t self, mp_obj_t msec_in) {
    // Unlock to be able to configure the registers
    MAP_WatchdogUnlock(WDT_BASE);

+#ifdef DEBUG
    // make the WDT stall when the debugger stops on a breakpoint
    MAP_WatchdogStallEnable (WDT_BASE);
+#endif

    // set the watchdog timer reload value
    // the WDT trigger a system reset after the second timeout
-    // so, divide by the 2 timeout value received
-    MAP_WatchdogReloadSet(WDT_BASE, PYBWDT_MILLISECONDS_TO_TICKS(msec / 2));
+    // so, divide by 2 the timeout value received
+    MAP_WatchdogReloadSet(WDT_BASE, PYBWDT_MILLISECONDS_TO_TICKS(timeout_ms / 2));

-    // start the timer. Once wdt is started, it cannot be disabled.
+    // start the timer. Once it's started, it cannot be disabled.
    MAP_WatchdogEnable(WDT_BASE);
-    pybwdt_data.running = true;
+    pyb_wdt_obj.base.type = &pyb_wdt_type;
+    pyb_wdt_obj.running = true;

+    return (mp_obj_t)&pyb_wdt_obj;
+}
+
+STATIC mp_obj_t pyb_wdt_feed(mp_obj_t self_in) {
+    pyb_wdt_obj_t *self = self_in;
+    if ((self->servers || self->servers_sleeping) && self->simplelink && self->running) {
+        self->servers = false;
+        self->simplelink = false;
+        MAP_WatchdogIntClear(WDT_BASE);
+    }
    return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_2(pyb_enable_wdt_obj, pyb_enable_wdt);
-
-/// \function wdt_kick()
-/// Kicks the watchdog timer
-STATIC mp_obj_t pyb_kick_wdt(mp_obj_t self) {
-    pybwdt_kick ();
-    return mp_const_none;
-}
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_kick_wdt_obj, pyb_kick_wdt);
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(pyb_wdt_feed_obj, pyb_wdt_feed);

 STATIC const mp_map_elem_t pybwdt_locals_dict_table[] = {
-    { MP_OBJ_NEW_QSTR(MP_QSTR_enable), (mp_obj_t)&pyb_enable_wdt_obj },
-    { MP_OBJ_NEW_QSTR(MP_QSTR_kick),   (mp_obj_t)&pyb_kick_wdt_obj },
+    { MP_OBJ_NEW_QSTR(MP_QSTR_feed),   (mp_obj_t)&pyb_wdt_feed_obj },
 };
 STATIC MP_DEFINE_CONST_DICT(pybwdt_locals_dict, pybwdt_locals_dict_table);

-static const mp_obj_type_t pybwdt_type = {
+const mp_obj_type_t pyb_wdt_type = {
    { &mp_type_type },
    .name = MP_QSTR_WDT,
+    .make_new = pyb_wdt_make_new,
    .locals_dict = (mp_obj_t)&pybwdt_locals_dict,
 };

-const mp_obj_base_t pyb_wdt_obj = {&pybwdt_type};
--- a/cc3200/mods/pybwdt.h
+++ b/cc3200/mods/pybwdt.h
@@ -29,11 +29,11 @@

 #include "py/obj.h"

-extern const mp_obj_base_t pyb_wdt_obj;
+extern const mp_obj_type_t pyb_wdt_type;

 void pybwdt_init0 (void);
-void pybwdt_kick (void);
 void pybwdt_srv_alive (void);
+void pybwdt_srv_sleeping (bool state);
 void pybwdt_sl_alive (void);

 #endif /* PYBWDT_H_ */
--- a/cc3200/mpconfigport.h
+++ b/cc3200/mpconfigport.h
@@ -30,6 +30,11 @@

 #include <stdint.h>

+#ifndef BOOTLOADER
+#include "FreeRTOS.h"
+#include "semphr.h"
+#endif
+
 // options to control how Micro Python is built

 #define MICROPY_ALLOC_PATH_MAX                      (128)
@@ -43,93 +48,129 @@
 #define MICROPY_HELPER_REPL                         (1)
 #define MICROPY_ENABLE_SOURCE_LINE                  (1)
 #define MICROPY_ENABLE_DOC_STRING                   (0)
+#define MICROPY_REPL_AUTO_INDENT                    (1)
 #define MICROPY_ERROR_REPORTING                     (MICROPY_ERROR_REPORTING_TERSE)
 #define MICROPY_LONGINT_IMPL                        (MICROPY_LONGINT_IMPL_MPZ)
 #define MICROPY_FLOAT_IMPL                          (MICROPY_FLOAT_IMPL_NONE)
 #define MICROPY_OPT_COMPUTED_GOTO                   (0)
 #define MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE    (0)
+#ifndef DEBUG // we need ram on the launchxl while debugging
+#define MICROPY_CPYTHON_COMPAT                      (1)
+#else
+#define MICROPY_CPYTHON_COMPAT                      (0)
+#endif
+#define MICROPY_QSTR_BYTES_IN_HASH                  (1)
+
+// fatfs configuration used in ffconf.h
+#define MICROPY_FATFS_ENABLE_LFN                    (2)
+#define MICROPY_FATFS_MAX_LFN                       (MICROPY_ALLOC_PATH_MAX)
+#define MICROPY_FATFS_LFN_CODE_PAGE                 (437) // 1=SFN/ANSI 437=LFN/U.S.(OEM)
+#define MICROPY_FATFS_RPATH                         (2)
+#define MICROPY_FATFS_VOLUMES                       (2)
+#define MICROPY_FATFS_REENTRANT                     (1)
+#define MICROPY_FATFS_TIMEOUT                       (2500)
+#define MICROPY_FATFS_SYNC_T                        SemaphoreHandle_t
+#define MICROPY_FSUSERMOUNT_ADHOC                   (1)

-/* Enable FatFS LFNs
-    0: Disable LFN feature.
-    1: Enable LFN with static working buffer on the BSS. Always NOT reentrant.
-    2: Enable LFN with dynamic working buffer on the STACK.
-    3: Enable LFN with dynamic working buffer on the HEAP.
-*/
-#define MICROPY_ENABLE_LFN                          (2)
-#define MICROPY_LFN_CODE_PAGE                       (437)       // 1=SFN/ANSI 437=LFN/U.S.(OEM)
 #define MICROPY_STREAMS_NON_BLOCK                   (1)
-#define MICROPY_MODULE_WEAK_LINKS                   (0)
-#define MICROPY_CAN_OVERRIDE_BUILTINS               (0)
+#define MICROPY_MODULE_WEAK_LINKS                   (1)
+#define MICROPY_CAN_OVERRIDE_BUILTINS               (1)
+#define MICROPY_PY_ASYNC_AWAIT (0)
+#define MICROPY_PY_BUILTINS_TIMEOUTERROR            (1)
+#define MICROPY_PY_ALL_SPECIAL_METHODS              (1)
+#ifndef DEBUG
 #define MICROPY_PY_BUILTINS_STR_UNICODE             (1)
-#define MICROPY_PY_BUILTINS_STR_SPLITLINES          (0)
+#define MICROPY_PY_BUILTINS_STR_SPLITLINES          (1)
 #define MICROPY_PY_BUILTINS_MEMORYVIEW              (1)
 #define MICROPY_PY_BUILTINS_FROZENSET               (1)
 #define MICROPY_PY_BUILTINS_EXECFILE                (1)
-#define MICROPY_PY_MICROPYTHON_MEM_INFO             (0)
+#define MICROPY_PY_ARRAY_SLICE_ASSIGN               (1)
+#define MICROPY_PY_COLLECTIONS_ORDEREDDICT          (1)
+#else
+#define MICROPY_PY_BUILTINS_STR_UNICODE             (0)
+#define MICROPY_PY_BUILTINS_STR_SPLITLINES          (0)
+#define MICROPY_PY_BUILTINS_MEMORYVIEW              (0)
+#define MICROPY_PY_BUILTINS_FROZENSET               (0)
+#define MICROPY_PY_BUILTINS_EXECFILE                (0)
 #define MICROPY_PY_ARRAY_SLICE_ASSIGN               (0)
 #define MICROPY_PY_COLLECTIONS_ORDEREDDICT          (0)
-#define MICROPY_PY_SYS_MAXSIZE                      (0)
+#endif
+#define MICROPY_PY_MICROPYTHON_MEM_INFO             (0)
+#define MICROPY_PY_SYS_MAXSIZE                      (1)
 #define MICROPY_PY_SYS_EXIT                         (1)
 #define MICROPY_PY_SYS_STDFILES                     (1)
 #define MICROPY_PY_CMATH                            (0)
 #define MICROPY_PY_IO                               (1)
 #define MICROPY_PY_IO_FILEIO                        (1)
-#define MICROPY_PY_UBINASCII                        (1)
-#define MICROPY_PY_UCTYPES                          (1)
+#define MICROPY_PY_UBINASCII                        (0)
+#define MICROPY_PY_UCTYPES                          (0)
 #define MICROPY_PY_UZLIB                            (0)
 #define MICROPY_PY_UJSON                            (1)
 #define MICROPY_PY_URE                              (1)
-#define MICROPY_PY_UHEAPQ                           (1)
+#define MICROPY_PY_UHEAPQ                           (0)
 #define MICROPY_PY_UHASHLIB                         (0)

 #define MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF      (1)
 #define MICROPY_EMERGENCY_EXCEPTION_BUF_SIZE        (0)

 // extra built in names to add to the global namespace
-extern const struct _mp_obj_fun_builtin_t mp_builtin_help_obj;
-extern const struct _mp_obj_fun_builtin_t mp_builtin_input_obj;
-extern const struct _mp_obj_fun_builtin_t mp_builtin_open_obj;
 #define MICROPY_PORT_BUILTINS \
    { MP_OBJ_NEW_QSTR(MP_QSTR_help),  (mp_obj_t)&mp_builtin_help_obj },   \
    { MP_OBJ_NEW_QSTR(MP_QSTR_input), (mp_obj_t)&mp_builtin_input_obj },  \
    { MP_OBJ_NEW_QSTR(MP_QSTR_open),  (mp_obj_t)&mp_builtin_open_obj },   \

 // extra built in modules to add to the list of known ones
-extern const struct _mp_obj_module_t pyb_module;
-extern const struct _mp_obj_module_t mp_module_ubinascii;
+extern const struct _mp_obj_module_t machine_module;
+extern const struct _mp_obj_module_t wipy_module;
 extern const struct _mp_obj_module_t mp_module_ure;
 extern const struct _mp_obj_module_t mp_module_ujson;
-extern const struct _mp_obj_module_t mp_module_uheapq;
 extern const struct _mp_obj_module_t mp_module_uos;
 extern const struct _mp_obj_module_t mp_module_utime;
 extern const struct _mp_obj_module_t mp_module_uselect;
 extern const struct _mp_obj_module_t mp_module_usocket;
 extern const struct _mp_obj_module_t mp_module_network;
+extern const struct _mp_obj_module_t mp_module_ubinascii;
+extern const struct _mp_obj_module_t mp_module_ussl;

 #define MICROPY_PORT_BUILTIN_MODULES \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_pyb),     (mp_obj_t)&pyb_module },          \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_os),      (mp_obj_t)&mp_module_uos },       \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_time),    (mp_obj_t)&mp_module_utime },     \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_select),  (mp_obj_t)&mp_module_uselect },   \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_socket),  (mp_obj_t)&mp_module_usocket },   \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_network), (mp_obj_t)&mp_module_network },   \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_re),      (mp_obj_t)&mp_module_ure },       \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_json),    (mp_obj_t)&mp_module_ujson },     \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_heapq),   (mp_obj_t)&mp_module_uheapq },    \
+    { MP_OBJ_NEW_QSTR(MP_QSTR_umachine),     (mp_obj_t)&machine_module },      \
+	{ MP_OBJ_NEW_QSTR(MP_QSTR_wipy),        (mp_obj_t)&wipy_module },         \
+    { MP_OBJ_NEW_QSTR(MP_QSTR_uos),         (mp_obj_t)&mp_module_uos },       \
+    { MP_OBJ_NEW_QSTR(MP_QSTR_utime),       (mp_obj_t)&mp_module_utime },     \
+    { MP_OBJ_NEW_QSTR(MP_QSTR_uselect),     (mp_obj_t)&mp_module_uselect },   \
+    { MP_OBJ_NEW_QSTR(MP_QSTR_usocket),     (mp_obj_t)&mp_module_usocket },   \
+    { MP_OBJ_NEW_QSTR(MP_QSTR_network),     (mp_obj_t)&mp_module_network },   \
+    { MP_OBJ_NEW_QSTR(MP_QSTR_ubinascii),   (mp_obj_t)&mp_module_ubinascii }, \
+    { MP_OBJ_NEW_QSTR(MP_QSTR_ussl),        (mp_obj_t)&mp_module_ussl },      \
+
+#define MICROPY_PORT_BUILTIN_MODULE_WEAK_LINKS \
+    { MP_OBJ_NEW_QSTR(MP_QSTR_struct),      (mp_obj_t)&mp_module_ustruct },   \
+    { MP_OBJ_NEW_QSTR(MP_QSTR_re),          (mp_obj_t)&mp_module_ure },       \
+    { MP_OBJ_NEW_QSTR(MP_QSTR_json),        (mp_obj_t)&mp_module_ujson },     \
+    { MP_OBJ_NEW_QSTR(MP_QSTR_os),          (mp_obj_t)&mp_module_uos },       \
+    { MP_OBJ_NEW_QSTR(MP_QSTR_time),        (mp_obj_t)&mp_module_utime },     \
+    { MP_OBJ_NEW_QSTR(MP_QSTR_select),      (mp_obj_t)&mp_module_uselect },   \
+    { MP_OBJ_NEW_QSTR(MP_QSTR_socket),      (mp_obj_t)&mp_module_usocket },   \
+    { MP_OBJ_NEW_QSTR(MP_QSTR_binascii),    (mp_obj_t)&mp_module_ubinascii }, \
+    { MP_OBJ_NEW_QSTR(MP_QSTR_ssl),         (mp_obj_t)&mp_module_ussl },      \
+    { MP_OBJ_NEW_QSTR(MP_QSTR_machine),     (mp_obj_t)&machine_module },      \

 // extra constants
 #define MICROPY_PORT_CONSTANTS \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_pyb),     (mp_obj_t)&pyb_module },          \
+    { MP_OBJ_NEW_QSTR(MP_QSTR_umachine),     (mp_obj_t)&machine_module },      \

 // vm state and root pointers for the gc
 #define MP_STATE_PORT MP_STATE_VM
 #define MICROPY_PORT_ROOT_POINTERS                                        \
    const char *readline_hist[8];                                         \
    mp_obj_t mp_const_user_interrupt;                                     \
-    mp_obj_t pyb_config_main;                                             \
-    mp_obj_list_t mod_network_nic_list;                                   \
-    mp_obj_list_t pybsleep_obj_list;                                      \
-    mp_obj_list_t mpcallback_obj_list;                                    \
+    mp_obj_t machine_config_main;                                         \
+    mp_obj_list_t pyb_sleep_obj_list;                                     \
+    mp_obj_list_t mp_irq_obj_list;                                        \
+    mp_obj_list_t pyb_timer_channel_obj_list;                             \
+    mp_obj_list_t mount_obj_list;                                         \
+    struct _pyb_uart_obj_t *pyb_uart_objs[2];                             \
+    struct _os_term_dup_obj_t *os_term_dup_obj;                           \


 // type definitions for the specific machine
@@ -146,7 +187,6 @@ typedef void            *machine_ptr_t;             // must be of pointer size
 typedef const void      *machine_const_ptr_t;       // must be of pointer size
 typedef long            mp_off_t;

-void mp_hal_stdout_tx_strn_cooked(const char *str, uint32_t len);
 #define MP_PLAT_PRINT_STRN(str, len) mp_hal_stdout_tx_strn_cooked(str, len)

 #define MICROPY_BEGIN_ATOMIC_SECTION()              disable_irq()
@@ -170,9 +210,14 @@ void mp_hal_stdout_tx_strn_cooked(const char *str, uint32_t len);
 // Include board specific configuration
 #include "mpconfigboard.h"

-#define MICROPY_HAL_H                               "cc3200_hal.h"
-#define MICROPY_PIN_DEFS_PORT_H                     "pin_defs_cc3200.h"
+#define MICROPY_MPHALPORT_H                         "cc3200_hal.h"
 #define MICROPY_PORT_HAS_TELNET                     (1)
 #define MICROPY_PORT_HAS_FTP                        (1)
+#define MICROPY_PY_SYS_PLATFORM                     "WiPy"
+
+#define MICROPY_PORT_WLAN_AP_SSID                   "wipy-wlan"
+#define MICROPY_PORT_WLAN_AP_KEY                    "www.wipy.io"
+#define MICROPY_PORT_WLAN_AP_SECURITY               SL_SEC_TYPE_WPA_WPA2
+#define MICROPY_PORT_WLAN_AP_CHANNEL                5

 #endif // __INCLUDED_MPCONFIGPORT_H
--- a/cc3200/mptask.c
+++ b/cc3200/mptask.c
@@ -28,10 +28,10 @@
 #include <stdint.h>

 #include "py/mpconfig.h"
-#include MICROPY_HAL_H
 #include "py/obj.h"
 #include "py/runtime.h"
 #include "py/gc.h"
+#include "py/mphal.h"
 #include "inc/hw_memmap.h"
 #include "inc/hw_types.h"
 #include "inc/hw_ints.h"
@@ -43,13 +43,14 @@
 #include "pybuart.h"
 #include "pybpin.h"
 #include "pybrtc.h"
-#include "pyexec.h"
+#include "lib/utils/pyexec.h"
 #include "gccollect.h"
 #include "gchelper.h"
 #include "readline.h"
 #include "mperror.h"
 #include "simplelink.h"
 #include "modnetwork.h"
+#include "modusocket.h"
 #include "modwlan.h"
 #include "serverstask.h"
 #include "telnet.h"
@@ -60,10 +61,14 @@
 #include "mpexception.h"
 #include "random.h"
 #include "pybi2c.h"
-#include "pybsd.h"
 #include "pins.h"
 #include "pybsleep.h"
-#include "mpcallback.h"
+#include "pybtimer.h"
+#include "cryptohash.h"
+#include "mpirq.h"
+#include "updater.h"
+#include "moduos.h"
+#include "antenna.h"

 /******************************************************************************
 DECLARE PRIVATE CONSTANTS
@@ -101,11 +106,14 @@ void TASK_Micropython (void *pvParameters) {
    // initialize the garbage collector with the top of our stack
    uint32_t sp = gc_helper_get_sp();
    gc_collect_init (sp);
-    bool safeboot = false;
-    FRESULT res;

+    bool safeboot = false;
    mptask_pre_init();

+#ifndef DEBUG
+    safeboot = PRCMGetSpecialBit(PRCM_SAFE_BOOT_BIT);
+#endif
+
 soft_reset:

    // GC init
@@ -119,39 +127,18 @@ soft_reset:

    // execute all basic initializations
    mpexception_init0();
-    mpcallback_init0();
-    pybsleep_init0();
+    mp_irq_init0();
+    pyb_sleep_init0();
+    pin_init0();
    mperror_init0();
    uart_init0();
-    pin_init0();
+    timer_init0();
    readline_init0();
    mod_network_init0();
-    wlan_init0();
-#if MICROPY_HW_ENABLE_RNG
+    moduos_init0();
    rng_init0();
-#endif

-    // we are alive, so let the world know it
-    mperror_enable_heartbeat();
-
-#ifdef LAUNCHXL
-    // configure the stdio uart pins with the correct alternate functions
-    // param 3 ("mode") is DON'T CARE" for AFs others than GPIO
-    pin_config ((pin_obj_t *)&pin_GPIO1, PIN_MODE_3, 0, PIN_TYPE_STD_PU, PIN_STRENGTH_2MA);
-    pin_config ((pin_obj_t *)&pin_GPIO2, PIN_MODE_3, 0, PIN_TYPE_STD_PU, PIN_STRENGTH_2MA);
-    // instantiate the stdio uart
-    mp_obj_t args[2] = {
-            mp_obj_new_int(MICROPY_STDIO_UART),
-            mp_obj_new_int(MICROPY_STDIO_UART_BAUD),
-    };
-    pyb_stdio_uart = pyb_uart_type.make_new((mp_obj_t)&pyb_uart_type, MP_ARRAY_SIZE(args), 0, args);
-    // create a callback for the uart, in order to enable the rx interrupts
-    uart_callback_new (pyb_stdio_uart, mp_const_none, MICROPY_STDIO_UART_RX_BUF_SIZE, INT_PRIORITY_LVL_3);
-#else
-    pyb_stdio_uart = MP_OBJ_NULL;
-#endif
-
-    pybsleep_reset_cause_t rstcause = pybsleep_get_reset_cause();
+    pybsleep_reset_cause_t rstcause = pyb_sleep_get_reset_cause();
    if (rstcause < PYB_SLP_SOFT_RESET) {
        if (rstcause == PYB_SLP_HIB_RESET) {
            // when waking up from hibernate we just want
@@ -161,9 +148,6 @@ soft_reset:
        else {
            // only if not comming out of hibernate or a soft reset
            mptask_enter_ap_mode();
-        #ifndef DEBUG
-            safeboot = PRCMIsSafeBootRequested();
-        #endif
        }

        // enable telnet and ftp
@@ -178,21 +162,17 @@ soft_reset:
    mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR__slash_flash_slash_lib));

    // reset config variables; they should be set by boot.py
-    MP_STATE_PORT(pyb_config_main) = MP_OBJ_NULL;
+    MP_STATE_PORT(machine_config_main) = MP_OBJ_NULL;

    if (!safeboot) {
-        // run boot.py, if it exists
-        const char *boot_py = "boot.py";
-        res = f_stat(boot_py, NULL);
-        if (res == FR_OK) {
-            int ret = pyexec_file(boot_py);
-            if (ret & PYEXEC_FORCED_EXIT) {
-                goto soft_reset_exit;
-            }
-            if (!ret) {
-                // flash the system led
-                mperror_signal_error();
-            }
+        // run boot.py
+        int ret = pyexec_file("boot.py");
+        if (ret & PYEXEC_FORCED_EXIT) {
+            goto soft_reset_exit;
+        }
+        if (!ret) {
+            // flash the system led
+            mperror_signal_error();
        }
    }

@@ -206,21 +186,18 @@ soft_reset:
        // run the main script from the current directory.
        if (pyexec_mode_kind == PYEXEC_MODE_FRIENDLY_REPL) {
            const char *main_py;
-            if (MP_STATE_PORT(pyb_config_main) == MP_OBJ_NULL) {
+            if (MP_STATE_PORT(machine_config_main) == MP_OBJ_NULL) {
                main_py = "main.py";
            } else {
-                main_py = mp_obj_str_get_str(MP_STATE_PORT(pyb_config_main));
+                main_py = mp_obj_str_get_str(MP_STATE_PORT(machine_config_main));
            }
-            res = f_stat(main_py, NULL);
-            if (res == FR_OK) {
-                int ret = pyexec_file(main_py);
-                if (ret & PYEXEC_FORCED_EXIT) {
-                    goto soft_reset_exit;
-                }
-                if (!ret) {
-                    // flash the system led
-                    mperror_signal_error();
-                }
+            int ret = pyexec_file(main_py);
+            if (ret & PYEXEC_FORCED_EXIT) {
+                goto soft_reset_exit;
+            }
+            if (!ret) {
+                // flash the system led
+                mperror_signal_error();
            }
        }
    }
@@ -242,15 +219,27 @@ soft_reset:
 soft_reset_exit:

    // soft reset
-    pybsleep_signal_soft_reset();
-
+    pyb_sleep_signal_soft_reset();
    mp_printf(&mp_plat_print, "PYB: soft reboot\n");

+    // disable all callbacks to avoid undefined behaviour
+    // when coming out of a soft reset
+    mp_irq_disable_all();
+
+    // cancel the RTC alarm which might be running independent of the irq state
+    pyb_rtc_disable_alarm();
+
+    // flush the serial flash buffer
    sflash_disk_flush();

-#if MICROPY_HW_HAS_SDCARD
-    pybsd_deinit();
-#endif
+    // clean-up the user socket space
+    modusocket_close_all_user_sockets();
+
+    // unmount all user file systems
+    osmount_unmount_all();
+
+    // wait for pending transactions to complete
+    mp_hal_delay_ms(20);

    goto soft_reset;
 }
@@ -260,9 +249,8 @@ soft_reset_exit:
 ******************************************************************************/
 __attribute__ ((section (".boot")))
 STATIC void mptask_pre_init (void) {
-#if MICROPY_HW_ENABLE_RTC
-    pybrtc_init();
-#endif
+    // this one only makes sense after a poweron reset
+    pyb_rtc_pre_init();

    // Create the simple link spawn task
    ASSERT (OSI_OK == VStartSimpleLinkSpawnTask(SIMPLELINK_SPAWN_TASK_PRIORITY));
@@ -271,11 +259,18 @@ STATIC void mptask_pre_init (void) {
    ASSERT ((sflash_fatfs = mem_Malloc(sizeof(FATFS))) != NULL);

    // this one allocates memory for the nvic vault
-    pybsleep_pre_init();
+    pyb_sleep_pre_init();

-#if MICROPY_HW_HAS_SDCARD
-    pybsd_init0();
-#endif
+    // this one allocates memory for the WLAN semaphore
+    wlan_pre_init();
+
+    // this one allocates memory for the updater semaphore
+    updater_pre_init();
+
+    // this one allocates memory for the socket semaphore
+    modusocket_pre_init();
+
+    //CRYPTOHASH_Init();

 #ifdef DEBUG
    ASSERT (OSI_OK == osi_TaskCreate(TASK_Servers,
@@ -297,7 +292,6 @@ STATIC void mptask_init_sflash_filesystem (void) {

    // Initialise the local flash filesystem.
    // Create it if needed, and mount in on /flash.
-    // try to mount the flash
    FRESULT res = f_mount(sflash_fatfs, "/flash", 1);
    if (res == FR_NO_FILESYSTEM) {
        // no filesystem, so create a fresh one
@@ -323,7 +317,20 @@ STATIC void mptask_init_sflash_filesystem (void) {
    // It is set to the internal flash filesystem by default.
    f_chdrive("/flash");

-    // Make sure we have a /flash/boot.py.  Create it if needed.
+    // create /flash/sys, /flash/lib and /flash/cert if they don't exist
+    if (FR_OK != f_chdir ("/flash/sys")) {
+        f_mkdir("/flash/sys");
+    }
+    if (FR_OK != f_chdir ("/flash/lib")) {
+        f_mkdir("/flash/lib");
+    }
+    if (FR_OK != f_chdir ("/flash/cert")) {
+        f_mkdir("/flash/cert");
+    }
+
+    f_chdir ("/flash");
+
+    // make sure we have a /flash/boot.py.  Create it if needed.
    res = f_stat("/flash/boot.py", &fno);
    if (res == FR_OK) {
        if (fno.fattrib & AM_DIR) {
@@ -345,9 +352,12 @@ STATIC void mptask_init_sflash_filesystem (void) {
 }

 STATIC void mptask_enter_ap_mode (void) {
-    // enable simplelink in low power mode
-    wlan_sl_enable (ROLE_AP, MICROPY_PORT_WLAN_AP_SSID, strlen(MICROPY_PORT_WLAN_AP_SSID), MICROPY_PORT_WLAN_AP_SECURITY,
-                    MICROPY_PORT_WLAN_AP_KEY, strlen(MICROPY_PORT_WLAN_AP_KEY), MICROPY_PORT_WLAN_AP_CHANNEL);
+    // append the mac only if it's not the first boot
+    bool add_mac = !PRCMGetSpecialBit(PRCM_FIRST_BOOT_BIT);
+    // enable simplelink in ap mode (use the MAC address to make the ssid unique)
+    wlan_sl_init (ROLE_AP, MICROPY_PORT_WLAN_AP_SSID, strlen(MICROPY_PORT_WLAN_AP_SSID),
+                  MICROPY_PORT_WLAN_AP_SECURITY, MICROPY_PORT_WLAN_AP_KEY, strlen(MICROPY_PORT_WLAN_AP_KEY),
+                  MICROPY_PORT_WLAN_AP_CHANNEL, ANTENNA_TYPE_INTERNAL, add_mac);
 }

 STATIC void mptask_create_main_py (void) {
@@ -359,10 +369,3 @@ STATIC void mptask_create_main_py (void) {
    f_close(&fp);
 }

-STATIC mp_obj_t pyb_main(mp_obj_t main) {
-    if (MP_OBJ_IS_STR(main)) {
-        MP_STATE_PORT(pyb_config_main) = main;
-    }
-    return mp_const_none;
-}
-MP_DEFINE_CONST_FUN_OBJ_1(pyb_main_obj, pyb_main);
--- a/cc3200/qstrdefsport.h
+++ b/cc3200/qstrdefsport.h
@@ -25,300 +25,8 @@
 * THE SOFTWARE.
 */

-// qstrs specific to this port
-Q(__name__)
-Q(help)
-Q(pyb)
-Q(info)
-Q(reset)
-Q(main)
-Q(sync)
-Q(gc)
-Q(rng)
-Q(delay)
-Q(time)
-Q(open)
-Q(on)
-Q(off)
-Q(toggle)
-Q(write)
-Q(read)
-Q(readall)
-Q(readline)
-Q(input)
-Q(os)
-Q(freq)
-Q(repl_info)
-Q(disable_irq)
-Q(enable_irq)
-Q(millis)
-Q(micros)
-Q(elapsed_millis)
-Q(elapsed_micros)
-Q(udelay)
-Q(version)
-Q(flush)
-Q(FileIO)
-Q(mkdisk)
-Q(enable)
-Q(disable)
-// Entries for sys.path
+// for machine module
+Q(/)
+// entries for sys.path
 Q(/flash)
 Q(/flash/lib)
-#if MICROPY_HW_HAS_SDCARD
-Q(/sd)
-Q(/sd/lib)
-#endif
-
-// for module weak links
-Q(re)
-Q(json)
-Q(heapq)
-
-// for os module
-Q(uos)
-Q(os)
-Q(/)
-Q(flash)
-#if MICROPY_HW_HAS_SDCARD
-Q(sd)
-#endif
-Q(chdir)
-Q(getcwd)
-Q(listdir)
-Q(mkdir)
-Q(remove)
-Q(rmdir)
-Q(unlink)
-Q(sep)
-Q(stat)
-Q(urandom)
-
-// for file class
-Q(seek)
-Q(tell)
-
-// for Pin class
-Q(Pin)
-Q(init)
-Q(value)
-Q(low)
-Q(high)
-Q(name)
-Q(port)
-Q(pin)
-Q(cpu)
-Q(mode)
-Q(pull)
-Q(index)
-Q(strength)
-Q(af)
-Q(intenable)
-Q(intdisable)
-Q(intmode)
-Q(swint)
-Q(IN)
-Q(OUT)
-Q(STD)
-Q(STD_PU)
-Q(STD_PD)
-Q(OD)
-Q(OD_PU)
-Q(OD_PD)
-Q(INT_RISING)
-Q(INT_FALLING)
-Q(INT_RISING_FALLING)
-Q(INT_LOW_LEVEL)
-Q(INT_HIGH_LEVEL)
-Q(S2MA)
-Q(S4MA)
-Q(S6MA)
-
-// for UART class
-Q(UART)
-Q(baudrate)
-Q(bits)
-Q(stop)
-Q(parity)
-Q(init)
-Q(deinit)
-Q(all)
-Q(writechar)
-Q(readchar)
-Q(readinto)
-Q(read_buf_len)
-Q(timeout)
-Q(timeout_char)
-Q(repl_uart)
-Q(flow)
-Q(FLOW_NONE)
-Q(FLOW_TX)
-Q(FLOW_RX)
-Q(FLOW_TXRX)
-
-// for I2C class
-Q(I2C)
-Q(addr)
-Q(data)
-Q(memaddr)
-Q(addr_size)
-Q(init)
-Q(deinit)
-Q(is_ready)
-Q(scan)
-Q(send)
-Q(recv)
-Q(mem_read)
-Q(mem_write)
-
-// for ADC class
-Q(ADC)
-Q(read)
-
-#if MICROPY_HW_HAS_SDCARD
-// for SD class
-Q(SD)
-Q(enable)
-Q(disable)
-#endif
-
-// for RTC class
-Q(RTC)
-Q(datetime)
-
-// for time class
-Q(utime)
-Q(localtime)
-Q(mktime)
-Q(sleep)
-Q(time)
-
-// for select class
-Q(select)
-Q(uselect)
-Q(register)
-Q(unregister)
-Q(modify)
-Q(poll)
-
-// for socket class
-Q(socket)
-Q(usocket)
-Q(getaddrinfo)
-Q(family)
-Q(type)
-Q(send)
-Q(sendto)
-Q(recv)
-Q(recvfrom)
-Q(listen)
-Q(accept)
-Q(bind)
-Q(settimeout)
-Q(setblocking)
-Q(setsockopt)
-Q(close)
-Q(protocol)
-Q(AF_INET)
-Q(AF_INET6)
-Q(SOCK_STREAM)
-Q(SOCK_DGRAM)
-Q(SOCK_RAW)
-Q(IPPROTO_SEC)
-Q(IPPROTO_TCP)
-Q(IPPROTO_UDP)
-Q(IPPROTO_RAW)
-
-// for network class
-Q(network)
-Q(route)
-Q(start_server)
-Q(stop_server)
-Q(server_enabled)
-Q(server_login)
-
-// for WLAN class
-Q(WLAN)
-Q(key)
-Q(security)
-Q(ssid)
-Q(bssid)
-Q(scan)
-Q(connect)
-Q(isconnected)
-Q(disconnect)
-Q(channel)
-Q(ifconfig)
-Q(urn)
-Q(mode)
-Q(config_ip)
-Q(ip)
-Q(subnet)
-Q(gateway)
-Q(dns)
-Q(STA)
-Q(AP)
-Q(P2P)
-Q(OPEN)
-Q(WEP)
-Q(WPA_WPA2)
-Q(WPA_ENT)
-Q(WPS_PBC)
-Q(WPS_PIN)
-Q(DYNAMIC)
-Q(STATIC)
-
-// for WDT class
-Q(WDT)
-Q(enable)
-Q(kick)
-
-// for HeartBeat class
-Q(HeartBeat)
-Q(enable)
-Q(disable)
-
-// for callback class
-Q(init)
-Q(enable)
-Q(disable)
-Q(callback)
-Q(handler)
-Q(intmode)
-Q(value)
-Q(priority)
-Q(wakes)
-
-// for Sleep class
-Q(Sleep)
-Q(idle)
-Q(suspend)
-Q(hibernate)
-Q(reset_cause)
-Q(wake_reason)
-Q(ACTIVE)
-Q(SUSPENDED)
-Q(HIBERNATING)
-Q(PWR_ON_RESET)
-Q(HARD_RESET)
-Q(WDT_RESET)
-Q(HIB_RESET)
-Q(SOFT_RESET)
-Q(WLAN_WAKE)
-Q(PIN_WAKE)
-Q(RTC_WAKE)
-
-// for SPI class
-Q(SPI)
-Q(baudrate)
-Q(bits)
-Q(submode)
-Q(cs)
-Q(init)
-Q(deinit)
-Q(send)
-Q(recv)
-Q(send_recv)
-Q(ACTIVE_LOW)
-Q(ACTIVE_HIGH)
-
--- a/cc3200/serverstask.c
+++ b/cc3200/serverstask.c
@@ -25,40 +25,40 @@
 */

 #include <stdint.h>
+#include <string.h>

 #include "py/mpconfig.h"
-#include MICROPY_HAL_H
 #include "py/misc.h"
-#include "simplelink.h"
+#include "py/nlr.h"
+#include "py/mphal.h"
 #include "serverstask.h"
-#include "modwlan.h"
+#include "simplelink.h"
 #include "debug.h"
-#include "mpexception.h"
 #include "telnet.h"
 #include "ftp.h"
 #include "pybwdt.h"
-
-
-/******************************************************************************
- DECLARE PRIVATE DEFINITIONS
- ******************************************************************************/
-
-#define SERVERS_DEF_USER            "micro"
-#define SERVERS_DEF_PASS            "python"
+#include "modusocket.h"
+#include "mpexception.h"
+#include "modnetwork.h"
+#include "modwlan.h"

 /******************************************************************************
 DEFINE PRIVATE TYPES
 ******************************************************************************/
 typedef struct {
-    volatile bool enabled;
-    volatile bool do_disable;
-    volatile bool do_enable;
-}servers_Data_t;
+    uint32_t timeout;
+    bool enabled;
+    bool do_disable;
+    bool do_enable;
+    bool do_reset;
+    bool do_wlan_cycle_power;
+} servers_data_t;

 /******************************************************************************
 DECLARE PRIVATE DATA
 ******************************************************************************/
-static servers_Data_t servers_data = {.enabled = false, .do_disable = false, .do_enable = false};
+static servers_data_t servers_data = {.timeout = SERVERS_DEF_TIMEOUT_MS};
+static volatile bool sleep_sockets = false;

 /******************************************************************************
 DECLARE PRIVATE FUNCTIONS
@@ -67,8 +67,8 @@ static servers_Data_t servers_data = {.enabled = false, .do_disable = false, .do
 /******************************************************************************
 DECLARE PUBLIC DATA
 ******************************************************************************/
-char *servers_user;
-char *servers_pass;
+char servers_user[SERVERS_USER_PASS_LEN_MAX + 1];
+char servers_pass[SERVERS_USER_PASS_LEN_MAX + 1];

 /******************************************************************************
 DECLARE PUBLIC FUNCTIONS
@@ -77,8 +77,6 @@ void TASK_Servers (void *pvParameters) {

    bool cycle = false;

-    ASSERT ((servers_user = mem_Malloc(SERVERS_USER_LEN_MAX + 1)) != NULL);
-    ASSERT ((servers_pass = mem_Malloc(SERVERS_PASS_LEN_MAX + 1)) != NULL);
    strcpy (servers_user, SERVERS_DEF_USER);
    strcpy (servers_pass, SERVERS_DEF_PASS);

@@ -87,25 +85,7 @@ void TASK_Servers (void *pvParameters) {

    for ( ;; ) {

-        if (servers_data.enabled) {
-            if (servers_data.do_disable) {
-                // disable network services
-                telnet_disable();
-                ftp_disable();
-                // now clear the flags
-                servers_data.do_disable = false;
-                servers_data.enabled = false;
-            }
-            else {
-                if (cycle) {
-                    telnet_run();
-                }
-                else {
-                    ftp_run();
-                }
-            }
-        }
-        else if (servers_data.do_enable) {
+        if (servers_data.do_enable) {
            // enable network services
            telnet_enable();
            ftp_enable();
@@ -113,42 +93,111 @@ void TASK_Servers (void *pvParameters) {
            servers_data.enabled = true;
            servers_data.do_enable = false;
        }
+        else if (servers_data.do_disable) {
+            // disable network services
+            telnet_disable();
+            ftp_disable();
+            // now clear the flags
+            servers_data.do_disable = false;
+            servers_data.enabled = false;
+        }
+        else if (servers_data.do_reset) {
+            // resetting the servers is needed to prevent half-open sockets
+            servers_data.do_reset = false;
+            if (servers_data.enabled) {
+                telnet_reset();
+                ftp_reset();
+            }
+            // and we should also close all user sockets. We do it here
+            // for convinience and to save on code size.
+            modusocket_close_all_user_sockets();
+        }
+
+        if (cycle) {
+            telnet_run();
+        }
+        else {
+            ftp_run();
+        }
+
+        if (sleep_sockets) {
+            pybwdt_srv_sleeping(true);
+            modusocket_enter_sleep();
+            pybwdt_srv_sleeping(false);
+            mp_hal_delay_ms(SERVERS_CYCLE_TIME_MS * 2);
+            if (servers_data.do_wlan_cycle_power) {
+                servers_data.do_wlan_cycle_power = false;
+                wlan_off_on();
+            }
+            sleep_sockets = false;
+
+        }
+
+        // set the alive flag for the wdt
+        pybwdt_srv_alive();

        // move to the next cycle
        cycle = cycle ? false : true;
-        HAL_Delay(SERVERS_CYCLE_TIME_MS);
-        // set the alive flag for the wdt
-        pybwdt_srv_alive();
+        mp_hal_delay_ms(SERVERS_CYCLE_TIME_MS);
    }
 }

 void servers_start (void) {
-    servers_data.do_disable = false;
    servers_data.do_enable = true;
+    mp_hal_delay_ms(SERVERS_CYCLE_TIME_MS * 3);
 }

 void servers_stop (void) {
-    servers_data.do_enable = false;
    servers_data.do_disable = true;
    do {
-        HAL_Delay (SERVERS_CYCLE_TIME_MS);
+        mp_hal_delay_ms(SERVERS_CYCLE_TIME_MS);
    } while (servers_are_enabled());
+    mp_hal_delay_ms(SERVERS_CYCLE_TIME_MS * 3);
+}
+
+void servers_reset (void) {
+    servers_data.do_reset = true;
+}
+
+void servers_wlan_cycle_power (void) {
+    servers_data.do_wlan_cycle_power = true;
 }

 bool servers_are_enabled (void) {
    return servers_data.enabled;
 }

+void server_sleep_sockets (void) {
+    sleep_sockets = true;
+    mp_hal_delay_ms(SERVERS_CYCLE_TIME_MS + 1);
+}
+
 void servers_close_socket (int16_t *sd) {
    if (*sd > 0) {
+        modusocket_socket_delete(*sd);
        sl_Close(*sd);
        *sd = -1;
    }
 }

 void servers_set_login (char *user, char *pass) {
-    memcpy(servers_user, user, SERVERS_USER_LEN_MAX);
-    memcpy(servers_pass, pass, SERVERS_PASS_LEN_MAX);
+    if (strlen(user) > SERVERS_USER_PASS_LEN_MAX || strlen(pass) > SERVERS_USER_PASS_LEN_MAX) {
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
+    }
+    memcpy(servers_user, user, SERVERS_USER_PASS_LEN_MAX);
+    memcpy(servers_pass, pass, SERVERS_USER_PASS_LEN_MAX);
+}
+
+void servers_set_timeout (uint32_t timeout) {
+    if (timeout < SERVERS_MIN_TIMEOUT_MS) {
+        // timeout is too low
+        nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, mpexception_value_invalid_arguments));
+    }
+    servers_data.timeout = timeout;
+}
+
+uint32_t servers_get_timeout (void) {
+    return servers_data.timeout;
 }

 /******************************************************************************
--- a/cc3200/serverstask.h
+++ b/cc3200/serverstask.h
@@ -31,15 +31,19 @@
 DEFINE CONSTANTS
 ******************************************************************************/
 #define SERVERS_PRIORITY                        2
-#define SERVERS_STACK_SIZE                      1072
+#define SERVERS_STACK_SIZE                      1024

 #define SERVERS_SSID_LEN_MAX                    16
 #define SERVERS_KEY_LEN_MAX                     16

-#define SERVERS_USER_LEN_MAX                    16
-#define SERVERS_PASS_LEN_MAX                    16
+#define SERVERS_USER_PASS_LEN_MAX               32

-#define SERVERS_CYCLE_TIME_MS                   5
+#define SERVERS_CYCLE_TIME_MS                   2
+
+#define SERVERS_DEF_USER                        "micro"
+#define SERVERS_DEF_PASS                        "python"
+#define SERVERS_DEF_TIMEOUT_MS                  300000        // 5 minutes
+#define SERVERS_MIN_TIMEOUT_MS                  5000          // 5 seconds

 /******************************************************************************
 DEFINE TYPES
@@ -48,8 +52,8 @@
 /******************************************************************************
 EXPORTED DATA
 ******************************************************************************/
-extern char *servers_user;
-extern char *servers_pass;
+extern char servers_user[];
+extern char servers_pass[];

 /******************************************************************************
 DECLARE PUBLIC FUNCTIONS
@@ -57,8 +61,13 @@ extern char *servers_pass;
 extern void TASK_Servers (void *pvParameters);
 extern void servers_start (void);
 extern void servers_stop (void);
+extern void servers_reset (void);
+extern void servers_wlan_cycle_power (void);
 extern bool servers_are_enabled (void);
 extern void servers_close_socket (int16_t *sd);
 extern void servers_set_login (char *user, char *pass);
+extern void server_sleep_sockets (void);
+extern void servers_set_timeout (uint32_t timeout);
+extern uint32_t servers_get_timeout (void);

 #endif /* SERVERSTASK_H_ */
--- a/cc3200/simplelink/oslib/osi_freertos.c
+++ b/cc3200/simplelink/oslib/osi_freertos.c
@@ -44,9 +44,7 @@
 #include "task.h"
 #include "semphr.h"
 #include "portmacro.h"
-#include <osi.h>
-
-#include "rom.h"
+#include "osi.h"
 #include "rom_map.h"
 #include "inc/hw_types.h"
 #include "interrupt.h"
@@ -457,7 +455,7 @@ OsiReturnVal_e VStartSimpleLinkSpawnTask(unsigned portBASE_TYPE uxPriority)
    ASSERT (xSimpleLinkSpawnQueue != NULL);

    ASSERT (pdPASS == xTaskCreate( vSimpleLinkSpawnTask, ( portCHAR * ) "SLSPAWN",\
-    					           736 / sizeof(portSTACK_TYPE), NULL, uxPriority, &xSimpleLinkSpawnTaskHndl ));
+                                   896 / sizeof(portSTACK_TYPE), NULL, uxPriority, &xSimpleLinkSpawnTaskHndl ));

    return OSI_OK;
 }
--- a/Show More
+++ b/Show More